[babeltrace.git] / tests / lib / test_plugin.c

/*
 * test_plugin.c
 *
 * CTF IR Reference Count test
 *
 * Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; under version 2 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <babeltrace/plugin/plugin.h>
#include <babeltrace/ref.h>
#include <babeltrace/values.h>
#include <babeltrace/graph/component.h>
#include <babeltrace/graph/graph.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include <glib.h>
#include "tap/tap.h"
#include "common.h"

#define NR_TESTS 		58
#define NON_EXISTING_PATH	"/this/hopefully/does/not/exist/5bc75f8d-0dba-4043-a509-d7984b97e42b.so"

/* Those symbols are written to by some test plugins */
static int check_env_var(const char *name)
{
	const char *val = getenv(name);

	if (!val) {
		return -1;
	}

	return atoi(val);
}

static void reset_test_plugin_env_vars(void)
{
	g_setenv("BT_TEST_PLUGIN_INIT_CALLED", "0", 1);
	g_setenv("BT_TEST_PLUGIN_EXIT_CALLED", "0", 1);
}

static char *get_test_plugin_path(const char *plugin_dir,
		const char *plugin_name)
{
	char *ret;
	char *plugin_file_name;

	if (asprintf(&plugin_file_name, "plugin-%s." G_MODULE_SUFFIX,
			plugin_name) == -1) {
		abort();
	}

	ret = g_build_filename(plugin_dir, plugin_file_name, NULL);
	free(plugin_file_name);

	return ret;
}

static void test_invalid(const char *plugin_dir)
{
	struct bt_plugin_set *plugin_set;

	diag("invalid plugin test below");

	plugin_set = bt_plugin_create_all_from_file(NON_EXISTING_PATH);
	ok(!plugin_set, "bt_plugin_create_all_from_file() fails with a non-existing file");

	plugin_set = bt_plugin_create_all_from_file(plugin_dir);
	ok(!plugin_set, "bt_plugin_create_all_from_file() fails with a directory");

	ok(!bt_plugin_create_all_from_file(NULL),
		"bt_plugin_create_all_from_file() handles NULL correctly");
	ok(!bt_plugin_create_all_from_dir(NULL, BT_FALSE),
		"bt_plugin_create_all_from_dir() handles NULL correctly");
	ok(!bt_plugin_get_name(NULL),
		"bt_plugin_get_name() handles NULL correctly");
	ok(!bt_plugin_get_description(NULL),
		"bt_plugin_get_description() handles NULL correctly");
	ok(bt_plugin_get_version(NULL, NULL, NULL, NULL, NULL) !=
		BT_PLUGIN_STATUS_OK,
		"bt_plugin_get_version() handles NULL correctly");
	ok(!bt_plugin_get_author(NULL),
		"bt_plugin_get_author() handles NULL correctly");
	ok(!bt_plugin_get_license(NULL),
		"bt_plugin_get_license() handles NULL correctly");
	ok(!bt_plugin_get_path(NULL),
		"bt_plugin_get_path() handles NULL correctly");
	ok(bt_plugin_get_component_class_count(NULL) < 0,
		"bt_plugin_get_component_class_count() handles NULL correctly");
	ok(!bt_plugin_get_component_class_by_index(NULL, 0),
		"bt_plugin_get_component_class_by_index() handles NULL correctly");
	ok(!bt_plugin_get_component_class_by_name_and_type(NULL, NULL, 0),
		"bt_plugin_get_component_class_by_name_and_type() handles NULL correctly");
}

static void test_minimal(const char *plugin_dir)
{
	struct bt_plugin_set *plugin_set;
	struct bt_plugin *plugin;
	char *minimal_path = get_test_plugin_path(plugin_dir, "minimal");

	assert(minimal_path);
	diag("minimal plugin test below");

	reset_test_plugin_env_vars();
	plugin_set = bt_plugin_create_all_from_file(minimal_path);
	ok(plugin_set && bt_plugin_set_get_plugin_count(plugin_set) == 1,
		"bt_plugin_create_all_from_file() succeeds with a valid file");
	ok(check_env_var("BT_TEST_PLUGIN_INIT_CALLED") == 1,
		"plugin's initialization function is called during bt_plugin_create_all_from_file()");
	ok(bt_plugin_set_get_plugin_count(plugin_set) == 1,
		"bt_plugin_create_all_from_file() returns the expected number of plugins");
	plugin = bt_plugin_set_get_plugin(plugin_set, 0);
	ok(strcmp(bt_plugin_get_name(plugin), "test_minimal") == 0,
		"bt_plugin_get_name() returns the expected name");
	ok(strcmp(bt_plugin_get_description(plugin),
		"Minimal Babeltrace plugin with no component classes") == 0,
		"bt_plugin_get_description() returns the expected description");
	ok(bt_plugin_get_version(plugin, NULL, NULL, NULL, NULL) !=
		BT_PLUGIN_STATUS_OK,
		"bt_plugin_get_version() fails when there's no version");
	ok(strcmp(bt_plugin_get_author(plugin), "Janine Sutto") == 0,
		"bt_plugin_get_author() returns the expected author");
	ok(strcmp(bt_plugin_get_license(plugin), "Beerware") == 0,
		"bt_plugin_get_license() returns the expected license");
	ok(strcmp(bt_plugin_get_path(plugin), minimal_path) == 0,
		"bt_plugin_get_path() returns the expected path");
	ok(bt_plugin_get_component_class_count(plugin) == 0,
		"bt_plugin_get_component_class_count() returns the expected value");
	bt_put(plugin);
	bt_put(plugin_set);
	ok(check_env_var("BT_TEST_PLUGIN_EXIT_CALLED") == 1,
		"plugin's exit function is called when the plugin is destroyed");

	free(minimal_path);
}

