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 <stdlib.h>
  27 #include <string.h>
  28 #include <stdio.h>
  29 #include <assert.h>
  30 #include <glib.h>
  31 #include <linux/limits.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 **plugins;
  64
  65         plugins = bt_plugin_create_all_from_file(NON_EXISTING_PATH);
  66         ok(!plugins, "bt_plugin_create_all_from_file() fails with a non-existing file");
  67
  68         plugins = bt_plugin_create_all_from_file(plugin_dir);
  69         ok(!plugins, "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, 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(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");
  94 }
  95
  96 static void test_minimal(const char *plugin_dir)
  97 {
  98         struct bt_plugin **plugins;
  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         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,
 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");
 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");
 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);
 132         free(plugins);
 133 }
 134
 135 static void test_sfs(const char *plugin_dir)
 136 {
 137         struct bt_plugin **plugins;
 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");
 144         unsigned int major, minor, patch;
 145         const char *extra;
 146         struct bt_value *params;
 147         struct bt_value *results;
 148         struct bt_value *object;
 149         struct bt_value *res_params;
 150         const char *object_str;
 151         int ret;
 152
 153         assert(sfs_path);
 154         diag("sfs plugin test below");
 155
 156         plugins = bt_plugin_create_all_from_file(sfs_path);
 157         assert(plugins && plugins[0]);
 158         plugin = plugins[0];
 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");
 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(
 174                 plugin, "source", BT_COMPONENT_CLASS_TYPE_SOURCE);
 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(
 179                 plugin, "sink", BT_COMPONENT_CLASS_TYPE_SINK);
 180         ok(sink_comp_class,
 181                 "bt_plugin_get_component_class_by_name_and_type() finds a sink component class");
 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
 189         filter_comp_class = bt_plugin_get_component_class_by_name_and_type(
 190                 plugin, "filter", BT_COMPONENT_CLASS_TYPE_FILTER);
 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",
 194                 BT_COMPONENT_CLASS_TYPE_SOURCE),
 195                 "bt_plugin_get_component_class_by_name_and_type() does not find a component class given the wrong type");
 196         params = bt_value_integer_create_init(23);
 197         assert(params);
 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,
 205                 "get-something", params);
 206         ok(results, "bt_component_class_query() succeeds");
 207         assert(bt_value_is_array(results) && bt_value_array_size(results) == 2);
 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);
 211         assert(ret == 0);
 212         ok(strcmp(object_str, "get-something") == 0,
 213                 "bt_component_class_query() receives the expected object name");
 214         res_params = bt_value_array_get(results, 1);
 215         ok(res_params == params,
 216                 "bt_component_class_query() receives the expected parameters");
 217
 218         diag("> putting the plugin object here");
 219         BT_PUT(plugin);
 220         sink_component = bt_component_create(sink_comp_class, NULL, NULL);
 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);
 224         sink_component = bt_component_create(sink_comp_class, NULL, NULL);
 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);
 228         sink_component = bt_component_create(sink_comp_class, NULL, NULL);
 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);
 234         free(plugins);
 235         bt_put(object);
 236         bt_put(res_params);
 237         bt_put(results);
 238         bt_put(params);
 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
 268 static void test_find(const char *plugin_dir)
 269 {
 270         struct bt_plugin *plugin;
 271         struct bt_component_class *comp_cls_sink;
 272         struct bt_component_class *comp_cls_source;
 273         char *plugin_path;
 274
 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");
 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);
 284         plugin = bt_plugin_find("test_minimal");
 285         ok(plugin,
 286                 "bt_plugin_find() succeeds with a plugin name it can find");
 287         ok(strcmp(bt_plugin_get_author(plugin), "Janine Sutto") == 0,
 288                 "bt_plugin_find() finds the correct plugin for a given name");
 289         BT_PUT(plugin);
 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);
 311         free(plugin_path);
 312 }
 313
 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);
 331         test_find(plugin_dir);
 332         ret = exit_status();
 333 end:
 334         return ret;
 335 }