[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 <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 		44
#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;

	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");
	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");

	diag("> putting the plugin object here");
	BT_PUT(plugin);
	sink_component = bt_component_create(sink_comp_class, NULL, bt_value_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, bt_value_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, bt_value_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);
}

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_create_from_name(const char *plugin_dir)
{
	struct bt_plugin *plugin;
	char *plugin_path;

	ok(!bt_plugin_create_from_name(NULL),
		"bt_plugin_create_from_name() handles NULL");
	ok(!bt_plugin_create_from_name(NON_EXISTING_PATH),
		"bt_plugin_create_from_name() 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_create_from_name("test_minimal");
	ok(plugin,
		"bt_plugin_create_from_name() succeeds with a plugin name it can find");
	ok(strcmp(bt_plugin_get_author(plugin), "Janine Sutto") == 0,
		"bt_plugin_create_from_name() finds the correct plugin for a given name");
	BT_PUT(plugin);
	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_create_from_name(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>
	25	#include <stdlib.h>
	26	#include <string.h>
	27	#include <stdio.h>
	28	#include <assert.h>
	29	#include <glib.h>
a8b3f23b	30	#include <linux/limits.h>
cbb9e0b1 PP	31	#include "tap/tap.h"
	32	#include "common.h"
	33
a8b3f23b	34	#define NR_TESTS 44
cbb9e0b1 PP	35	#define NON_EXISTING_PATH "/this/hopefully/does/not/exist/5bc75f8d-0dba-4043-a509-d7984b97e42b.so"
	36
	37	/* Those symbols are written to by some test plugins */
	38	int test_plugin_init_called;
	39	int test_plugin_exit_called;
	40
	41	static void reset_test_plugin_symbols(void)
	42	{
	43	test_plugin_init_called = 0;
	44	test_plugin_exit_called = 0;
	45	}
	46
	47	static char get_test_plugin_path(const char plugin_dir,
	48	const char *plugin_name)
	49	{
	50	GString *path = g_string_new(plugin_dir);
	51	char *ret;
	52
	53	assert(path);
	54	g_string_append_printf(path, "/plugin-%s.so", plugin_name);
	55	ret = path->str;
	56	g_string_free(path, FALSE);
	57	return ret;
	58	}
	59
	60	static void test_invalid(const char *plugin_dir)
	61	{
6ba0b073	62	struct bt_plugin **plugins;
cbb9e0b1	63
6ba0b073 PP	64	plugins = bt_plugin_create_all_from_file(NON_EXISTING_PATH);
6ba0b073 PP	65	ok(!plugins, "bt_plugin_create_all_from_file() fails with a non-existing file");
cbb9e0b1	66
6ba0b073 PP	67	plugins = bt_plugin_create_all_from_file(plugin_dir);
6ba0b073 PP	68	ok(!plugins, "bt_plugin_create_all_from_file() fails with a directory");
cbb9e0b1	69
6ba0b073 PP	70	ok(!bt_plugin_create_all_from_file(NULL),
6ba0b073 PP	71	"bt_plugin_create_all_from_file() handles NULL correctly");
cbb9e0b1 PP	72	ok(!bt_plugin_create_all_from_dir(NULL, false),
	73	"bt_plugin_create_all_from_dir() handles NULL correctly");
	74	ok(!bt_plugin_get_name(NULL),
	75	"bt_plugin_get_name() handles NULL correctly");
	76	ok(!bt_plugin_get_description(NULL),
	77	"bt_plugin_get_description() handles NULL correctly");
458e8e1d PP	78	ok(bt_plugin_get_version(NULL, NULL, NULL, NULL, NULL) !=
	79	BT_PLUGIN_STATUS_OK,
	80	"bt_plugin_get_version() handles NULL correctly");
cbb9e0b1 PP	81	ok(!bt_plugin_get_author(NULL),
	82	"bt_plugin_get_author() handles NULL correctly");
	83	ok(!bt_plugin_get_license(NULL),
	84	"bt_plugin_get_license() handles NULL correctly");
	85	ok(!bt_plugin_get_path(NULL),
	86	"bt_plugin_get_path() handles NULL correctly");
	87	ok(bt_plugin_get_component_class_count(NULL) < 0,
	88	"bt_plugin_get_component_class_count() handles NULL correctly");
	89	ok(!bt_plugin_get_component_class(NULL, 0),
	90	"bt_plugin_get_component_class() handles NULL correctly");
	91	ok(!bt_plugin_get_component_class_by_name_and_type(NULL, NULL, 0),
	92	"bt_plugin_get_component_class_by_name_and_type() handles NULL correctly");
cbb9e0b1 PP	93	}
	94
	95	static void test_minimal(const char *plugin_dir)
	96	{
6ba0b073	97	struct bt_plugin **plugins;
cbb9e0b1 PP	98	struct bt_plugin *plugin;
	99	char *minimal_path = get_test_plugin_path(plugin_dir, "minimal");
	100
	101	assert(minimal_path);
	102	diag("minimal plugin test below");
	103
	104	reset_test_plugin_symbols();
6ba0b073 PP	105	plugins = bt_plugin_create_all_from_file(minimal_path);
	106	ok(plugins && plugins[0], "bt_plugin_create_all_from_file() succeeds with a valid file");
	107	ok(test_plugin_init_called, "plugin's initialization function is called during bt_plugin_create_all_from_file()");
	108	ok(plugins && plugins[0] && !plugins[1],
	109	"bt_plugin_create_all_from_file() returns the expected number of plugins");
	110	plugin = plugins[0];
	111	ok(strcmp(bt_plugin_get_name(plugin), "test_minimal") == 0,
cbb9e0b1 PP	112	"bt_plugin_get_name() returns the expected name");
	113	ok(strcmp(bt_plugin_get_description(plugin),
	114	"Minimal Babeltrace plugin with no component classes") == 0,
	115	"bt_plugin_get_description() returns the expected description");
458e8e1d PP	116	ok(bt_plugin_get_version(plugin, NULL, NULL, NULL, NULL) !=
	117	BT_PLUGIN_STATUS_OK,
	118	"bt_plugin_get_version() fails when there's no version");
cbb9e0b1 PP	119	ok(strcmp(bt_plugin_get_author(plugin), "Janine Sutto") == 0,
	120	"bt_plugin_get_author() returns the expected author");
	121	ok(strcmp(bt_plugin_get_license(plugin), "Beerware") == 0,
	122	"bt_plugin_get_license() returns the expected license");
	123	ok(strcmp(bt_plugin_get_path(plugin), minimal_path) == 0,
	124	"bt_plugin_get_path() returns the expected path");
	125	ok(bt_plugin_get_component_class_count(plugin) == 0,
	126	"bt_plugin_get_component_class_count() returns the expected value");
	127	BT_PUT(plugin);
	128	ok(test_plugin_exit_called, "plugin's exit function is called when the plugin is destroyed");
	129
	130	free(minimal_path);
6ba0b073	131	free(plugins);
cbb9e0b1 PP	132	}
	133
	134	static void test_sfs(const char *plugin_dir)
	135	{
6ba0b073	136	struct bt_plugin **plugins;
cbb9e0b1 PP	137	struct bt_plugin *plugin;
	138	struct bt_component_class *sink_comp_class;
	139	struct bt_component_class *source_comp_class;
	140	struct bt_component_class *filter_comp_class;
	141	struct bt_component *sink_component;
	142	char *sfs_path = get_test_plugin_path(plugin_dir, "sfs");
458e8e1d PP	143	unsigned int major, minor, patch;
458e8e1d PP	144	const char *extra;
cbb9e0b1 PP	145
	146	assert(sfs_path);
	147	diag("sfs plugin test below");
	148
6ba0b073 PP	149	plugins = bt_plugin_create_all_from_file(sfs_path);
	150	assert(plugins && plugins[0]);
	151	plugin = plugins[0];
458e8e1d PP	152	ok(bt_plugin_get_version(plugin, &major, &minor, &patch, &extra) ==
	153	BT_PLUGIN_STATUS_OK,
	154	"bt_plugin_get_version() succeeds when there's a version");
	155	ok(major == 1,
	156	"bt_plugin_get_version() returns the expected major version");
	157	ok(minor == 2,
	158	"bt_plugin_get_version() returns the expected minor version");
	159	ok(patch == 3,
	160	"bt_plugin_get_version() returns the expected patch version");
	161	ok(strcmp(extra, "yes") == 0,
	162	"bt_plugin_get_version() returns the expected extra version");
cbb9e0b1 PP	163	ok(bt_plugin_get_component_class_count(plugin) == 3,
	164	"bt_plugin_get_component_class_count() returns the expected value");
	165
	166	source_comp_class = bt_plugin_get_component_class_by_name_and_type(
d3e4dcd8	167	plugin, "source", BT_COMPONENT_CLASS_TYPE_SOURCE);
cbb9e0b1 PP	168	ok(source_comp_class,
	169	"bt_plugin_get_component_class_by_name_and_type() finds a source component class");
	170
	171	sink_comp_class = bt_plugin_get_component_class_by_name_and_type(
d3e4dcd8	172	plugin, "sink", BT_COMPONENT_CLASS_TYPE_SINK);
cbb9e0b1 PP	173
	174	ok(sink_comp_class,
	175	"bt_plugin_get_component_class_by_name_and_type() finds a sink component class");
	176	filter_comp_class = bt_plugin_get_component_class_by_name_and_type(
d3e4dcd8	177	plugin, "filter", BT_COMPONENT_CLASS_TYPE_FILTER);
cbb9e0b1 PP	178
	179	ok(filter_comp_class,
	180	"bt_plugin_get_component_class_by_name_and_type() finds a filter component class");
	181	ok(!bt_plugin_get_component_class_by_name_and_type(plugin, "filter",
d3e4dcd8	182	BT_COMPONENT_CLASS_TYPE_SOURCE),
cbb9e0b1 PP	183	"bt_plugin_get_component_class_by_name_and_type() does not find a component class given the wrong type");
	184
	185	diag("> putting the plugin object here");
	186	BT_PUT(plugin);
	187	sink_component = bt_component_create(sink_comp_class, NULL, bt_value_null);
	188	ok(sink_component, "bt_component_create() still works after the plugin object is destroyed");
	189	BT_PUT(sink_component);
	190	BT_PUT(source_comp_class);
	191	sink_component = bt_component_create(sink_comp_class, NULL, bt_value_null);
	192	ok(sink_component, "bt_component_create() still works after the source component class object is destroyed");
	193	BT_PUT(sink_component);
	194	BT_PUT(filter_comp_class);
	195	sink_component = bt_component_create(sink_comp_class, NULL, bt_value_null);
	196	ok(sink_component, "bt_component_create() still works after the filter component class object is destroyed");
	197	BT_PUT(sink_comp_class);
	198	BT_PUT(sink_component);
	199
	200	free(sfs_path);
6ba0b073	201	free(plugins);
cbb9e0b1 PP	202	}
	203
	204	static void test_create_all_from_dir(const char *plugin_dir)
	205	{
	206	struct bt_plugin **plugins;
	207	struct bt_plugin *plugin;
	208	int i;
	209
	210	diag("create from all test below");
	211
	212	plugins = bt_plugin_create_all_from_dir(NON_EXISTING_PATH, false);
	213	ok(!plugins,
	214	"bt_plugin_create_all_from_dir() fails with an invalid path");
	215
	216	plugins = bt_plugin_create_all_from_dir(plugin_dir, false);
	217	ok(plugins, "bt_plugin_create_all_from_dir() succeeds with a valid path");
	218
	219	i = 0;
	220	while ((plugin = plugins[i])) {
	221	BT_PUT(plugin);
	222	i++;
	223	}
	224
	225	/* 2 or 4, if `.la` files are considered or not */
	226	ok(i == 2 \|\| i == 4, "bt_plugin_create_all_from_dir() returns the expected number of plugin objects");
	227
	228	free(plugins);
	229	}
	230
a8b3f23b PP	231	static void test_create_from_name(const char *plugin_dir)
	232	{
	233	struct bt_plugin *plugin;
	234	char *plugin_path;
	235
	236	ok(!bt_plugin_create_from_name(NULL),
	237	"bt_plugin_create_from_name() handles NULL");
	238	ok(!bt_plugin_create_from_name(NON_EXISTING_PATH),
	239	"bt_plugin_create_from_name() returns NULL with an unknown plugin name");
	240	plugin_path = malloc(PATH_MAX * 5);
	241	assert(plugin_path);
	242	sprintf(plugin_path, "%s:/ec1d09e5-696c-442e-b1c3-f9c6cf7f5958:::%s:8db46494-a398-466a-9649-c765ae077629:",
	243	NON_EXISTING_PATH, plugin_dir);
	244	setenv("BABELTRACE_PLUGIN_PATH", plugin_path, 1);
	245	plugin = bt_plugin_create_from_name("test_minimal");
	246	ok(plugin,
	247	"bt_plugin_create_from_name() succeeds with a plugin name it can find");
	248	ok(strcmp(bt_plugin_get_author(plugin), "Janine Sutto") == 0,
	249	"bt_plugin_create_from_name() finds the correct plugin for a given name");
	250	BT_PUT(plugin);
	251	free(plugin_path);
	252	}
	253
cbb9e0b1 PP	254	int main(int argc, char **argv)
	255	{
	256	int ret;
	257	const char *plugin_dir;
	258
	259	if (argc != 2) {
	260	puts("Usage: test_plugin plugin_directory");
	261	ret = 1;
	262	goto end;
	263	}
	264
	265	plugin_dir = argv[1];
	266	plan_tests(NR_TESTS);
	267	test_invalid(plugin_dir);
	268	test_minimal(plugin_dir);
	269	test_sfs(plugin_dir);
	270	test_create_all_from_dir(plugin_dir);
a8b3f23b	271	test_create_from_name(plugin_dir);
cbb9e0b1 PP	272	ret = exit_status();
	273	end:
	274	return ret;
	275	}