static void test_sfs(const char *plugin_dir)
{
	struct bt_plugin_set *plugin_set;
	struct bt_plugin *plugin;
	struct bt_component_class *sink_comp_class;
	struct bt_component_class *source_comp_class;
	struct bt_component_class *filter_comp_class;
	struct bt_component *sink_component;
	char *sfs_path = get_test_plugin_path(plugin_dir, "sfs");
	unsigned int major, minor, patch;
	const char *extra;
	struct bt_value *params;
	struct bt_value *results;
	struct bt_value *object;
	struct bt_value *res_params;
	struct bt_graph *graph;
	const char *object_str;
	enum bt_value_status value_ret;
	enum bt_graph_status graph_ret;

	assert(sfs_path);
	diag("sfs plugin test below");

	plugin_set = bt_plugin_create_all_from_file(sfs_path);
	assert(plugin_set && bt_plugin_set_get_plugin_count(plugin_set) == 1);
	plugin = bt_plugin_set_get_plugin(plugin_set, 0);
	ok(bt_plugin_get_version(plugin, &major, &minor, &patch, &extra) ==
		BT_PLUGIN_STATUS_OK,
		"bt_plugin_get_version() succeeds when there's a version");
	ok(major == 1,
		"bt_plugin_get_version() returns the expected major version");
	ok(minor == 2,
		"bt_plugin_get_version() returns the expected minor version");
	ok(patch == 3,
		"bt_plugin_get_version() returns the expected patch version");
	ok(strcmp(extra, "yes") == 0,
		"bt_plugin_get_version() returns the expected extra version");
	ok(bt_plugin_get_component_class_count(plugin) == 3,
		"bt_plugin_get_component_class_count() returns the expected value");

	source_comp_class = bt_plugin_get_component_class_by_name_and_type(
		plugin, "source", BT_COMPONENT_CLASS_TYPE_SOURCE);
	ok(source_comp_class,
		"bt_plugin_get_component_class_by_name_and_type() finds a source component class");

	sink_comp_class = bt_plugin_get_component_class_by_name_and_type(
		plugin, "sink", BT_COMPONENT_CLASS_TYPE_SINK);
	ok(sink_comp_class,
		"bt_plugin_get_component_class_by_name_and_type() finds a sink component class");
	ok(strcmp(bt_component_class_get_help(sink_comp_class),
		"Bacon ipsum dolor amet strip steak cupim pastrami venison shoulder.\n"
		"Prosciutto beef ribs flank meatloaf pancetta brisket kielbasa drumstick\n"
		"venison tenderloin cow tail. Beef short loin shoulder meatball, sirloin\n"
		"ground round brisket salami cupim pork bresaola turkey bacon boudin.\n") == 0,
		"bt_component_class_get_help() returns the expected help text");

	filter_comp_class = bt_plugin_get_component_class_by_name_and_type(
		plugin, "filter", BT_COMPONENT_CLASS_TYPE_FILTER);
	ok(filter_comp_class,
		"bt_plugin_get_component_class_by_name_and_type() finds a filter component class");
	ok(!bt_plugin_get_component_class_by_name_and_type(plugin, "filter",
		BT_COMPONENT_CLASS_TYPE_SOURCE),
		"bt_plugin_get_component_class_by_name_and_type() does not find a component class given the wrong type");
	params = bt_value_integer_create_init(23);
	assert(params);
	ok (!bt_component_class_query(NULL, "get-something", params),
		"bt_component_class_query() handles NULL (component class)");
	ok (!bt_component_class_query(filter_comp_class, NULL, params),
		"bt_component_class_query() handles NULL (object)");
	ok (!bt_component_class_query(filter_comp_class, "get-something", NULL),
		"bt_component_class_query() handles NULL (parameters)");
	results = bt_component_class_query(filter_comp_class,
		"get-something", params);
	ok(results, "bt_component_class_query() succeeds");
	assert(bt_value_is_array(results) && bt_value_array_size(results) == 2);
	object = bt_value_array_get(results, 0);
	assert(object && bt_value_is_string(object));
	value_ret = bt_value_string_get(object, &object_str);
	assert(value_ret == BT_VALUE_STATUS_OK);
	ok(strcmp(object_str, "get-something") == 0,
		"bt_component_class_query() receives the expected object name");
	res_params = bt_value_array_get(results, 1);
	ok(res_params == params,
		"bt_component_class_query() receives the expected parameters");

	diag("> putting the plugin object here");
	BT_PUT(plugin);
	graph = bt_graph_create();
	assert(graph);
	graph_ret = bt_graph_add_component(graph, sink_comp_class, "the-sink",
		NULL, &sink_component);
	ok(graph_ret == BT_GRAPH_STATUS_OK && sink_component,
		"bt_graph_add_component() still works after the plugin object is destroyed");
	BT_PUT(sink_component);
	BT_PUT(source_comp_class);
	bt_put(graph);
	graph = bt_graph_create();
	assert(graph);
	graph_ret = bt_graph_add_component(graph, sink_comp_class, "the-sink",
		NULL, &sink_component);
	ok(graph_ret == BT_GRAPH_STATUS_OK && sink_component,
		"bt_graph_add_component() still works after the source component class object is destroyed");
	BT_PUT(sink_component);
	BT_PUT(filter_comp_class);
	bt_put(graph);
	graph = bt_graph_create();
	assert(graph);
	graph_ret = bt_graph_add_component(graph, sink_comp_class, "the-sink",
		NULL, &sink_component);
	ok(graph_ret == BT_GRAPH_STATUS_OK && sink_component,
		"bt_graph_add_component() still works after the filter component class object is destroyed");
	BT_PUT(sink_comp_class);
	BT_PUT(sink_component);

	free(sfs_path);
	bt_put(graph);
	bt_put(plugin_set);
	bt_put(object);
	bt_put(res_params);
	bt_put(results);
	bt_put(params);
}

