tests/lib/test_plugin.c

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