[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 <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include <glib.h>
#include <linux/limits.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 */
int test_plugin_init_called;
int test_plugin_exit_called;

static void reset_test_plugin_symbols(void)
{
	test_plugin_init_called = 0;
	test_plugin_exit_called = 0;
}

static char *get_test_plugin_path(const char *plugin_dir,
		const char *plugin_name)
{
	GString *path = g_string_new(plugin_dir);
	char *ret;

	assert(path);
	g_string_append_printf(path, "/plugin-%s.so", plugin_name);
	ret = path->str;
	g_string_free(path, FALSE);
	return ret;
}

static void test_invalid(const char *plugin_dir)
{
	struct bt_plugin **plugins;

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

	plugins = bt_plugin_create_all_from_file(plugin_dir);
	ok(!plugins, "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, 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(NULL, 0),
		"bt_plugin_get_component_class() 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 **plugins;
	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_symbols();
	plugins = bt_plugin_create_all_from_file(minimal_path);
	ok(plugins && plugins[0], "bt_plugin_create_all_from_file() succeeds with a valid file");
	ok(test_plugin_init_called, "plugin's initialization function is called during bt_plugin_create_all_from_file()");
	ok(plugins && plugins[0] && !plugins[1],
		"bt_plugin_create_all_from_file() returns the expected number of plugins");
	plugin = plugins[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);
	ok(test_plugin_exit_called, "plugin's exit function is called when the plugin is destroyed");

	free(minimal_path);
	free(plugins);
}

static void test_sfs(const char *plugin_dir)
{
	struct bt_plugin **plugins;
	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;
	const char *object_str;
	int ret;

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

	plugins = bt_plugin_create_all_from_file(sfs_path);
	assert(plugins && plugins[0]);
	plugin = plugins[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));
	ret = bt_value_string_get(object, &object_str);
	assert(ret == 0);
	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);
	sink_component = bt_component_create(sink_comp_class, NULL, NULL);
	ok(sink_component, "bt_component_create() still works after the plugin object is destroyed");
	BT_PUT(sink_component);
	BT_PUT(source_comp_class);
	sink_component = bt_component_create(sink_comp_class, NULL, NULL);
	ok(sink_component, "bt_component_create() still works after the source component class object is destroyed");
	BT_PUT(sink_component);
	BT_PUT(filter_comp_class);
	sink_component = bt_component_create(sink_comp_class, NULL, NULL);
	ok(sink_component, "bt_component_create() still works after the filter component class object is destroyed");
	BT_PUT(sink_comp_class);
	BT_PUT(sink_component);

	free(sfs_path);
	free(plugins);
	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 **plugins;
	struct bt_plugin *plugin;
	int i;

	diag("create from all test below");

	plugins = bt_plugin_create_all_from_dir(NON_EXISTING_PATH, false);
	ok(!plugins,
		"bt_plugin_create_all_from_dir() fails with an invalid path");

	plugins = bt_plugin_create_all_from_dir(plugin_dir, false);
	ok(plugins, "bt_plugin_create_all_from_dir() succeeds with a valid path");

	i = 0;
	while ((plugin = plugins[i])) {
		BT_PUT(plugin);
		i++;
	}

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

	free(plugins);
}