static void test_create_all_from_dir(const char *plugin_dir)
{
	struct bt_plugin_set *plugin_set;

	diag("create from all test below");

	plugin_set = bt_plugin_create_all_from_dir(NON_EXISTING_PATH, BT_FALSE);
	ok(!plugin_set,
		"bt_plugin_create_all_from_dir() fails with an invalid path");

	plugin_set = bt_plugin_create_all_from_dir(plugin_dir, BT_FALSE);
	ok(plugin_set, "bt_plugin_create_all_from_dir() succeeds with a valid path");

	/* 2 or 4, if `.la` files are considered or not */
	ok(bt_plugin_set_get_plugin_count(plugin_set) == 2 ||
		bt_plugin_set_get_plugin_count(plugin_set) == 4,
		"bt_plugin_create_all_from_dir() returns the expected number of plugin objects");

	bt_put(plugin_set);
}

static void test_find(const char *plugin_dir)
{
	int ret;
	struct bt_plugin *plugin;
	struct bt_component_class *comp_cls_sink;
	struct bt_component_class *comp_cls_source;
	char *plugin_path;

	ok(!bt_plugin_find(NULL),
		"bt_plugin_find() handles NULL");
	ok(!bt_plugin_find(NON_EXISTING_PATH),
		"bt_plugin_find() returns NULL with an unknown plugin name");
	ret = asprintf(&plugin_path, "%s" G_SEARCHPATH_SEPARATOR_S
			G_DIR_SEPARATOR_S "ec1d09e5-696c-442e-b1c3-f9c6cf7f5958"
			G_SEARCHPATH_SEPARATOR_S G_SEARCHPATH_SEPARATOR_S
			G_SEARCHPATH_SEPARATOR_S "%s" G_SEARCHPATH_SEPARATOR_S
			"8db46494-a398-466a-9649-c765ae077629"
			G_SEARCHPATH_SEPARATOR_S,
		NON_EXISTING_PATH, plugin_dir);
	assert(ret > 0 && plugin_path);
	g_setenv("BABELTRACE_PLUGIN_PATH", plugin_path, 1);
	plugin = bt_plugin_find("test_minimal");
	ok(plugin,
		"bt_plugin_find() succeeds with a plugin name it can find");
	ok(strcmp(bt_plugin_get_author(plugin), "Janine Sutto") == 0,
		"bt_plugin_find() finds the correct plugin for a given name");
	BT_PUT(plugin);
	comp_cls_sink = bt_plugin_find_component_class(NULL, "sink",
		BT_COMPONENT_CLASS_TYPE_SINK);
	ok(!comp_cls_sink, "bt_plugin_find_component_class() handles NULL (plugin name)");
	comp_cls_sink = bt_plugin_find_component_class("test_sfs", NULL,
		BT_COMPONENT_CLASS_TYPE_SINK);
	ok(!comp_cls_sink, "bt_plugin_find_component_class() handles NULL (component class name)");
	comp_cls_sink = bt_plugin_find_component_class("test_sfs", "sink2",
		BT_COMPONENT_CLASS_TYPE_SINK);
	ok(!comp_cls_sink, "bt_plugin_find_component_class() fails with an unknown component class name");
	comp_cls_sink = bt_plugin_find_component_class("test_sfs", "sink",
		BT_COMPONENT_CLASS_TYPE_SINK);
	ok(comp_cls_sink, "bt_plugin_find_component_class() succeeds with valid parameters");
	ok(strcmp(bt_component_class_get_name(comp_cls_sink), "sink") == 0,
		"bt_plugin_find_component_class() returns the appropriate component class (sink)");
	comp_cls_source = bt_plugin_find_component_class("test_sfs", "source",
		BT_COMPONENT_CLASS_TYPE_SOURCE);
	ok(comp_cls_sink, "bt_plugin_find_component_class() succeeds with another component class name (same plugin)");
	ok(strcmp(bt_component_class_get_name(comp_cls_source), "source") == 0,
		"bt_plugin_find_component_class() returns the appropriate component class (source)");
	BT_PUT(comp_cls_sink);
	BT_PUT(comp_cls_source);
	free(plugin_path);
}

