tests/libkshark-tests.cpp - pub/scm/utils/trace-cmd/kernel-shark - Git at Google

 // SPDX-License-Identifier: LGPL-2.1

 /*
  * Copyright (C) 2020 VMware Inc, Yordan Karadzhov (VMware) <y.karadz@gmail.com>
  */

 // Boost
 #define BOOST_TEST_MODULE KernelSharkTests
 #include <boost/test/unit_test.hpp>

 // KernelShark
 #include "libkshark.h"
 #include "libkshark-plugin.h"
 #include "KsCmakeDef.hpp"

 #define N_TEST_STREAMS	1000

 BOOST_AUTO_TEST_CASE(add_remove_streams)
 {
 	struct kshark_context *kshark_ctx = NULL;
 	int sd, free = 0, i;

 	BOOST_REQUIRE(kshark_instance(&kshark_ctx));

 	for (i = 0; i < N_TEST_STREAMS; ++i) {
 		sd = kshark_add_stream(kshark_ctx);
 		BOOST_CHECK_EQUAL(sd, free);

 		kshark_add_stream(kshark_ctx);

 		free = i / 2;
 		kshark_remove_stream(kshark_ctx, free);
 		sd = kshark_add_stream(kshark_ctx);
 		BOOST_CHECK_EQUAL(sd, free);

 		free = i / 2 + 1;
 		kshark_remove_stream(kshark_ctx, free);
 	}

 	BOOST_CHECK_EQUAL(kshark_ctx->n_streams, N_TEST_STREAMS);

 	while (sd > 0)
 		sd = kshark_add_stream(kshark_ctx);

 	BOOST_CHECK_EQUAL(kshark_ctx->n_streams, INT16_MAX + 1);
 	BOOST_CHECK_EQUAL(kshark_ctx->stream_info.array_size, INT16_MAX + 1);
 	BOOST_CHECK_EQUAL(sd, -ENODEV);

 	kshark_free(kshark_ctx);
 }

 BOOST_AUTO_TEST_CASE(get_stream)
 {
 	kshark_context *kshark_ctx(nullptr);
 	kshark_data_stream *stream;
 	int sd;

 	BOOST_REQUIRE(kshark_instance(&kshark_ctx));
 	sd = kshark_add_stream(kshark_ctx);
 	stream = kshark_get_data_stream(kshark_ctx, sd);
 	BOOST_CHECK_EQUAL(stream, nullptr);

 	kshark_ctx->stream[sd]->interface = malloc(1);
 	stream = kshark_get_data_stream(kshark_ctx, sd);
 	BOOST_CHECK(stream != nullptr);

 	kshark_free(kshark_ctx);
 }

 BOOST_AUTO_TEST_CASE(close_all)
 {
 	struct kshark_context *kshark_ctx(nullptr);
 	int sd, i;

 	BOOST_REQUIRE(kshark_instance(&kshark_ctx));
 	for (i = 0; i < N_TEST_STREAMS; ++i) {
 		sd = kshark_add_stream(kshark_ctx);
 		BOOST_CHECK_EQUAL(sd, i);
 	}

 	kshark_close_all(kshark_ctx);
 	BOOST_CHECK_EQUAL(kshark_ctx->n_streams, 0);
 	BOOST_CHECK_EQUAL(kshark_ctx->stream_info.next_free_stream_id, 0);
 	BOOST_CHECK_EQUAL(kshark_ctx->stream_info.max_stream_id, -1);
 	for (i = 0; i < kshark_ctx->stream_info.array_size; ++i)
 		BOOST_CHECK_EQUAL(kshark_ctx->stream[i], nullptr);
 }

 #define ARRAY_DEFAULT_SIZE	1000
 BOOST_AUTO_TEST_CASE(doule_size_macro)
 {
 	int i, n = ARRAY_DEFAULT_SIZE;
 	int *arr = (int *) malloc(n * sizeof(*arr));
 	bool ok;

 	for (i = 0; i < n; ++i)
 		arr[i] = i;

 	ok = KS_DOUBLE_SIZE(arr, n);
 	BOOST_CHECK_EQUAL(ok, true);
 	BOOST_CHECK_EQUAL(n, ARRAY_DEFAULT_SIZE * 2);

 	for (i = 0; i < ARRAY_DEFAULT_SIZE; ++i)
 		BOOST_CHECK_EQUAL(arr[i], i);
 	for (; i < n; ++i)
 		BOOST_CHECK_EQUAL(arr[i], 0);
 }

 #define N_VALUES	2 * KS_CONTAINER_DEFAULT_SIZE + 1
 #define MAX_TS		100000
 BOOST_AUTO_TEST_CASE(fill_data_container)
 {
 	struct kshark_data_container *data = kshark_init_data_container();
 	struct kshark_entry entries[N_VALUES];
 	int64_t i, ts_last(0);

 	BOOST_CHECK_EQUAL(data->capacity, KS_CONTAINER_DEFAULT_SIZE);

 	for (i = 0; i < N_VALUES; ++i) {
 		entries[i].ts = rand() % MAX_TS;
 		kshark_data_container_append(data, &entries[i], 10 - entries[i].ts);
 	}

 	BOOST_CHECK_EQUAL(data->size, N_VALUES);
 	BOOST_CHECK_EQUAL(data->capacity, 4 * KS_CONTAINER_DEFAULT_SIZE);

 	kshark_data_container_sort(data);
 	BOOST_CHECK_EQUAL(data->capacity, N_VALUES);
 	for (i = 0; i < N_VALUES; ++i) {
 		BOOST_CHECK(data->data[i]->entry->ts >= ts_last);
 		BOOST_CHECK_EQUAL(data->data[i]->entry->ts,
 				  10 - data->data[i]->field);

 		ts_last = data->data[i]->entry->ts;
 	}

 	i = kshark_find_entry_field_by_time(MAX_TS / 2, data->data,
 					    0, N_VALUES - 1);

 	BOOST_CHECK(data->data[i - 1]->entry->ts < MAX_TS / 2);
 	BOOST_CHECK(data->data[i]->entry->ts >= MAX_TS / 2);

 	kshark_free_data_container(data);
 }

 struct test_context {
 	int a;
 	char b;
 };

 KS_DEFINE_PLUGIN_CONTEXT(struct test_context, free);

 BOOST_AUTO_TEST_CASE(init_close_plugin)
 {
 	struct test_context *ctx;
 	int i;

 	for (i = 0; i < N_TEST_STREAMS; ++i) {
 		ctx = __init(i);
 		ctx->a = i * 10;
 		ctx->b = 'z';
 	}

 	for (i = 0; i < N_TEST_STREAMS; ++i) {
 		ctx = __get_context(i);
 		BOOST_REQUIRE(ctx != NULL);
 		BOOST_CHECK_EQUAL(ctx->a, i * 10);
 		BOOST_CHECK_EQUAL(ctx->b, 'z');

 		__close(i);
 		BOOST_REQUIRE(__get_context(i) == NULL);
 	}

 	__close(-1);
 }

 #define PLUGIN_1_LIB	"/plugin-dummy_dpi.so"
 #define PLUGIN_1_NAME	"dummy_dpi"

 #define PLUGIN_2_LIB	"/plugin-dummy_dpi_ctrl.so"
 #define PLUGIN_2_NAME	"dummy_dpi_ctrl"

 #define INPUT_A_LIB	"/input-dummy_input.so"
 #define INPUT_A_NAME	"dummy_input"

 #define INPUT_B_LIB	"/input-dummy_input_ctrl.so"
 #define INPUT_B_NAME	"dummy_input_ctrl"

 std::string path(KS_TEST_DIR);

 BOOST_AUTO_TEST_CASE(register_plugin)
 {
 	kshark_plugin_list *p1, *p2, *i1, *i2, *x1, *x2;
 	kshark_generic_stream_interface *interface;
 	kshark_context *kshark_ctx(nullptr);
 	kshark_data_stream *stream;
 	std::string plugin;
 	int sd;

 	BOOST_REQUIRE(kshark_instance(&kshark_ctx));
 	BOOST_REQUIRE(kshark_ctx->plugins == nullptr);
 	BOOST_REQUIRE(kshark_ctx->inputs == nullptr);
 	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 0);

 	plugin = path + PLUGIN_1_LIB;
 	p1 = kshark_register_plugin(kshark_ctx, PLUGIN_1_NAME, plugin.c_str());
 	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 1);
 	BOOST_CHECK(kshark_ctx->plugins != nullptr);
 	BOOST_CHECK_EQUAL(kshark_ctx->plugins->next, nullptr);
 	BOOST_CHECK_EQUAL(kshark_ctx->plugins, p1);
 	BOOST_CHECK(p1 != nullptr);
 	BOOST_CHECK(p1->process_interface != nullptr);
 	BOOST_CHECK(p1->handle != nullptr);
 	BOOST_CHECK_EQUAL(strcmp(p1->file, plugin.c_str()), 0);
 	BOOST_CHECK_EQUAL(strcmp(p1->name, PLUGIN_1_NAME), 0);

 	BOOST_CHECK_EQUAL(p1->ctrl_interface, nullptr);
 	BOOST_CHECK_EQUAL(p1->readout_interface, nullptr);

 	plugin = path + PLUGIN_2_LIB;
 	p2 = kshark_register_plugin(kshark_ctx, PLUGIN_2_NAME, plugin.c_str());
 	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 2);
 	BOOST_CHECK_EQUAL(kshark_ctx->plugins, p2);
 	BOOST_CHECK_EQUAL(kshark_ctx->plugins->next, p1);
 	BOOST_CHECK(p2 != nullptr);
 	BOOST_CHECK(p2->process_interface != nullptr);
 	BOOST_CHECK(p2->handle != nullptr);
 	BOOST_CHECK_EQUAL(strcmp(p2->file, plugin.c_str()), 0);
 	BOOST_CHECK_EQUAL(strcmp(p2->name, PLUGIN_2_NAME), 0);
 	BOOST_CHECK(p2->ctrl_interface != nullptr);

 	BOOST_CHECK_EQUAL(p2->readout_interface, nullptr);

 	plugin = path + INPUT_A_LIB;
 	i1 = kshark_register_plugin(kshark_ctx, INPUT_A_NAME, plugin.c_str());
 	BOOST_CHECK(i1 != nullptr);
 	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 3);
 	BOOST_CHECK_EQUAL(kshark_ctx->n_inputs, 1);
 	BOOST_CHECK(kshark_ctx->inputs != nullptr);
 	BOOST_CHECK(i1->readout_interface != nullptr);
 	BOOST_CHECK(i1->handle != nullptr);
 	BOOST_CHECK_EQUAL(strcmp(i1->file, plugin.c_str()), 0);
 	BOOST_CHECK_EQUAL(strcmp(i1->name, INPUT_A_NAME), 0);

 	BOOST_CHECK_EQUAL(i1->ctrl_interface, nullptr);
 	BOOST_CHECK_EQUAL(i1->process_interface, nullptr);

 	plugin = path + INPUT_B_LIB;
 	i2 = kshark_register_plugin(kshark_ctx, INPUT_B_NAME, plugin.c_str());
 	BOOST_CHECK(i2 != nullptr);
 	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 4);
 	BOOST_CHECK_EQUAL(kshark_ctx->n_inputs, 2);
 	BOOST_CHECK(i2->readout_interface != nullptr);
 	BOOST_CHECK(i2->handle != nullptr);
 	BOOST_CHECK(strcmp(i2->file, plugin.c_str()) == 0);
 	BOOST_CHECK(strcmp(i2->name, INPUT_B_NAME) == 0);
 	BOOST_CHECK(i2->ctrl_interface != nullptr);

 	BOOST_CHECK_EQUAL(i2->process_interface, nullptr);

 	x1 = kshark_find_plugin_by_name(kshark_ctx->plugins, PLUGIN_2_NAME);
 	BOOST_CHECK_EQUAL(x1, p2);

 	plugin = path + PLUGIN_2_LIB;
 	x2 = kshark_find_plugin(kshark_ctx->plugins, plugin.c_str());

 	BOOST_CHECK_EQUAL(x2, p2);

 	sd = kshark_add_stream(kshark_ctx);
 	interface =
 		(kshark_generic_stream_interface *) malloc(sizeof(*interface));
 	kshark_ctx->stream[sd]->interface = interface;
 	BOOST_CHECK_EQUAL(sd, 0);

 	stream = kshark_get_data_stream(kshark_ctx, sd);
 	BOOST_CHECK(stream != nullptr);

 	BOOST_CHECK_EQUAL(stream->plugins, nullptr);
 	kshark_register_plugin_to_stream(stream,
 					 p1->process_interface,
 					 true);
 	BOOST_CHECK_EQUAL(stream->n_plugins, 1);
 	BOOST_CHECK_EQUAL(stream->plugins->interface, p1->process_interface);
 	BOOST_CHECK_EQUAL(stream->plugins->next, nullptr);

 	kshark_register_plugin_to_stream(stream,
 					 p2->process_interface,
 					 true);
 	BOOST_CHECK_EQUAL(stream->n_plugins, 2);
 	BOOST_CHECK_EQUAL(stream->plugins->interface, p2->process_interface);
 	BOOST_CHECK_EQUAL(stream->plugins->next->interface, p1->process_interface);

 	kshark_unregister_plugin_from_stream(stream, p1->process_interface);
 	BOOST_CHECK_EQUAL(stream->n_plugins, 1);
 	BOOST_CHECK_EQUAL(stream->plugins->interface, p2->process_interface);
 	BOOST_CHECK_EQUAL(stream->plugins->next, nullptr);

 	kshark_free(kshark_ctx);
 }

 #define PLUGIN_ERR_LIB	"/plugin-dummy_dpi_err.so"
 #define PLUGIN_ERR_NAME	"dummy_dpi_err"

 BOOST_AUTO_TEST_CASE(handle_plugin)
 {
 	kshark_dpi_list *dpi1, *dpi2, *dpi_err;
 	kshark_plugin_list *p1, *p2, *p_err;
 	kshark_context *kshark_ctx(nullptr);
 	kshark_data_stream *stream;
 	std::string plugin;
 	int sd, ret;

 	BOOST_REQUIRE(kshark_instance(&kshark_ctx));
 	BOOST_CHECK_EQUAL(kshark_ctx->plugins, nullptr);
 	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 0);

 	plugin = path + PLUGIN_1_LIB;
 	p1 = kshark_register_plugin(kshark_ctx, PLUGIN_1_NAME, plugin.c_str());

 	plugin = path + PLUGIN_2_LIB;
 	p2 = kshark_register_plugin(kshark_ctx, PLUGIN_2_NAME, plugin.c_str());
 	BOOST_CHECK(kshark_ctx->plugins != nullptr);
 	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 2);

 	sd = kshark_add_stream(kshark_ctx);
 	kshark_ctx->stream[sd]->interface = malloc(1);
 	stream = kshark_get_data_stream(kshark_ctx, sd);
 	BOOST_CHECK(stream != nullptr);

 	dpi1 = kshark_register_plugin_to_stream(stream,
 						p1->process_interface,
 						true);
 	BOOST_CHECK_EQUAL(dpi1->status, KSHARK_PLUGIN_ENABLED);

 	dpi2 = kshark_register_plugin_to_stream(stream,
 						p2->process_interface,
 						false);
 	BOOST_CHECK_EQUAL(dpi2->status, 0);

 	ret = kshark_handle_dpi(stream, dpi1, KSHARK_PLUGIN_INIT);
 	BOOST_CHECK_EQUAL(ret, 1);
 	BOOST_CHECK_EQUAL(dpi1->status,
 			  KSHARK_PLUGIN_LOADED | KSHARK_PLUGIN_ENABLED);

 	ret = kshark_handle_dpi(stream, dpi2, KSHARK_PLUGIN_INIT);
 	BOOST_CHECK_EQUAL(ret, 0);
 	BOOST_CHECK_EQUAL(dpi2->status, 0);

 	dpi2->status |= KSHARK_PLUGIN_ENABLED;
 	ret = kshark_handle_dpi(stream, dpi2, KSHARK_PLUGIN_INIT);
 	BOOST_CHECK_EQUAL(ret, 2);
 	BOOST_CHECK_EQUAL(dpi1->status,
 			  KSHARK_PLUGIN_LOADED | KSHARK_PLUGIN_ENABLED);

 	ret = kshark_handle_all_dpis(stream, KSHARK_PLUGIN_UPDATE);
 	BOOST_CHECK_EQUAL(ret, 0);
 	BOOST_CHECK_EQUAL(dpi1->status,
 			  KSHARK_PLUGIN_LOADED | KSHARK_PLUGIN_ENABLED);
 	BOOST_CHECK_EQUAL(dpi2->status,
 			  KSHARK_PLUGIN_LOADED | KSHARK_PLUGIN_ENABLED);

 	plugin = path + PLUGIN_ERR_LIB;
 	p_err = kshark_register_plugin(kshark_ctx, PLUGIN_ERR_NAME,
 				       plugin.c_str());
 	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 3);
 	dpi_err = kshark_register_plugin_to_stream(stream,
 						   p_err->process_interface,
 						   true);
 	BOOST_CHECK_EQUAL(ret, 0);
 	ret = kshark_handle_dpi(stream, dpi_err, KSHARK_PLUGIN_INIT);
 	BOOST_CHECK_EQUAL(dpi_err->status,
 			  KSHARK_PLUGIN_FAILED | KSHARK_PLUGIN_ENABLED);
 	BOOST_CHECK_EQUAL(ret, 0);
 	ret = kshark_handle_dpi(stream, dpi_err, KSHARK_PLUGIN_CLOSE);
 	BOOST_CHECK_EQUAL(ret, 0);
 	BOOST_CHECK_EQUAL(dpi_err->status, KSHARK_PLUGIN_ENABLED);

 	ret = kshark_handle_all_dpis(stream, KSHARK_PLUGIN_CLOSE);
 	BOOST_CHECK_EQUAL(ret, -3);

 	kshark_free(kshark_ctx);
 }

 #define FAKE_DATA_FILE_A	"test.ta"
 #define FAKE_DATA_A_SIZE	200

 #define FAKE_DATA_FILE_B	"test.tb"
 #define FAKE_DATA_B_SIZE	100

 BOOST_AUTO_TEST_CASE(readout_plugins)
 {
 	kshark_context *kshark_ctx(nullptr);
 	kshark_entry **entries{nullptr};
 	kshark_data_stream *stream;
 	std::string plugin, data;
 	int sd, i, n_entries;
 	int64_t ts_last(0);

 	BOOST_REQUIRE(kshark_instance(&kshark_ctx));

 	plugin = path + INPUT_A_LIB;
 	kshark_register_plugin(kshark_ctx, INPUT_A_NAME, plugin.c_str());
 	plugin = path + INPUT_B_LIB;
 	kshark_register_plugin(kshark_ctx, INPUT_B_NAME, plugin.c_str());

 	data = FAKE_DATA_FILE_A;
 	sd = kshark_open(kshark_ctx, data.c_str());
 	BOOST_CHECK_EQUAL(sd, 0);

 	stream = kshark_get_data_stream(kshark_ctx, sd);
 	BOOST_CHECK(stream != nullptr);
 	BOOST_CHECK(stream->interface != nullptr);
 	BOOST_CHECK_EQUAL(strcmp(stream->data_format, "format_a"), 0);

 	data = FAKE_DATA_FILE_B;
 	sd = kshark_open(kshark_ctx, data.c_str());
 	BOOST_CHECK_EQUAL(sd, 1);

 	stream = kshark_get_data_stream(kshark_ctx, sd);
 	BOOST_CHECK(stream != nullptr);
 	BOOST_CHECK(stream->interface != nullptr);
 	BOOST_CHECK_EQUAL(strcmp(stream->data_format, "format_b"), 0);

 	n_entries = kshark_load_all_entries(kshark_ctx, &entries);
 	BOOST_CHECK_EQUAL(n_entries, FAKE_DATA_A_SIZE + FAKE_DATA_B_SIZE);

 	for (i = 0; i < n_entries; ++i) {
 		BOOST_CHECK(ts_last <= entries[i]->ts);
 		ts_last = entries[i]->ts;
 	}

 	for (i = 0; i < n_entries; ++i)
 		free(entries[i]);
 	free(entries);

 	kshark_free(kshark_ctx);
 }

 BOOST_AUTO_TEST_CASE(check_font_found)
 {
 #ifdef TT_FONT_FILE
 BOOST_REQUIRE(true);
 #else
 BOOST_REQUIRE(false);
 #endif
 }
	// SPDX-License-Identifier: LGPL-2.1

	/*
	* Copyright (C) 2020 VMware Inc, Yordan Karadzhov (VMware) <y.karadz@gmail.com>
	*/

	// Boost
	#define BOOST_TEST_MODULE KernelSharkTests
	#include <boost/test/unit_test.hpp>

	// KernelShark
	#include "libkshark.h"
	#include "libkshark-plugin.h"
	#include "KsCmakeDef.hpp"

	#define N_TEST_STREAMS 1000

	BOOST_AUTO_TEST_CASE(add_remove_streams)
	{
	struct kshark_context *kshark_ctx = NULL;
	int sd, free = 0, i;

	BOOST_REQUIRE(kshark_instance(&kshark_ctx));

	for (i = 0; i < N_TEST_STREAMS; ++i) {
	sd = kshark_add_stream(kshark_ctx);
	BOOST_CHECK_EQUAL(sd, free);

	kshark_add_stream(kshark_ctx);

	free = i / 2;
	kshark_remove_stream(kshark_ctx, free);
	sd = kshark_add_stream(kshark_ctx);
	BOOST_CHECK_EQUAL(sd, free);

	free = i / 2 + 1;
	kshark_remove_stream(kshark_ctx, free);
	}

	BOOST_CHECK_EQUAL(kshark_ctx->n_streams, N_TEST_STREAMS);

	while (sd > 0)
	sd = kshark_add_stream(kshark_ctx);

	BOOST_CHECK_EQUAL(kshark_ctx->n_streams, INT16_MAX + 1);
	BOOST_CHECK_EQUAL(kshark_ctx->stream_info.array_size, INT16_MAX + 1);
	BOOST_CHECK_EQUAL(sd, -ENODEV);

	kshark_free(kshark_ctx);
	}

	BOOST_AUTO_TEST_CASE(get_stream)
	{
	kshark_context *kshark_ctx(nullptr);
	kshark_data_stream *stream;
	int sd;

	BOOST_REQUIRE(kshark_instance(&kshark_ctx));
	sd = kshark_add_stream(kshark_ctx);
	stream = kshark_get_data_stream(kshark_ctx, sd);
	BOOST_CHECK_EQUAL(stream, nullptr);

	kshark_ctx->stream[sd]->interface = malloc(1);
	stream = kshark_get_data_stream(kshark_ctx, sd);
	BOOST_CHECK(stream != nullptr);

	kshark_free(kshark_ctx);
	}

	BOOST_AUTO_TEST_CASE(close_all)
	{
	struct kshark_context *kshark_ctx(nullptr);
	int sd, i;

	BOOST_REQUIRE(kshark_instance(&kshark_ctx));
	for (i = 0; i < N_TEST_STREAMS; ++i) {
	sd = kshark_add_stream(kshark_ctx);
	BOOST_CHECK_EQUAL(sd, i);
	}

	kshark_close_all(kshark_ctx);
	BOOST_CHECK_EQUAL(kshark_ctx->n_streams, 0);
	BOOST_CHECK_EQUAL(kshark_ctx->stream_info.next_free_stream_id, 0);
	BOOST_CHECK_EQUAL(kshark_ctx->stream_info.max_stream_id, -1);
	for (i = 0; i < kshark_ctx->stream_info.array_size; ++i)
	BOOST_CHECK_EQUAL(kshark_ctx->stream[i], nullptr);
	}

	#define ARRAY_DEFAULT_SIZE 1000
	BOOST_AUTO_TEST_CASE(doule_size_macro)
	{
	int i, n = ARRAY_DEFAULT_SIZE;
	int arr = (int ) malloc(n * sizeof(*arr));
	bool ok;

	for (i = 0; i < n; ++i)
	arr[i] = i;

	ok = KS_DOUBLE_SIZE(arr, n);
	BOOST_CHECK_EQUAL(ok, true);
	BOOST_CHECK_EQUAL(n, ARRAY_DEFAULT_SIZE * 2);

	for (i = 0; i < ARRAY_DEFAULT_SIZE; ++i)
	BOOST_CHECK_EQUAL(arr[i], i);
	for (; i < n; ++i)
	BOOST_CHECK_EQUAL(arr[i], 0);
	}

	#define N_VALUES 2 * KS_CONTAINER_DEFAULT_SIZE + 1
	#define MAX_TS 100000
	BOOST_AUTO_TEST_CASE(fill_data_container)
	{
	struct kshark_data_container *data = kshark_init_data_container();
	struct kshark_entry entries[N_VALUES];
	int64_t i, ts_last(0);

	BOOST_CHECK_EQUAL(data->capacity, KS_CONTAINER_DEFAULT_SIZE);

	for (i = 0; i < N_VALUES; ++i) {
	entries[i].ts = rand() % MAX_TS;
	kshark_data_container_append(data, &entries[i], 10 - entries[i].ts);
	}

	BOOST_CHECK_EQUAL(data->size, N_VALUES);
	BOOST_CHECK_EQUAL(data->capacity, 4 * KS_CONTAINER_DEFAULT_SIZE);

	kshark_data_container_sort(data);
	BOOST_CHECK_EQUAL(data->capacity, N_VALUES);
	for (i = 0; i < N_VALUES; ++i) {
	BOOST_CHECK(data->data[i]->entry->ts >= ts_last);
	BOOST_CHECK_EQUAL(data->data[i]->entry->ts,
	10 - data->data[i]->field);

	ts_last = data->data[i]->entry->ts;
	}

	i = kshark_find_entry_field_by_time(MAX_TS / 2, data->data,
	0, N_VALUES - 1);

	BOOST_CHECK(data->data[i - 1]->entry->ts < MAX_TS / 2);
	BOOST_CHECK(data->data[i]->entry->ts >= MAX_TS / 2);

	kshark_free_data_container(data);
	}

	struct test_context {
	int a;
	char b;
	};

	KS_DEFINE_PLUGIN_CONTEXT(struct test_context, free);

	BOOST_AUTO_TEST_CASE(init_close_plugin)
	{
	struct test_context *ctx;
	int i;

	for (i = 0; i < N_TEST_STREAMS; ++i) {
	ctx = __init(i);
	ctx->a = i * 10;
	ctx->b = 'z';
	}

	for (i = 0; i < N_TEST_STREAMS; ++i) {
	ctx = __get_context(i);
	BOOST_REQUIRE(ctx != NULL);
	BOOST_CHECK_EQUAL(ctx->a, i * 10);
	BOOST_CHECK_EQUAL(ctx->b, 'z');

	__close(i);
	BOOST_REQUIRE(__get_context(i) == NULL);
	}

	__close(-1);
	}

	#define PLUGIN_1_LIB "/plugin-dummy_dpi.so"
	#define PLUGIN_1_NAME "dummy_dpi"

	#define PLUGIN_2_LIB "/plugin-dummy_dpi_ctrl.so"
	#define PLUGIN_2_NAME "dummy_dpi_ctrl"

	#define INPUT_A_LIB "/input-dummy_input.so"
	#define INPUT_A_NAME "dummy_input"

	#define INPUT_B_LIB "/input-dummy_input_ctrl.so"
	#define INPUT_B_NAME "dummy_input_ctrl"

	std::string path(KS_TEST_DIR);

	BOOST_AUTO_TEST_CASE(register_plugin)
	{
	kshark_plugin_list p1, p2, i1, i2, x1, x2;
	kshark_generic_stream_interface *interface;
	kshark_context *kshark_ctx(nullptr);
	kshark_data_stream *stream;
	std::string plugin;
	int sd;

	BOOST_REQUIRE(kshark_instance(&kshark_ctx));
	BOOST_REQUIRE(kshark_ctx->plugins == nullptr);
	BOOST_REQUIRE(kshark_ctx->inputs == nullptr);
	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 0);

	plugin = path + PLUGIN_1_LIB;
	p1 = kshark_register_plugin(kshark_ctx, PLUGIN_1_NAME, plugin.c_str());
	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 1);
	BOOST_CHECK(kshark_ctx->plugins != nullptr);
	BOOST_CHECK_EQUAL(kshark_ctx->plugins->next, nullptr);
	BOOST_CHECK_EQUAL(kshark_ctx->plugins, p1);
	BOOST_CHECK(p1 != nullptr);
	BOOST_CHECK(p1->process_interface != nullptr);
	BOOST_CHECK(p1->handle != nullptr);
	BOOST_CHECK_EQUAL(strcmp(p1->file, plugin.c_str()), 0);
	BOOST_CHECK_EQUAL(strcmp(p1->name, PLUGIN_1_NAME), 0);

	BOOST_CHECK_EQUAL(p1->ctrl_interface, nullptr);
	BOOST_CHECK_EQUAL(p1->readout_interface, nullptr);

	plugin = path + PLUGIN_2_LIB;
	p2 = kshark_register_plugin(kshark_ctx, PLUGIN_2_NAME, plugin.c_str());
	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 2);
	BOOST_CHECK_EQUAL(kshark_ctx->plugins, p2);
	BOOST_CHECK_EQUAL(kshark_ctx->plugins->next, p1);
	BOOST_CHECK(p2 != nullptr);
	BOOST_CHECK(p2->process_interface != nullptr);
	BOOST_CHECK(p2->handle != nullptr);
	BOOST_CHECK_EQUAL(strcmp(p2->file, plugin.c_str()), 0);
	BOOST_CHECK_EQUAL(strcmp(p2->name, PLUGIN_2_NAME), 0);
	BOOST_CHECK(p2->ctrl_interface != nullptr);

	BOOST_CHECK_EQUAL(p2->readout_interface, nullptr);

	plugin = path + INPUT_A_LIB;
	i1 = kshark_register_plugin(kshark_ctx, INPUT_A_NAME, plugin.c_str());
	BOOST_CHECK(i1 != nullptr);
	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 3);
	BOOST_CHECK_EQUAL(kshark_ctx->n_inputs, 1);
	BOOST_CHECK(kshark_ctx->inputs != nullptr);
	BOOST_CHECK(i1->readout_interface != nullptr);
	BOOST_CHECK(i1->handle != nullptr);
	BOOST_CHECK_EQUAL(strcmp(i1->file, plugin.c_str()), 0);
	BOOST_CHECK_EQUAL(strcmp(i1->name, INPUT_A_NAME), 0);

	BOOST_CHECK_EQUAL(i1->ctrl_interface, nullptr);
	BOOST_CHECK_EQUAL(i1->process_interface, nullptr);

	plugin = path + INPUT_B_LIB;
	i2 = kshark_register_plugin(kshark_ctx, INPUT_B_NAME, plugin.c_str());
	BOOST_CHECK(i2 != nullptr);
	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 4);
	BOOST_CHECK_EQUAL(kshark_ctx->n_inputs, 2);
	BOOST_CHECK(i2->readout_interface != nullptr);
	BOOST_CHECK(i2->handle != nullptr);
	BOOST_CHECK(strcmp(i2->file, plugin.c_str()) == 0);
	BOOST_CHECK(strcmp(i2->name, INPUT_B_NAME) == 0);
	BOOST_CHECK(i2->ctrl_interface != nullptr);

	BOOST_CHECK_EQUAL(i2->process_interface, nullptr);

	x1 = kshark_find_plugin_by_name(kshark_ctx->plugins, PLUGIN_2_NAME);
	BOOST_CHECK_EQUAL(x1, p2);

	plugin = path + PLUGIN_2_LIB;
	x2 = kshark_find_plugin(kshark_ctx->plugins, plugin.c_str());

	BOOST_CHECK_EQUAL(x2, p2);

	sd = kshark_add_stream(kshark_ctx);
	interface =
	(kshark_generic_stream_interface ) malloc(sizeof(interface));
	kshark_ctx->stream[sd]->interface = interface;
	BOOST_CHECK_EQUAL(sd, 0);

	stream = kshark_get_data_stream(kshark_ctx, sd);
	BOOST_CHECK(stream != nullptr);

	BOOST_CHECK_EQUAL(stream->plugins, nullptr);
	kshark_register_plugin_to_stream(stream,
	p1->process_interface,
	true);
	BOOST_CHECK_EQUAL(stream->n_plugins, 1);
	BOOST_CHECK_EQUAL(stream->plugins->interface, p1->process_interface);
	BOOST_CHECK_EQUAL(stream->plugins->next, nullptr);

	kshark_register_plugin_to_stream(stream,
	p2->process_interface,
	true);
	BOOST_CHECK_EQUAL(stream->n_plugins, 2);
	BOOST_CHECK_EQUAL(stream->plugins->interface, p2->process_interface);
	BOOST_CHECK_EQUAL(stream->plugins->next->interface, p1->process_interface);

	kshark_unregister_plugin_from_stream(stream, p1->process_interface);
	BOOST_CHECK_EQUAL(stream->n_plugins, 1);
	BOOST_CHECK_EQUAL(stream->plugins->interface, p2->process_interface);
	BOOST_CHECK_EQUAL(stream->plugins->next, nullptr);

	kshark_free(kshark_ctx);
	}

	#define PLUGIN_ERR_LIB "/plugin-dummy_dpi_err.so"
	#define PLUGIN_ERR_NAME "dummy_dpi_err"

	BOOST_AUTO_TEST_CASE(handle_plugin)
	{
	kshark_dpi_list dpi1, dpi2, *dpi_err;
	kshark_plugin_list p1, p2, *p_err;
	kshark_context *kshark_ctx(nullptr);
	kshark_data_stream *stream;
	std::string plugin;
	int sd, ret;

	BOOST_REQUIRE(kshark_instance(&kshark_ctx));
	BOOST_CHECK_EQUAL(kshark_ctx->plugins, nullptr);
	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 0);

	plugin = path + PLUGIN_1_LIB;
	p1 = kshark_register_plugin(kshark_ctx, PLUGIN_1_NAME, plugin.c_str());

	plugin = path + PLUGIN_2_LIB;
	p2 = kshark_register_plugin(kshark_ctx, PLUGIN_2_NAME, plugin.c_str());
	BOOST_CHECK(kshark_ctx->plugins != nullptr);
	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 2);

	sd = kshark_add_stream(kshark_ctx);
	kshark_ctx->stream[sd]->interface = malloc(1);
	stream = kshark_get_data_stream(kshark_ctx, sd);
	BOOST_CHECK(stream != nullptr);

	dpi1 = kshark_register_plugin_to_stream(stream,
	p1->process_interface,
	true);
	BOOST_CHECK_EQUAL(dpi1->status, KSHARK_PLUGIN_ENABLED);

	dpi2 = kshark_register_plugin_to_stream(stream,
	p2->process_interface,
	false);
	BOOST_CHECK_EQUAL(dpi2->status, 0);

	ret = kshark_handle_dpi(stream, dpi1, KSHARK_PLUGIN_INIT);
	BOOST_CHECK_EQUAL(ret, 1);
	BOOST_CHECK_EQUAL(dpi1->status,
	KSHARK_PLUGIN_LOADED \| KSHARK_PLUGIN_ENABLED);

	ret = kshark_handle_dpi(stream, dpi2, KSHARK_PLUGIN_INIT);
	BOOST_CHECK_EQUAL(ret, 0);
	BOOST_CHECK_EQUAL(dpi2->status, 0);

	dpi2->status \|= KSHARK_PLUGIN_ENABLED;
	ret = kshark_handle_dpi(stream, dpi2, KSHARK_PLUGIN_INIT);
	BOOST_CHECK_EQUAL(ret, 2);
	BOOST_CHECK_EQUAL(dpi1->status,
	KSHARK_PLUGIN_LOADED \| KSHARK_PLUGIN_ENABLED);

	ret = kshark_handle_all_dpis(stream, KSHARK_PLUGIN_UPDATE);
	BOOST_CHECK_EQUAL(ret, 0);
	BOOST_CHECK_EQUAL(dpi1->status,
	KSHARK_PLUGIN_LOADED \| KSHARK_PLUGIN_ENABLED);
	BOOST_CHECK_EQUAL(dpi2->status,
	KSHARK_PLUGIN_LOADED \| KSHARK_PLUGIN_ENABLED);

	plugin = path + PLUGIN_ERR_LIB;
	p_err = kshark_register_plugin(kshark_ctx, PLUGIN_ERR_NAME,
	plugin.c_str());
	BOOST_CHECK_EQUAL(kshark_ctx->n_plugins, 3);
	dpi_err = kshark_register_plugin_to_stream(stream,
	p_err->process_interface,
	true);
	BOOST_CHECK_EQUAL(ret, 0);
	ret = kshark_handle_dpi(stream, dpi_err, KSHARK_PLUGIN_INIT);
	BOOST_CHECK_EQUAL(dpi_err->status,
	KSHARK_PLUGIN_FAILED \| KSHARK_PLUGIN_ENABLED);
	BOOST_CHECK_EQUAL(ret, 0);
	ret = kshark_handle_dpi(stream, dpi_err, KSHARK_PLUGIN_CLOSE);
	BOOST_CHECK_EQUAL(ret, 0);
	BOOST_CHECK_EQUAL(dpi_err->status, KSHARK_PLUGIN_ENABLED);

	ret = kshark_handle_all_dpis(stream, KSHARK_PLUGIN_CLOSE);
	BOOST_CHECK_EQUAL(ret, -3);

	kshark_free(kshark_ctx);
	}

	#define FAKE_DATA_FILE_A "test.ta"
	#define FAKE_DATA_A_SIZE 200

	#define FAKE_DATA_FILE_B "test.tb"
	#define FAKE_DATA_B_SIZE 100

	BOOST_AUTO_TEST_CASE(readout_plugins)
	{
	kshark_context *kshark_ctx(nullptr);
	kshark_entry **entries{nullptr};
	kshark_data_stream *stream;
	std::string plugin, data;
	int sd, i, n_entries;
	int64_t ts_last(0);

	BOOST_REQUIRE(kshark_instance(&kshark_ctx));

	plugin = path + INPUT_A_LIB;
	kshark_register_plugin(kshark_ctx, INPUT_A_NAME, plugin.c_str());
	plugin = path + INPUT_B_LIB;
	kshark_register_plugin(kshark_ctx, INPUT_B_NAME, plugin.c_str());

	data = FAKE_DATA_FILE_A;
	sd = kshark_open(kshark_ctx, data.c_str());
	BOOST_CHECK_EQUAL(sd, 0);

	stream = kshark_get_data_stream(kshark_ctx, sd);
	BOOST_CHECK(stream != nullptr);
	BOOST_CHECK(stream->interface != nullptr);
	BOOST_CHECK_EQUAL(strcmp(stream->data_format, "format_a"), 0);

	data = FAKE_DATA_FILE_B;
	sd = kshark_open(kshark_ctx, data.c_str());
	BOOST_CHECK_EQUAL(sd, 1);

	stream = kshark_get_data_stream(kshark_ctx, sd);
	BOOST_CHECK(stream != nullptr);
	BOOST_CHECK(stream->interface != nullptr);
	BOOST_CHECK_EQUAL(strcmp(stream->data_format, "format_b"), 0);

	n_entries = kshark_load_all_entries(kshark_ctx, &entries);
	BOOST_CHECK_EQUAL(n_entries, FAKE_DATA_A_SIZE + FAKE_DATA_B_SIZE);

	for (i = 0; i < n_entries; ++i) {
	BOOST_CHECK(ts_last <= entries[i]->ts);
	ts_last = entries[i]->ts;
	}

	for (i = 0; i < n_entries; ++i)
	free(entries[i]);
	free(entries);

	kshark_free(kshark_ctx);
	}

	BOOST_AUTO_TEST_CASE(check_font_found)
	{
	#ifdef TT_FONT_FILE
	BOOST_REQUIRE(true);
	#else
	BOOST_REQUIRE(false);
	#endif
	}