static void test_find(const char *plugin_dir)
{
	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");
	plugin_path = malloc(PATH_MAX * 5);
	assert(plugin_path);
	sprintf(plugin_path, "%s:/ec1d09e5-696c-442e-b1c3-f9c6cf7f5958:::%s:8db46494-a398-466a-9649-c765ae077629:",
		NON_EXISTING_PATH, plugin_dir);
	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>
cbb9e0b1 PP	26	#include <stdlib.h>
	27	#include <string.h>
	28	#include <stdio.h>
	29	#include <assert.h>
	30	#include <glib.h>
a8b3f23b	31	#include <linux/limits.h>
cbb9e0b1 PP	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 */
	39	int test_plugin_init_called;
	40	int test_plugin_exit_called;
	41
	42	static void reset_test_plugin_symbols(void)
	43	{
	44	test_plugin_init_called = 0;
	45	test_plugin_exit_called = 0;
	46	}
	47
	48	static char get_test_plugin_path(const char plugin_dir,
	49	const char *plugin_name)
	50	{
	51	GString *path = g_string_new(plugin_dir);
	52	char *ret;
	53
	54	assert(path);
	55	g_string_append_printf(path, "/plugin-%s.so", plugin_name);
	56	ret = path->str;
	57	g_string_free(path, FALSE);
	58	return ret;
	59	}
	60
	61	static void test_invalid(const char *plugin_dir)
	62	{
6ba0b073	63	struct bt_plugin **plugins;
cbb9e0b1	64
6ba0b073 PP	65	plugins = bt_plugin_create_all_from_file(NON_EXISTING_PATH);
6ba0b073 PP	66	ok(!plugins, "bt_plugin_create_all_from_file() fails with a non-existing file");
cbb9e0b1	67
6ba0b073 PP	68	plugins = bt_plugin_create_all_from_file(plugin_dir);
6ba0b073 PP	69	ok(!plugins, "bt_plugin_create_all_from_file() fails with a directory");
cbb9e0b1	70
6ba0b073 PP	71	ok(!bt_plugin_create_all_from_file(NULL),
6ba0b073 PP	72	"bt_plugin_create_all_from_file() handles NULL correctly");
cbb9e0b1 PP	73	ok(!bt_plugin_create_all_from_dir(NULL, false),
	74	"bt_plugin_create_all_from_dir() handles NULL correctly");
	75	ok(!bt_plugin_get_name(NULL),
	76	"bt_plugin_get_name() handles NULL correctly");
	77	ok(!bt_plugin_get_description(NULL),
	78	"bt_plugin_get_description() handles NULL correctly");
458e8e1d PP	79	ok(bt_plugin_get_version(NULL, NULL, NULL, NULL, NULL) !=
	80	BT_PLUGIN_STATUS_OK,
	81	"bt_plugin_get_version() handles NULL correctly");
cbb9e0b1 PP	82	ok(!bt_plugin_get_author(NULL),
	83	"bt_plugin_get_author() handles NULL correctly");
	84	ok(!bt_plugin_get_license(NULL),
	85	"bt_plugin_get_license() handles NULL correctly");
	86	ok(!bt_plugin_get_path(NULL),
	87	"bt_plugin_get_path() handles NULL correctly");
	88	ok(bt_plugin_get_component_class_count(NULL) < 0,
	89	"bt_plugin_get_component_class_count() handles NULL correctly");
	90	ok(!bt_plugin_get_component_class(NULL, 0),
	91	"bt_plugin_get_component_class() handles NULL correctly");
	92	ok(!bt_plugin_get_component_class_by_name_and_type(NULL, NULL, 0),
	93	"bt_plugin_get_component_class_by_name_and_type() handles NULL correctly");
cbb9e0b1 PP	94	}
	95
	96	static void test_minimal(const char *plugin_dir)
	97	{
6ba0b073	98	struct bt_plugin **plugins;
cbb9e0b1 PP	99	struct bt_plugin *plugin;
	100	char *minimal_path = get_test_plugin_path(plugin_dir, "minimal");
	101
	102	assert(minimal_path);
	103	diag("minimal plugin test below");
	104
	105	reset_test_plugin_symbols();
6ba0b073 PP	106	plugins = bt_plugin_create_all_from_file(minimal_path);
	107	ok(plugins && plugins[0], "bt_plugin_create_all_from_file() succeeds with a valid file");
	108	ok(test_plugin_init_called, "plugin's initialization function is called during bt_plugin_create_all_from_file()");
	109	ok(plugins && plugins[0] && !plugins[1],
	110	"bt_plugin_create_all_from_file() returns the expected number of plugins");
	111	plugin = plugins[0];
	112	ok(strcmp(bt_plugin_get_name(plugin), "test_minimal") == 0,
cbb9e0b1 PP	113	"bt_plugin_get_name() returns the expected name");
	114	ok(strcmp(bt_plugin_get_description(plugin),
	115	"Minimal Babeltrace plugin with no component classes") == 0,
	116	"bt_plugin_get_description() returns the expected description");
458e8e1d PP	117	ok(bt_plugin_get_version(plugin, NULL, NULL, NULL, NULL) !=
	118	BT_PLUGIN_STATUS_OK,
	119	"bt_plugin_get_version() fails when there's no version");
cbb9e0b1 PP	120	ok(strcmp(bt_plugin_get_author(plugin), "Janine Sutto") == 0,
	121	"bt_plugin_get_author() returns the expected author");
	122	ok(strcmp(bt_plugin_get_license(plugin), "Beerware") == 0,
	123	"bt_plugin_get_license() returns the expected license");
	124	ok(strcmp(bt_plugin_get_path(plugin), minimal_path) == 0,
	125	"bt_plugin_get_path() returns the expected path");
	126	ok(bt_plugin_get_component_class_count(plugin) == 0,
	127	"bt_plugin_get_component_class_count() returns the expected value");
	128	BT_PUT(plugin);
	129	ok(test_plugin_exit_called, "plugin's exit function is called when the plugin is destroyed");
	130
	131	free(minimal_path);
6ba0b073	132	free(plugins);
cbb9e0b1 PP	133	}
	134
	135	static void test_sfs(const char *plugin_dir)
	136	{
6ba0b073	137	struct bt_plugin **plugins;
cbb9e0b1 PP	138	struct bt_plugin *plugin;
	139	struct bt_component_class *sink_comp_class;
	140	struct bt_component_class *source_comp_class;
	141	struct bt_component_class *filter_comp_class;
	142	struct bt_component *sink_component;
	143	char *sfs_path = get_test_plugin_path(plugin_dir, "sfs");
458e8e1d PP	144	unsigned int major, minor, patch;
458e8e1d PP	145	const char *extra;
5933c0f2 PP	146	struct bt_value *params;
5933c0f2 PP	147	struct bt_value *results;
a67681c1	148	struct bt_value *object;
5933c0f2	149	struct bt_value *res_params;
a67681c1	150	const char *object_str;
5933c0f2	151	int ret;
cbb9e0b1 PP	152
	153	assert(sfs_path);
	154	diag("sfs plugin test below");
	155
6ba0b073 PP	156	plugins = bt_plugin_create_all_from_file(sfs_path);
	157	assert(plugins && plugins[0]);
	158	plugin = plugins[0];
458e8e1d PP	159	ok(bt_plugin_get_version(plugin, &major, &minor, &patch, &extra) ==
	160	BT_PLUGIN_STATUS_OK,
	161	"bt_plugin_get_version() succeeds when there's a version");
	162	ok(major == 1,
	163	"bt_plugin_get_version() returns the expected major version");
	164	ok(minor == 2,
	165	"bt_plugin_get_version() returns the expected minor version");
	166	ok(patch == 3,
	167	"bt_plugin_get_version() returns the expected patch version");
	168	ok(strcmp(extra, "yes") == 0,
	169	"bt_plugin_get_version() returns the expected extra version");
cbb9e0b1 PP	170	ok(bt_plugin_get_component_class_count(plugin) == 3,
	171	"bt_plugin_get_component_class_count() returns the expected value");
	172
	173	source_comp_class = bt_plugin_get_component_class_by_name_and_type(
d3e4dcd8	174	plugin, "source", BT_COMPONENT_CLASS_TYPE_SOURCE);
cbb9e0b1 PP	175	ok(source_comp_class,
	176	"bt_plugin_get_component_class_by_name_and_type() finds a source component class");
	177
	178	sink_comp_class = bt_plugin_get_component_class_by_name_and_type(
d3e4dcd8	179	plugin, "sink", BT_COMPONENT_CLASS_TYPE_SINK);
cbb9e0b1 PP	180	ok(sink_comp_class,
cbb9e0b1 PP	181	"bt_plugin_get_component_class_by_name_and_type() finds a sink component class");
a889b89f PP	182	ok(strcmp(bt_component_class_get_help(sink_comp_class),
	183	"Bacon ipsum dolor amet strip steak cupim pastrami venison shoulder.\n"
	184	"Prosciutto beef ribs flank meatloaf pancetta brisket kielbasa drumstick\n"
	185	"venison tenderloin cow tail. Beef short loin shoulder meatball, sirloin\n"
	186	"ground round brisket salami cupim pork bresaola turkey bacon boudin.\n") == 0,
	187	"bt_component_class_get_help() returns the expected help text");
	188
cbb9e0b1	189	filter_comp_class = bt_plugin_get_component_class_by_name_and_type(
d3e4dcd8	190	plugin, "filter", BT_COMPONENT_CLASS_TYPE_FILTER);
cbb9e0b1 PP	191	ok(filter_comp_class,
	192	"bt_plugin_get_component_class_by_name_and_type() finds a filter component class");
	193	ok(!bt_plugin_get_component_class_by_name_and_type(plugin, "filter",
d3e4dcd8	194	BT_COMPONENT_CLASS_TYPE_SOURCE),
cbb9e0b1	195	"bt_plugin_get_component_class_by_name_and_type() does not find a component class given the wrong type");
5933c0f2 PP	196	params = bt_value_integer_create_init(23);
5933c0f2 PP	197	assert(params);
a67681c1 PP	198	ok (!bt_component_class_query(NULL, "get-something", params),
	199	"bt_component_class_query() handles NULL (component class)");
	200	ok (!bt_component_class_query(filter_comp_class, NULL, params),
	201	"bt_component_class_query() handles NULL (object)");
	202	ok (!bt_component_class_query(filter_comp_class, "get-something", NULL),
	203	"bt_component_class_query() handles NULL (parameters)");
	204	results = bt_component_class_query(filter_comp_class,
5933c0f2	205	"get-something", params);
a67681c1	206	ok(results, "bt_component_class_query() succeeds");
5933c0f2	207	assert(bt_value_is_array(results) && bt_value_array_size(results) == 2);
a67681c1 PP	208	object = bt_value_array_get(results, 0);
	209	assert(object && bt_value_is_string(object));
	210	ret = bt_value_string_get(object, &object_str);
5933c0f2	211	assert(ret == 0);
a67681c1 PP	212	ok(strcmp(object_str, "get-something") == 0,
a67681c1 PP	213	"bt_component_class_query() receives the expected object name");
5933c0f2 PP	214	res_params = bt_value_array_get(results, 1);
5933c0f2 PP	215	ok(res_params == params,
a67681c1	216	"bt_component_class_query() receives the expected parameters");
cbb9e0b1 PP	217
	218	diag("> putting the plugin object here");
	219	BT_PUT(plugin);
2b43acf9	220	sink_component = bt_component_create(sink_comp_class, NULL, NULL);
cbb9e0b1 PP	221	ok(sink_component, "bt_component_create() still works after the plugin object is destroyed");
	222	BT_PUT(sink_component);
	223	BT_PUT(source_comp_class);
2b43acf9	224	sink_component = bt_component_create(sink_comp_class, NULL, NULL);
cbb9e0b1 PP	225	ok(sink_component, "bt_component_create() still works after the source component class object is destroyed");
	226	BT_PUT(sink_component);
	227	BT_PUT(filter_comp_class);
2b43acf9	228	sink_component = bt_component_create(sink_comp_class, NULL, NULL);
cbb9e0b1 PP	229	ok(sink_component, "bt_component_create() still works after the filter component class object is destroyed");
	230	BT_PUT(sink_comp_class);
	231	BT_PUT(sink_component);
	232
	233	free(sfs_path);
6ba0b073	234	free(plugins);
a67681c1	235	bt_put(object);
5933c0f2 PP	236	bt_put(res_params);
	237	bt_put(results);
	238	bt_put(params);
cbb9e0b1 PP	239	}
	240
	241	static void test_create_all_from_dir(const char *plugin_dir)
	242	{
	243	struct bt_plugin **plugins;
	244	struct bt_plugin *plugin;
	245	int i;
	246
	247	diag("create from all test below");
	248
	249	plugins = bt_plugin_create_all_from_dir(NON_EXISTING_PATH, false);
	250	ok(!plugins,
	251	"bt_plugin_create_all_from_dir() fails with an invalid path");
	252
	253	plugins = bt_plugin_create_all_from_dir(plugin_dir, false);
	254	ok(plugins, "bt_plugin_create_all_from_dir() succeeds with a valid path");
	255
	256	i = 0;
	257	while ((plugin = plugins[i])) {
	258	BT_PUT(plugin);
	259	i++;
	260	}
	261
	262	/* 2 or 4, if `.la` files are considered or not */
	263	ok(i == 2 \|\| i == 4, "bt_plugin_create_all_from_dir() returns the expected number of plugin objects");
	264
	265	free(plugins);
	266	}
	267
2b43acf9	268	static void test_find(const char *plugin_dir)
a8b3f23b PP	269	{
a8b3f23b PP	270	struct bt_plugin *plugin;
2b43acf9 PP	271	struct bt_component_class *comp_cls_sink;
2b43acf9 PP	272	struct bt_component_class *comp_cls_source;
a8b3f23b PP	273	char *plugin_path;
a8b3f23b PP	274
2b43acf9 PP	275	ok(!bt_plugin_find(NULL),
	276	"bt_plugin_find() handles NULL");
	277	ok(!bt_plugin_find(NON_EXISTING_PATH),
	278	"bt_plugin_find() returns NULL with an unknown plugin name");
a8b3f23b PP	279	plugin_path = malloc(PATH_MAX * 5);
	280	assert(plugin_path);
	281	sprintf(plugin_path, "%s:/ec1d09e5-696c-442e-b1c3-f9c6cf7f5958:::%s:8db46494-a398-466a-9649-c765ae077629:",
	282	NON_EXISTING_PATH, plugin_dir);
	283	setenv("BABELTRACE_PLUGIN_PATH", plugin_path, 1);
2b43acf9	284	plugin = bt_plugin_find("test_minimal");
a8b3f23b	285	ok(plugin,
2b43acf9	286	"bt_plugin_find() succeeds with a plugin name it can find");
a8b3f23b	287	ok(strcmp(bt_plugin_get_author(plugin), "Janine Sutto") == 0,
2b43acf9	288	"bt_plugin_find() finds the correct plugin for a given name");
a8b3f23b	289	BT_PUT(plugin);
2b43acf9 PP	290	comp_cls_sink = bt_plugin_find_component_class(NULL, "sink",
	291	BT_COMPONENT_CLASS_TYPE_SINK);
	292	ok(!comp_cls_sink, "bt_plugin_find_component_class() handles NULL (plugin name)");
	293	comp_cls_sink = bt_plugin_find_component_class("test_sfs", NULL,
	294	BT_COMPONENT_CLASS_TYPE_SINK);
	295	ok(!comp_cls_sink, "bt_plugin_find_component_class() handles NULL (component class name)");
	296	comp_cls_sink = bt_plugin_find_component_class("test_sfs", "sink2",
	297	BT_COMPONENT_CLASS_TYPE_SINK);
	298	ok(!comp_cls_sink, "bt_plugin_find_component_class() fails with an unknown component class name");
	299	comp_cls_sink = bt_plugin_find_component_class("test_sfs", "sink",
	300	BT_COMPONENT_CLASS_TYPE_SINK);
	301	ok(comp_cls_sink, "bt_plugin_find_component_class() succeeds with valid parameters");
	302	ok(strcmp(bt_component_class_get_name(comp_cls_sink), "sink") == 0,
	303	"bt_plugin_find_component_class() returns the appropriate component class (sink)");
	304	comp_cls_source = bt_plugin_find_component_class("test_sfs", "source",
	305	BT_COMPONENT_CLASS_TYPE_SOURCE);
	306	ok(comp_cls_sink, "bt_plugin_find_component_class() succeeds with another component class name (same plugin)");
	307	ok(strcmp(bt_component_class_get_name(comp_cls_source), "source") == 0,
	308	"bt_plugin_find_component_class() returns the appropriate component class (source)");
	309	BT_PUT(comp_cls_sink);
	310	BT_PUT(comp_cls_source);
a8b3f23b PP	311	free(plugin_path);
	312	}
	313
cbb9e0b1 PP	314	int main(int argc, char **argv)
	315	{
	316	int ret;
	317	const char *plugin_dir;
	318
	319	if (argc != 2) {
	320	puts("Usage: test_plugin plugin_directory");
	321	ret = 1;
	322	goto end;
	323	}
	324
	325	plugin_dir = argv[1];
	326	plan_tests(NR_TESTS);
	327	test_invalid(plugin_dir);
	328	test_minimal(plugin_dir);
	329	test_sfs(plugin_dir);
	330	test_create_all_from_dir(plugin_dir);
2b43acf9	331	test_find(plugin_dir);
cbb9e0b1 PP	332	ret = exit_status();
	333	end:
	334	return ret;
	335	}