int main(int argc, char **argv)
{
	int ret;
	const char *plugin_dir;

	if (argc != 2) {
		puts("Usage: test_plugin plugin_directory");
		ret = 1;
		goto end;
	}

	plugin_dir = argv[1];
	plan_tests(NR_TESTS);
	test_invalid(plugin_dir);
	test_minimal(plugin_dir);
	test_sfs(plugin_dir);
	test_create_all_from_dir(plugin_dir);
	test_find(plugin_dir);
	ret = exit_status();
end:
	return ret;
}
Commit	Line	Data
cbb9e0b1 PP	1	/*
	2	* test_plugin.c
	3	*
	4	* CTF IR Reference Count test
	5	*
	6	* Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; under version 2 of the License.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License along
	18	* with this program; if not, write to the Free Software Foundation, Inc.,
	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*/
	21
	22	#include <babeltrace/plugin/plugin.h>
	23	#include <babeltrace/ref.h>
	24	#include <babeltrace/values.h>
cc469c42	25	#include <babeltrace/graph/component.h>
36712f1d	26	#include <babeltrace/graph/graph.h>
cbb9e0b1 PP	27	#include <stdlib.h>
	28	#include <string.h>
	29	#include <stdio.h>
	30	#include <assert.h>
	31	#include <glib.h>
	32	#include "tap/tap.h"
	33	#include "common.h"
	34
2b43acf9	35	#define NR_TESTS 58
cbb9e0b1 PP	36	#define NON_EXISTING_PATH "/this/hopefully/does/not/exist/5bc75f8d-0dba-4043-a509-d7984b97e42b.so"
	37
	38	/* Those symbols are written to by some test plugins */
df5b5d01 PP	39	static int check_env_var(const char *name)
	40	{
	41	const char *val = getenv(name);
	42
	43	if (!val) {
	44	return -1;
	45	}
	46
	47	return atoi(val);
	48	}
cbb9e0b1	49
df5b5d01	50	static void reset_test_plugin_env_vars(void)
cbb9e0b1	51	{
fbb2f0da MJ	52	g_setenv("BT_TEST_PLUGIN_INIT_CALLED", "0", 1);
fbb2f0da MJ	53	g_setenv("BT_TEST_PLUGIN_EXIT_CALLED", "0", 1);
cbb9e0b1 PP	54	}
	55
	56	static char get_test_plugin_path(const char plugin_dir,
	57	const char *plugin_name)
	58	{
cbb9e0b1	59	char *ret;
84095ea4 MJ	60	char *plugin_file_name;
	61
	62	if (asprintf(&plugin_file_name, "plugin-%s." G_MODULE_SUFFIX,
	63	plugin_name) == -1) {
	64	abort();
	65	}
	66
	67	ret = g_build_filename(plugin_dir, plugin_file_name, NULL);
	68	free(plugin_file_name);
cbb9e0b1	69
cbb9e0b1 PP	70	return ret;
	71	}
	72
	73	static void test_invalid(const char *plugin_dir)
	74	{
a8ff38ef	75	struct bt_plugin_set *plugin_set;
cbb9e0b1	76
84095ea4 MJ	77	diag("invalid plugin test below");
84095ea4 MJ	78
a8ff38ef PP	79	plugin_set = bt_plugin_create_all_from_file(NON_EXISTING_PATH);
a8ff38ef PP	80	ok(!plugin_set, "bt_plugin_create_all_from_file() fails with a non-existing file");
cbb9e0b1	81
a8ff38ef PP	82	plugin_set = bt_plugin_create_all_from_file(plugin_dir);
a8ff38ef PP	83	ok(!plugin_set, "bt_plugin_create_all_from_file() fails with a directory");
cbb9e0b1	84
6ba0b073 PP	85	ok(!bt_plugin_create_all_from_file(NULL),
6ba0b073 PP	86	"bt_plugin_create_all_from_file() handles NULL correctly");
c55a9f58	87	ok(!bt_plugin_create_all_from_dir(NULL, BT_FALSE),
cbb9e0b1 PP	88	"bt_plugin_create_all_from_dir() handles NULL correctly");
	89	ok(!bt_plugin_get_name(NULL),
	90	"bt_plugin_get_name() handles NULL correctly");
	91	ok(!bt_plugin_get_description(NULL),
	92	"bt_plugin_get_description() handles NULL correctly");
458e8e1d PP	93	ok(bt_plugin_get_version(NULL, NULL, NULL, NULL, NULL) !=
	94	BT_PLUGIN_STATUS_OK,
	95	"bt_plugin_get_version() handles NULL correctly");
cbb9e0b1 PP	96	ok(!bt_plugin_get_author(NULL),
	97	"bt_plugin_get_author() handles NULL correctly");
	98	ok(!bt_plugin_get_license(NULL),
	99	"bt_plugin_get_license() handles NULL correctly");
	100	ok(!bt_plugin_get_path(NULL),
	101	"bt_plugin_get_path() handles NULL correctly");
	102	ok(bt_plugin_get_component_class_count(NULL) < 0,
	103	"bt_plugin_get_component_class_count() handles NULL correctly");
9ac68eb1 PP	104	ok(!bt_plugin_get_component_class_by_index(NULL, 0),
9ac68eb1 PP	105	"bt_plugin_get_component_class_by_index() handles NULL correctly");
cbb9e0b1 PP	106	ok(!bt_plugin_get_component_class_by_name_and_type(NULL, NULL, 0),
cbb9e0b1 PP	107	"bt_plugin_get_component_class_by_name_and_type() handles NULL correctly");
cbb9e0b1 PP	108	}
	109
	110	static void test_minimal(const char *plugin_dir)
	111	{
a8ff38ef	112	struct bt_plugin_set *plugin_set;
cbb9e0b1 PP	113	struct bt_plugin *plugin;
	114	char *minimal_path = get_test_plugin_path(plugin_dir, "minimal");
	115
	116	assert(minimal_path);
	117	diag("minimal plugin test below");
	118
df5b5d01	119	reset_test_plugin_env_vars();
a8ff38ef PP	120	plugin_set = bt_plugin_create_all_from_file(minimal_path);
	121	ok(plugin_set && bt_plugin_set_get_plugin_count(plugin_set) == 1,
	122	"bt_plugin_create_all_from_file() succeeds with a valid file");
df5b5d01 PP	123	ok(check_env_var("BT_TEST_PLUGIN_INIT_CALLED") == 1,
df5b5d01 PP	124	"plugin's initialization function is called during bt_plugin_create_all_from_file()");
a8ff38ef	125	ok(bt_plugin_set_get_plugin_count(plugin_set) == 1,
6ba0b073	126	"bt_plugin_create_all_from_file() returns the expected number of plugins");
a8ff38ef	127	plugin = bt_plugin_set_get_plugin(plugin_set, 0);
6ba0b073	128	ok(strcmp(bt_plugin_get_name(plugin), "test_minimal") == 0,
cbb9e0b1 PP	129	"bt_plugin_get_name() returns the expected name");
	130	ok(strcmp(bt_plugin_get_description(plugin),
	131	"Minimal Babeltrace plugin with no component classes") == 0,
	132	"bt_plugin_get_description() returns the expected description");
458e8e1d PP	133	ok(bt_plugin_get_version(plugin, NULL, NULL, NULL, NULL) !=
	134	BT_PLUGIN_STATUS_OK,
	135	"bt_plugin_get_version() fails when there's no version");
cbb9e0b1 PP	136	ok(strcmp(bt_plugin_get_author(plugin), "Janine Sutto") == 0,
	137	"bt_plugin_get_author() returns the expected author");
	138	ok(strcmp(bt_plugin_get_license(plugin), "Beerware") == 0,
	139	"bt_plugin_get_license() returns the expected license");
	140	ok(strcmp(bt_plugin_get_path(plugin), minimal_path) == 0,
	141	"bt_plugin_get_path() returns the expected path");
	142	ok(bt_plugin_get_component_class_count(plugin) == 0,
	143	"bt_plugin_get_component_class_count() returns the expected value");
a8ff38ef PP	144	bt_put(plugin);
a8ff38ef PP	145	bt_put(plugin_set);
df5b5d01 PP	146	ok(check_env_var("BT_TEST_PLUGIN_EXIT_CALLED") == 1,
df5b5d01 PP	147	"plugin's exit function is called when the plugin is destroyed");
cbb9e0b1 PP	148
	149	free(minimal_path);
	150	}
	151
	152	static void test_sfs(const char *plugin_dir)
	153	{
a8ff38ef	154	struct bt_plugin_set *plugin_set;
cbb9e0b1 PP	155	struct bt_plugin *plugin;
	156	struct bt_component_class *sink_comp_class;
	157	struct bt_component_class *source_comp_class;
	158	struct bt_component_class *filter_comp_class;
	159	struct bt_component *sink_component;
	160	char *sfs_path = get_test_plugin_path(plugin_dir, "sfs");
458e8e1d PP	161	unsigned int major, minor, patch;
458e8e1d PP	162	const char *extra;
5933c0f2 PP	163	struct bt_value *params;
5933c0f2 PP	164	struct bt_value *results;
a67681c1	165	struct bt_value *object;
5933c0f2	166	struct bt_value *res_params;
36712f1d	167	struct bt_graph *graph;
a67681c1	168	const char *object_str;
c3c69044 MD	169	enum bt_value_status value_ret;
c3c69044 MD	170	enum bt_graph_status graph_ret;
cbb9e0b1 PP	171
	172	assert(sfs_path);
	173	diag("sfs plugin test below");
	174
a8ff38ef PP	175	plugin_set = bt_plugin_create_all_from_file(sfs_path);
	176	assert(plugin_set && bt_plugin_set_get_plugin_count(plugin_set) == 1);
	177	plugin = bt_plugin_set_get_plugin(plugin_set, 0);
458e8e1d PP	178	ok(bt_plugin_get_version(plugin, &major, &minor, &patch, &extra) ==
	179	BT_PLUGIN_STATUS_OK,
	180	"bt_plugin_get_version() succeeds when there's a version");
	181	ok(major == 1,
	182	"bt_plugin_get_version() returns the expected major version");
	183	ok(minor == 2,
	184	"bt_plugin_get_version() returns the expected minor version");
	185	ok(patch == 3,
	186	"bt_plugin_get_version() returns the expected patch version");
	187	ok(strcmp(extra, "yes") == 0,
	188	"bt_plugin_get_version() returns the expected extra version");
cbb9e0b1 PP	189	ok(bt_plugin_get_component_class_count(plugin) == 3,
	190	"bt_plugin_get_component_class_count() returns the expected value");
	191
	192	source_comp_class = bt_plugin_get_component_class_by_name_and_type(
d3e4dcd8	193	plugin, "source", BT_COMPONENT_CLASS_TYPE_SOURCE);
cbb9e0b1 PP	194	ok(source_comp_class,
	195	"bt_plugin_get_component_class_by_name_and_type() finds a source component class");
	196
	197	sink_comp_class = bt_plugin_get_component_class_by_name_and_type(
d3e4dcd8	198	plugin, "sink", BT_COMPONENT_CLASS_TYPE_SINK);
cbb9e0b1 PP	199	ok(sink_comp_class,
cbb9e0b1 PP	200	"bt_plugin_get_component_class_by_name_and_type() finds a sink component class");
a889b89f PP	201	ok(strcmp(bt_component_class_get_help(sink_comp_class),
	202	"Bacon ipsum dolor amet strip steak cupim pastrami venison shoulder.\n"
	203	"Prosciutto beef ribs flank meatloaf pancetta brisket kielbasa drumstick\n"
	204	"venison tenderloin cow tail. Beef short loin shoulder meatball, sirloin\n"
	205	"ground round brisket salami cupim pork bresaola turkey bacon boudin.\n") == 0,
	206	"bt_component_class_get_help() returns the expected help text");
	207
cbb9e0b1	208	filter_comp_class = bt_plugin_get_component_class_by_name_and_type(
d3e4dcd8	209	plugin, "filter", BT_COMPONENT_CLASS_TYPE_FILTER);
cbb9e0b1 PP	210	ok(filter_comp_class,
	211	"bt_plugin_get_component_class_by_name_and_type() finds a filter component class");
	212	ok(!bt_plugin_get_component_class_by_name_and_type(plugin, "filter",
d3e4dcd8	213	BT_COMPONENT_CLASS_TYPE_SOURCE),
cbb9e0b1	214	"bt_plugin_get_component_class_by_name_and_type() does not find a component class given the wrong type");
5933c0f2 PP	215	params = bt_value_integer_create_init(23);
5933c0f2 PP	216	assert(params);
a67681c1 PP	217	ok (!bt_component_class_query(NULL, "get-something", params),
	218	"bt_component_class_query() handles NULL (component class)");
	219	ok (!bt_component_class_query(filter_comp_class, NULL, params),
	220	"bt_component_class_query() handles NULL (object)");
	221	ok (!bt_component_class_query(filter_comp_class, "get-something", NULL),
	222	"bt_component_class_query() handles NULL (parameters)");
	223	results = bt_component_class_query(filter_comp_class,
5933c0f2	224	"get-something", params);
a67681c1	225	ok(results, "bt_component_class_query() succeeds");
5933c0f2	226	assert(bt_value_is_array(results) && bt_value_array_size(results) == 2);
a67681c1 PP	227	object = bt_value_array_get(results, 0);
a67681c1 PP	228	assert(object && bt_value_is_string(object));
c3c69044 MD	229	value_ret = bt_value_string_get(object, &object_str);
c3c69044 MD	230	assert(value_ret == BT_VALUE_STATUS_OK);
a67681c1 PP	231	ok(strcmp(object_str, "get-something") == 0,
a67681c1 PP	232	"bt_component_class_query() receives the expected object name");
5933c0f2 PP	233	res_params = bt_value_array_get(results, 1);
5933c0f2 PP	234	ok(res_params == params,
a67681c1	235	"bt_component_class_query() receives the expected parameters");
cbb9e0b1 PP	236
	237	diag("> putting the plugin object here");
	238	BT_PUT(plugin);
36712f1d PP	239	graph = bt_graph_create();
36712f1d PP	240	assert(graph);
c3c69044 MD	241	graph_ret = bt_graph_add_component(graph, sink_comp_class, "the-sink",
	242	NULL, &sink_component);
	243	ok(graph_ret == BT_GRAPH_STATUS_OK && sink_component,
36712f1d	244	"bt_graph_add_component() still works after the plugin object is destroyed");
cbb9e0b1 PP	245	BT_PUT(sink_component);
cbb9e0b1 PP	246	BT_PUT(source_comp_class);
36712f1d PP	247	bt_put(graph);
	248	graph = bt_graph_create();
	249	assert(graph);
c3c69044 MD	250	graph_ret = bt_graph_add_component(graph, sink_comp_class, "the-sink",
	251	NULL, &sink_component);
	252	ok(graph_ret == BT_GRAPH_STATUS_OK && sink_component,
36712f1d	253	"bt_graph_add_component() still works after the source component class object is destroyed");
cbb9e0b1 PP	254	BT_PUT(sink_component);
cbb9e0b1 PP	255	BT_PUT(filter_comp_class);
36712f1d PP	256	bt_put(graph);
	257	graph = bt_graph_create();
	258	assert(graph);
c3c69044 MD	259	graph_ret = bt_graph_add_component(graph, sink_comp_class, "the-sink",
	260	NULL, &sink_component);
	261	ok(graph_ret == BT_GRAPH_STATUS_OK && sink_component,
36712f1d	262	"bt_graph_add_component() still works after the filter component class object is destroyed");
cbb9e0b1 PP	263	BT_PUT(sink_comp_class);
	264	BT_PUT(sink_component);
	265
	266	free(sfs_path);
36712f1d	267	bt_put(graph);
a8ff38ef	268	bt_put(plugin_set);
a67681c1	269	bt_put(object);
5933c0f2 PP	270	bt_put(res_params);
	271	bt_put(results);
	272	bt_put(params);
cbb9e0b1 PP	273	}
	274
	275	static void test_create_all_from_dir(const char *plugin_dir)
	276	{
a8ff38ef	277	struct bt_plugin_set *plugin_set;
cbb9e0b1 PP	278
	279	diag("create from all test below");
	280
c55a9f58	281	plugin_set = bt_plugin_create_all_from_dir(NON_EXISTING_PATH, BT_FALSE);
a8ff38ef	282	ok(!plugin_set,
cbb9e0b1 PP	283	"bt_plugin_create_all_from_dir() fails with an invalid path");
cbb9e0b1 PP	284
c55a9f58	285	plugin_set = bt_plugin_create_all_from_dir(plugin_dir, BT_FALSE);
a8ff38ef	286	ok(plugin_set, "bt_plugin_create_all_from_dir() succeeds with a valid path");
cbb9e0b1 PP	287
cbb9e0b1 PP	288	/* 2 or 4, if `.la` files are considered or not */
a8ff38ef PP	289	ok(bt_plugin_set_get_plugin_count(plugin_set) == 2 \|\|
	290	bt_plugin_set_get_plugin_count(plugin_set) == 4,
	291	"bt_plugin_create_all_from_dir() returns the expected number of plugin objects");
cbb9e0b1	292
a8ff38ef	293	bt_put(plugin_set);
cbb9e0b1 PP	294	}
cbb9e0b1 PP	295
2b43acf9	296	static void test_find(const char *plugin_dir)
a8b3f23b	297	{
8a6001c5	298	int ret;
a8b3f23b	299	struct bt_plugin *plugin;
2b43acf9 PP	300	struct bt_component_class *comp_cls_sink;
2b43acf9 PP	301	struct bt_component_class *comp_cls_source;
a8b3f23b PP	302	char *plugin_path;
a8b3f23b PP	303
2b43acf9 PP	304	ok(!bt_plugin_find(NULL),
	305	"bt_plugin_find() handles NULL");
	306	ok(!bt_plugin_find(NON_EXISTING_PATH),
	307	"bt_plugin_find() returns NULL with an unknown plugin name");
84095ea4 MJ	308	ret = asprintf(&plugin_path, "%s" G_SEARCHPATH_SEPARATOR_S
	309	G_DIR_SEPARATOR_S "ec1d09e5-696c-442e-b1c3-f9c6cf7f5958"
	310	G_SEARCHPATH_SEPARATOR_S G_SEARCHPATH_SEPARATOR_S
	311	G_SEARCHPATH_SEPARATOR_S "%s" G_SEARCHPATH_SEPARATOR_S
	312	"8db46494-a398-466a-9649-c765ae077629"
	313	G_SEARCHPATH_SEPARATOR_S,
a8b3f23b	314	NON_EXISTING_PATH, plugin_dir);
8a6001c5	315	assert(ret > 0 && plugin_path);
aacfaf40	316	g_setenv("BABELTRACE_PLUGIN_PATH", plugin_path, 1);
2b43acf9	317	plugin = bt_plugin_find("test_minimal");
a8b3f23b	318	ok(plugin,
2b43acf9	319	"bt_plugin_find() succeeds with a plugin name it can find");
a8b3f23b	320	ok(strcmp(bt_plugin_get_author(plugin), "Janine Sutto") == 0,
2b43acf9	321	"bt_plugin_find() finds the correct plugin for a given name");
a8b3f23b	322	BT_PUT(plugin);
2b43acf9 PP	323	comp_cls_sink = bt_plugin_find_component_class(NULL, "sink",
	324	BT_COMPONENT_CLASS_TYPE_SINK);
	325	ok(!comp_cls_sink, "bt_plugin_find_component_class() handles NULL (plugin name)");
	326	comp_cls_sink = bt_plugin_find_component_class("test_sfs", NULL,
	327	BT_COMPONENT_CLASS_TYPE_SINK);
	328	ok(!comp_cls_sink, "bt_plugin_find_component_class() handles NULL (component class name)");
	329	comp_cls_sink = bt_plugin_find_component_class("test_sfs", "sink2",
	330	BT_COMPONENT_CLASS_TYPE_SINK);
	331	ok(!comp_cls_sink, "bt_plugin_find_component_class() fails with an unknown component class name");
	332	comp_cls_sink = bt_plugin_find_component_class("test_sfs", "sink",
	333	BT_COMPONENT_CLASS_TYPE_SINK);
	334	ok(comp_cls_sink, "bt_plugin_find_component_class() succeeds with valid parameters");
	335	ok(strcmp(bt_component_class_get_name(comp_cls_sink), "sink") == 0,
	336	"bt_plugin_find_component_class() returns the appropriate component class (sink)");
	337	comp_cls_source = bt_plugin_find_component_class("test_sfs", "source",
	338	BT_COMPONENT_CLASS_TYPE_SOURCE);
	339	ok(comp_cls_sink, "bt_plugin_find_component_class() succeeds with another component class name (same plugin)");
	340	ok(strcmp(bt_component_class_get_name(comp_cls_source), "source") == 0,
	341	"bt_plugin_find_component_class() returns the appropriate component class (source)");
	342	BT_PUT(comp_cls_sink);
	343	BT_PUT(comp_cls_source);
a8b3f23b PP	344	free(plugin_path);
	345	}
	346
cbb9e0b1 PP	347	int main(int argc, char **argv)
	348	{
	349	int ret;
	350	const char *plugin_dir;
	351
	352	if (argc != 2) {
	353	puts("Usage: test_plugin plugin_directory");
	354	ret = 1;
	355	goto end;
	356	}
	357
	358	plugin_dir = argv[1];
	359	plan_tests(NR_TESTS);
	360	test_invalid(plugin_dir);
	361	test_minimal(plugin_dir);
	362	test_sfs(plugin_dir);
	363	test_create_all_from_dir(plugin_dir);
2b43acf9	364	test_find(plugin_dir);
cbb9e0b1 PP	365	ret = exit_status();
	366	end:
	367	return ret;
	368	}