qulogic/gplugin

Merged in feature/loader-registration-cleanup (pull request #62)
develop
2020-02-25, Gary Kramlich
c41afcd857ea
Parents 16b02c26028e17de6528736d
Children a9a1381feea9a5022abf9976
Merged in feature/loader-registration-cleanup (pull request #62)

Feature/loader registration cleanup

Approved-by: Elliott Sales de Andrade
15 files changed, 350 insertions(+), 109 deletions(-)
  • +10 -6
    gplugin/gplugin-loader.c
  • +2 -2
    gplugin/gplugin-loader.h
  • +134 -64
    gplugin/gplugin-manager.c
  • +2 -2
    gplugin/gplugin-manager.h
  • +4 -4
    gplugin/gplugin-native-loader.c
  • +4 -0
    gplugin/tests/meson.build
  • +179 -0
    gplugin/tests/test-loader-registration.c
  • +2 -6
    lua/gplugin-lua-core.c
  • +2 -2
    lua/gplugin-lua-loader.c
  • +1 -3
    perl/gplugin-perl-core.c
  • +2 -2
    perl/gplugin-perl-loader.c
  • +1 -3
    python/gplugin-python3-core.c
  • +2 -2
    python/gplugin-python3-loader.c
  • +2 -6
    tcc/gplugin-tcc-core.c
  • +3 -7
    tcc/gplugin-tcc-loader.c
    • --- a/gplugin/gplugin-loader.c Tue Feb 25 04:25:47 2020 +0000
    +++ b/gplugin/gplugin-loader.c Tue Feb 25 04:37:20 2020 +0000
    @@ -173,8 +173,8 @@
    }
    /**
    - * gplugin_loader_class_get_supported_extensions:
    - * @klass: The #GPluginLoaderClass.
    + * gplugin_loader_get_supported_extensions:
    + * @loader: The #GPluginLoader instance.
    *
    * Returns a #GSList of strings containing the extensions that the loader
    * supports. Each extension should not include the dot. For example: so,
    @@ -184,11 +184,15 @@
    * extensions that the loader supports.
    */
    GSList *
    -gplugin_loader_class_get_supported_extensions(GPluginLoaderClass *klass) {
    - g_return_val_if_fail(GPLUGIN_IS_LOADER_CLASS(klass), NULL);
    +gplugin_loader_get_supported_extensions(GPluginLoader *loader) {
    + GPluginLoaderClass *klass = NULL;
    +
    + g_return_val_if_fail(GPLUGIN_IS_LOADER(loader), NULL);
    - if(klass->supported_extensions)
    - return klass->supported_extensions(klass);
    + klass = GPLUGIN_LOADER_GET_CLASS(loader);
    + if(klass != NULL && klass->supported_extensions) {
    + return klass->supported_extensions(loader);
    + }
    return NULL;
    }
    --- a/gplugin/gplugin-loader.h Tue Feb 25 04:25:47 2020 +0000
    +++ b/gplugin/gplugin-loader.h Tue Feb 25 04:37:20 2020 +0000
    @@ -38,7 +38,7 @@
    GObjectClass gparent;
    /*< public >*/
    - GSList *(*supported_extensions)(GPluginLoaderClass *klass);
    + GSList *(*supported_extensions)(GPluginLoader *loader);
    GPluginPlugin *(*query)(GPluginLoader *loader, const gchar *filename, GError **error);
    @@ -49,7 +49,7 @@
    gpointer reserved[4];
    };
    -GSList *gplugin_loader_class_get_supported_extensions(GPluginLoaderClass *klass);
    +GSList *gplugin_loader_get_supported_extensions(GPluginLoader *loader);
    GPluginPlugin *gplugin_loader_query_plugin(GPluginLoader *loader, const gchar *filename, GError **error);
    --- a/gplugin/gplugin-manager.c Tue Feb 25 04:25:47 2020 +0000
    +++ b/gplugin/gplugin-manager.c Tue Feb 25 04:37:20 2020 +0000
    @@ -61,7 +61,8 @@
    GHashTable *plugins;
    GHashTable *plugins_filename_view;
    - GHashTable *loaders;
    + GSList *loaders;
    + GHashTable *loaders_by_extension;
    gboolean refresh_needed;
    } GPluginManager;
    @@ -76,8 +77,8 @@
    GList *(*get_paths)(GPluginManager *manager);
    - void (*register_loader)(GPluginManager *manager, GType type);
    - void (*unregister_loader)(GPluginManager *manager, GType type);
    + gboolean (*register_loader)(GPluginManager *manager, GType type, GError **error);
    + gboolean (*unregister_loader)(GPluginManager *manager, GType type, GError **error);
    void (*refresh)(GPluginManager *manager);
    @@ -156,6 +157,31 @@
    return TRUE;
    }
    +/*
    + * gplugin_manager_find_loader_by_type:
    + * @manager: The #GPluginManager instance.
    + * @type: The #GType of the loader to find.
    + *
    + * Looks up a #GPluginLoader instance by its type.
    + *
    + * Returns: (transfer none): The #GPluginLoader instance or %NULL.
    + */
    +static GPluginLoader *
    +gplugin_manager_find_loader_by_type(GPluginManager *manager, GType type) {
    + GSList *l = NULL;
    +
    + g_return_val_if_fail(GPLUGIN_IS_MANAGER(manager), NULL);
    + g_return_val_if_fail(g_type_is_a(type, GPLUGIN_TYPE_LOADER), NULL);
    +
    + for(l = manager->loaders; l; l = l->next) {
    + if(G_OBJECT_TYPE(l->data) == type) {
    + return GPLUGIN_LOADER(l->data);
    + }
    + }
    +
    + return NULL;
    +}
    +
    /******************************************************************************
    * Manager implementation
    *****************************************************************************/
    @@ -219,37 +245,37 @@
    return manager->paths->head;
    }
    -static void
    -gplugin_manager_real_register_loader(GPluginManager *manager,
    - GType type)
    +static gboolean
    +gplugin_manager_real_register_loader(GPluginManager *manager, GType type,
    + GError **error)
    {
    GPluginLoader *loader = NULL;
    - GPluginLoaderClass *lo_class = NULL;
    - GSList *l = NULL;
    + GSList *l = NULL, *exts = NULL;
    +
    + g_return_val_if_fail(g_type_is_a(type, GPLUGIN_TYPE_LOADER), FALSE);
    - g_return_if_fail(g_type_is_a(type, GPLUGIN_TYPE_LOADER));
    + loader = gplugin_manager_find_loader_by_type(manager, type);
    + if(GPLUGIN_IS_LOADER(loader)) {
    + g_set_error(error, GPLUGIN_DOMAIN, 0,
    + _("loader %s was already registered"), g_type_name(type));
    + return FALSE;
    + }
    /* Create the loader instance first. If we can't create it, we bail */
    loader = g_object_new(type, NULL);
    if(!GPLUGIN_IS_LOADER(loader)) {
    - g_warning(_("failed to create loader instance for %s"),
    - g_type_name(type));
    + g_set_error(error, GPLUGIN_DOMAIN, 0,
    + _("failed to create loader instance for %s"),
    + g_type_name(type));
    - return;
    + return FALSE;
    }
    - /* grab the class of the loader */
    - lo_class = GPLUGIN_LOADER_GET_CLASS(loader);
    - if(!lo_class) {
    - g_warning(_("failed to get the loader class for %s"), g_type_name(type));
    - g_object_unref(G_OBJECT(loader));
    + manager->loaders = g_slist_prepend(manager->loaders,
    + g_object_ref(G_OBJECT(loader)));
    - return;
    - }
    -
    - for(l = gplugin_loader_class_get_supported_extensions(lo_class);
    - l; l = l->next)
    - {
    + exts = gplugin_loader_get_supported_extensions(loader);
    + for(l = exts; l; l = l->next) {
    GSList *existing = NULL, *ll = NULL;
    const gchar *ext = (const gchar *)l->data;
    @@ -257,7 +283,7 @@
    * we can prepend our loader. But before we add ours, we remove any
    * old copies we might have of ours.
    */
    - existing = g_hash_table_lookup(manager->loaders, ext);
    + existing = g_hash_table_lookup(manager->loaders_by_extension, ext);
    for(ll = existing; ll; ll = ll->next) {
    if(G_OBJECT_TYPE(ll->data) == type) {
    GPluginLoader *old = GPLUGIN_LOADER(ll->data);
    @@ -273,40 +299,48 @@
    existing = g_slist_prepend(existing, g_object_ref(G_OBJECT(loader)));
    /* Now insert the updated slist back into the hash table */
    - g_hash_table_insert(manager->loaders, g_strdup(ext), existing);
    + g_hash_table_insert(manager->loaders_by_extension, g_strdup(ext),
    + existing);
    }
    + g_slist_free(exts);
    /* make a note that we need to refresh */
    manager->refresh_needed = TRUE;
    /* we remove our initial reference from the loader now to avoid a leak */
    g_object_unref(G_OBJECT(loader));
    +
    + return TRUE;
    }
    -static void
    -gplugin_manager_real_unregister_loader(GPluginManager *manager,
    - GType type)
    +static gboolean
    +gplugin_manager_real_unregister_loader(GPluginManager *manager, GType type,
    + GError **error)
    {
    - GPluginLoaderClass *klass = NULL;
    - GSList *exts = NULL;
    + GPluginLoader *loader = NULL;
    + GSList *l = NULL, *exts = NULL;
    - g_return_if_fail(g_type_is_a(type, GPLUGIN_TYPE_LOADER));
    + g_return_val_if_fail(g_type_is_a(type, GPLUGIN_TYPE_LOADER), FALSE);
    - klass = g_type_class_ref(type);
    - if(!klass)
    - return;
    + loader = gplugin_manager_find_loader_by_type(manager, type);
    + if(!GPLUGIN_IS_LOADER(loader)) {
    + g_set_error(error, GPLUGIN_DOMAIN, 0,
    + _("loader %s is not registered"), g_type_name(type));
    - for(exts = gplugin_loader_class_get_supported_extensions(klass);
    - exts; exts = exts->next) {
    + return FALSE;
    + }
    +
    + exts = gplugin_loader_get_supported_extensions(loader);
    + for(l = exts; l; l = l->next) {
    GSList *los = NULL;
    - GSList *l = NULL;
    + GSList *ll = NULL;
    const gchar *ext = NULL;
    ext = (const gchar *)exts->data;
    - los = g_hash_table_lookup(manager->loaders, ext);
    + los = g_hash_table_lookup(manager->loaders_by_extension, ext);
    - for(l = los; l; l = l->next) {
    - GPluginLoader *lo = GPLUGIN_LOADER(l->data);
    + for(ll = los; ll; ll = ll->next) {
    + GPluginLoader *lo = GPLUGIN_LOADER(ll->data);
    /* check if this is not the loader we're looking for */
    if(G_OBJECT_TYPE(lo) != type)
    @@ -318,10 +352,12 @@
    * just update it.
    */
    los = g_slist_remove(los, lo);
    - if(los)
    - g_hash_table_insert(manager->loaders, g_strdup(ext), los);
    - else
    - g_hash_table_remove(manager->loaders, ext);
    + if(los) {
    + g_hash_table_insert(manager->loaders_by_extension,
    + g_strdup(ext), los);
    + } else {
    + g_hash_table_remove(manager->loaders_by_extension, ext);
    + }
    /* kill our ref to the loader */
    g_object_unref(G_OBJECT(lo));
    @@ -330,8 +366,12 @@
    break;
    }
    }
    + g_slist_free(exts);
    - g_type_class_unref(klass);
    + manager->loaders = g_slist_remove(manager->loaders, loader);
    + g_object_unref(G_OBJECT(loader));
    +
    + return TRUE;
    }
    static void
    @@ -392,9 +432,8 @@
    }
    /* grab the list of loaders for this extension */
    - for(l = g_hash_table_lookup(manager->loaders, e->extension); l;
    - l = l->next)
    - {
    + l = g_hash_table_lookup(manager->loaders_by_extension, e->extension);
    + for(; l; l = l->next) {
    if(!l->data)
    continue;
    @@ -850,11 +889,15 @@
    /* destroy the filename view */
    g_clear_pointer(&manager->plugins_filename_view, g_hash_table_destroy);
    + /* clean up our list of loaders */
    + g_slist_free_full(manager->loaders, g_object_unref);
    + manager->loaders = NULL;
    +
    /* free all the data in the loaders hash table and destroy it */
    - g_hash_table_foreach_remove(manager->loaders,
    + g_hash_table_foreach_remove(manager->loaders_by_extension,
    gplugin_manager_remove_list_value,
    NULL);
    - g_clear_pointer(&manager->loaders, g_hash_table_destroy);
    + g_clear_pointer(&manager->loaders_by_extension, g_hash_table_destroy);
    /* call the base class's destructor */
    G_OBJECT_CLASS(gplugin_manager_parent_class)->finalize(obj);
    @@ -1011,18 +1054,18 @@
    manager->plugins_filename_view =
    g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_object_unref);
    - /* The loaders hash table is keyed on the supported extensions of the
    - * loader. Which means that a loader that supports multiple extensions
    - * will be in the table multiple times.
    + /* The loaders_by_extension hash table is keyed on the supported extensions
    + * of the loader. Which means that a loader that supports multiple
    + * extensions will be in the table multiple times.
    *
    * We deal with collisions by using a GSList for the value which will hold
    * references to instances of the actual loaders.
    *
    - * Storing this in this method allows up to quickly figure out which loader
    + * Storing this in this method allows us to quickly figure out which loader
    * to use by the filename and helps us to avoid iterating the loaders table
    * again and again.
    */
    - manager->loaders =
    + manager->loaders_by_extension =
    g_hash_table_new_full(gplugin_manager_str_hash, g_str_equal,
    g_free, NULL);
    }
    @@ -1032,13 +1075,22 @@
    *****************************************************************************/
    void
    gplugin_manager_private_init(void) {
    + GError *error = NULL;
    +
    if (instance != NULL) {
    return;
    }
    instance = g_object_new(GPLUGIN_TYPE_MANAGER, NULL);
    - gplugin_manager_register_loader(GPLUGIN_TYPE_NATIVE_LOADER);
    + if(!gplugin_manager_register_loader(GPLUGIN_TYPE_NATIVE_LOADER, &error)) {
    + if(error != NULL) {
    + g_error("failed to register loader: %s", error->message);
    + g_error_free(error);
    + } else {
    + g_error("failed to register loader: unknown failure");
    + }
    + }
    dependency_regex = g_regex_new(dependency_pattern, 0, 0, NULL);
    }
    @@ -1201,37 +1253,55 @@
    /**
    * gplugin_manager_register_loader:
    * @type: #GType of a #GPluginLoader.
    + * @error: (out) (nullable): The return address for a #GError.
    *
    * Registers @type as an available loader.
    + *
    + * Returns: %TRUE if the loader was successfully register, %FALSE otherwise
    + * with @error set.
    */
    -void
    -gplugin_manager_register_loader(GType type) {
    +gboolean
    +gplugin_manager_register_loader(GType type, GError **error) {
    GPluginManager *manager = GPLUGIN_MANAGER_INSTANCE;
    GPluginManagerClass *klass = NULL;
    - g_return_if_fail(GPLUGIN_IS_MANAGER(manager));
    + g_return_val_if_fail(GPLUGIN_IS_MANAGER(manager), FALSE);
    klass = GPLUGIN_MANAGER_GET_CLASS(manager);
    if(klass && klass->register_loader)
    - klass->register_loader(manager, type);
    + return klass->register_loader(manager, type, error);
    +
    + g_set_error(error, GPLUGIN_DOMAIN, 0,
    + "register_loader method not implemented");
    +
    + return FALSE;
    }
    /**
    * gplugin_manager_unregister_loader:
    * @type: #GType of a #GPluginLoader.
    + * @error: (out) (nullable): The return address for a #GError.
    *
    * Unregisters @type as an available loader.
    + *
    + * Returns: %TRUE if the loader was successfully unregistered, %FALSE
    + * otherwise with @error set.
    */
    -void
    -gplugin_manager_unregister_loader(GType type) {
    +gboolean
    +gplugin_manager_unregister_loader(GType type, GError **error) {
    GPluginManager *manager = GPLUGIN_MANAGER_INSTANCE;
    GPluginManagerClass *klass = NULL;
    - g_return_if_fail(GPLUGIN_IS_MANAGER(manager));
    + g_return_val_if_fail(GPLUGIN_IS_MANAGER(manager), FALSE);
    klass = GPLUGIN_MANAGER_GET_CLASS(manager);
    if(klass && klass->unregister_loader)
    - klass->unregister_loader(manager, type);
    + return klass->unregister_loader(manager, type, error);
    +
    + g_set_error(error, GPLUGIN_DOMAIN, 0,
    + "unregister_loader method not implemented");
    +
    + return FALSE;
    }
    /**
    --- a/gplugin/gplugin-manager.h Tue Feb 25 04:25:47 2020 +0000
    +++ b/gplugin/gplugin-manager.h Tue Feb 25 04:37:20 2020 +0000
    @@ -39,8 +39,8 @@
    GList *gplugin_manager_get_paths(void);
    -void gplugin_manager_register_loader(GType type);
    -void gplugin_manager_unregister_loader(GType type);
    +gboolean gplugin_manager_register_loader(GType type, GError **error);
    +gboolean gplugin_manager_unregister_loader(GType type, GError **error);
    void gplugin_manager_refresh(void);
    --- a/gplugin/gplugin-native-loader.c Tue Feb 25 04:25:47 2020 +0000
    +++ b/gplugin/gplugin-native-loader.c Tue Feb 25 04:37:20 2020 +0000
    @@ -101,12 +101,12 @@
    * GPluginLoaderInterface API
    *****************************************************************************/
    static GSList *
    -gplugin_native_loader_class_supported_extensions(G_GNUC_UNUSED GPluginLoaderClass *klass) {
    +gplugin_native_loader_supported_extensions(G_GNUC_UNUSED GPluginLoader *l) {
    GSList *exts = g_slist_append(NULL, G_MODULE_SUFFIX);
    #if defined(__APPLE__) || defined(__MACH__)
    - /* G_MODULE_SUFFIX only requests so on not windows, and both .so and
    - * .dylib are use on macos, so add dylib if we're on macos.
    + /* G_MODULE_SUFFIX only requests `.so` on not windows, and both .so and
    + * .dylib are used on macos, so add dylib if we're on macos.
    * See: https://gitlab.gnome.org/GNOME/glib/issues/1413
    */
    exts = g_slist_append(exts, "dylib");
    @@ -304,7 +304,7 @@
    GPLUGIN_LOADER_CLASS(klass);
    loader_class->supported_extensions =
    - gplugin_native_loader_class_supported_extensions;
    + gplugin_native_loader_supported_extensions;
    loader_class->query = gplugin_native_loader_query;
    loader_class->load = gplugin_native_loader_load;
    loader_class->unload = gplugin_native_loader_unload;
    --- a/gplugin/tests/meson.build Tue Feb 25 04:25:47 2020 +0000
    +++ b/gplugin/tests/meson.build Tue Feb 25 04:37:20 2020 +0000
    @@ -28,6 +28,10 @@
    dependencies : [gplugin_dep, GLIB, GOBJECT])
    test('Core', e)
    +e = executable('test-loader-registration', 'test-loader-registration.c',
    + dependencies : [gplugin_dep, GLIB, GOBJECT])
    +test('Loader Registration', e)
    +
    e = executable('test-option-group', 'test-option-group.c',
    dependencies : [gplugin_dep, GLIB, GOBJECT])
    test('Option Group', e)
    --- /dev/null Thu Jan 01 00:00:00 1970 +0000
    +++ b/gplugin/tests/test-loader-registration.c Tue Feb 25 04:37:20 2020 +0000
    @@ -0,0 +1,179 @@
    +/*
    + * Copyright (C) 2011-2020 Gary Kramlich <grim@reaperworld.com>
    + *
    + * This library is free software; you can redistribute it and/or
    + * modify it under the terms of the GNU Lesser General Public
    + * License as published by the Free Software Foundation; either
    + * version 2 of the License, or (at your option) any later version.
    + *
    + * This library 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
    + * Lesser General Public License for more details.
    + *
    + * You should have received a copy of the GNU Lesser General Public
    + * License along with this library; if not, see <http://www.gnu.org/licenses/>.
    + */
    +
    +#include <gplugin.h>
    +
    +/* it's getting dirty in here... */
    +#define GPLUGIN_COMPILATION
    +#include "../gplugin-private.h"
    +#undef GPLUGIN_COMPILATION
    +
    +#include <glib.h>
    +
    +/******************************************************************************
    + * GObject Implementation
    + *****************************************************************************/
    +#define TEST_GPLUGIN_TYPE_LOADER (test_gplugin_loader_get_type())
    +G_DECLARE_FINAL_TYPE(TestGPluginLoader, test_gplugin_loader, TEST_GPLUGIN, LOADER, GPluginLoader)
    +
    +struct _TestGPluginLoader {
    + GPluginLoader parent;
    +};
    +
    +static GSList *
    +test_gplugin_loader_supported_extensions(G_GNUC_UNUSED GPluginLoader *loader) {
    + return NULL;
    +}
    +
    +static GPluginPlugin *
    +test_gplugin_loader_query(G_GNUC_UNUSED GPluginLoader *loader,
    + G_GNUC_UNUSED const gchar *filename,
    + G_GNUC_UNUSED GError **error)
    +{
    + return NULL;
    +}
    +
    +static gboolean
    +test_gplugin_loader_load(G_GNUC_UNUSED GPluginLoader *loader,
    + G_GNUC_UNUSED GPluginPlugin *plugin,
    + G_GNUC_UNUSED GError **error)
    +{
    + return FALSE;
    +}
    +
    +static gboolean
    +test_gplugin_loader_unload(G_GNUC_UNUSED GPluginLoader *loader,
    + G_GNUC_UNUSED GPluginPlugin *plugin,
    + G_GNUC_UNUSED GError **error)
    +{
    + return FALSE;
    +}
    +
    +G_DEFINE_TYPE(TestGPluginLoader, test_gplugin_loader, GPLUGIN_TYPE_LOADER)
    +
    +static void
    +test_gplugin_loader_init(TestGPluginLoader *loader) {
    +}
    +
    +static void
    +test_gplugin_loader_class_init(TestGPluginLoaderClass *klass) {
    + GPluginLoaderClass *loader_class = GPLUGIN_LOADER_CLASS(klass);
    +
    + loader_class->supported_extensions =
    + test_gplugin_loader_supported_extensions;
    + loader_class->query = test_gplugin_loader_query;
    + loader_class->load = test_gplugin_loader_load;
    + loader_class->unload = test_gplugin_loader_unload;
    +}
    +
    +/******************************************************************************
    + * Tests
    + *****************************************************************************/
    +static void
    +test_gplugin_manager_loader_register(void) {
    + GError *error = NULL;
    + gboolean ret;
    +
    + gplugin_manager_private_uninit();
    + gplugin_manager_private_init();
    +
    + ret = gplugin_manager_register_loader(TEST_GPLUGIN_TYPE_LOADER, &error);
    +
    + g_assert_true(ret);
    + g_assert_no_error(error);
    +}
    +
    +static void
    +test_gplugin_manager_loader_register_twice(void) {
    + GError *error = NULL;
    + gboolean ret;
    +
    + gplugin_manager_private_uninit();
    + gplugin_manager_private_init();
    +
    + ret = gplugin_manager_register_loader(TEST_GPLUGIN_TYPE_LOADER, &error);
    + g_assert_true(ret);
    + g_assert_no_error(error);
    +
    + ret = gplugin_manager_register_loader(TEST_GPLUGIN_TYPE_LOADER, &error);
    + g_assert_false(ret);
    + g_assert_error(error, GPLUGIN_DOMAIN, 0);
    +}
    +
    +static void
    +test_gplugin_manager_loader_unregister(void) {
    + GError *error = NULL;
    + gboolean ret;
    +
    + gplugin_manager_private_uninit();
    + gplugin_manager_private_init();
    +
    + ret = gplugin_manager_register_loader(TEST_GPLUGIN_TYPE_LOADER, &error);
    +
    + g_assert_true(ret);
    + g_assert_no_error(error);
    +
    + ret = gplugin_manager_unregister_loader(TEST_GPLUGIN_TYPE_LOADER, &error);
    +
    + g_assert_true(ret);
    + g_assert_no_error(error);
    +}
    +
    +static void
    +test_gplugin_manager_loader_unregister_twice(void) {
    + GError *error = NULL;
    + gboolean ret;
    +
    + gplugin_manager_private_uninit();
    + gplugin_manager_private_init();
    +
    + ret = gplugin_manager_register_loader(TEST_GPLUGIN_TYPE_LOADER, &error);
    + g_assert_true(ret);
    + g_assert_no_error(error);
    +
    + ret = gplugin_manager_unregister_loader(TEST_GPLUGIN_TYPE_LOADER, &error);
    + g_assert_true(ret);
    + g_assert_no_error(error);
    +
    + ret = gplugin_manager_unregister_loader(TEST_GPLUGIN_TYPE_LOADER, &error);
    + g_assert_false(ret);
    + g_assert_error(error, GPLUGIN_DOMAIN, 0);
    +}
    +
    +/******************************************************************************
    + * Main
    + *****************************************************************************/
    +gint
    +main(gint argc, gchar **argv) {
    +
    + g_test_init(&argc, &argv, NULL);
    +
    + gplugin_init();
    +
    + g_test_add_func("/manager/loader/register",
    + test_gplugin_manager_loader_register);
    + g_test_add_func("/manager/loader/register-twice",
    + test_gplugin_manager_loader_register_twice);
    +
    + g_test_add_func("/manager/loader/unregister",
    + test_gplugin_manager_loader_unregister);
    + g_test_add_func("/manager/loader/unregister-twice",
    + test_gplugin_manager_loader_unregister_twice);
    +
    + return g_test_run();
    +}
    +
    --- a/lua/gplugin-lua-core.c Tue Feb 25 04:25:47 2020 +0000
    +++ b/lua/gplugin-lua-core.c Tue Feb 25 04:37:20 2020 +0000
    @@ -50,15 +50,11 @@
    }
    G_MODULE_EXPORT gboolean
    -gplugin_load(GPluginNativePlugin *plugin,
    - G_GNUC_UNUSED GError **error)
    -{
    +gplugin_load(GPluginNativePlugin *plugin, GError **error) {
    gplugin_lua_loader_register(plugin);
    gplugin_lua_plugin_register(plugin);
    - gplugin_manager_register_loader(GPLUGIN_LUA_TYPE_LOADER);
    -
    - return TRUE;
    + return gplugin_manager_register_loader(GPLUGIN_LUA_TYPE_LOADER, error);
    }
    G_MODULE_EXPORT gboolean
    --- a/lua/gplugin-lua-loader.c Tue Feb 25 04:25:47 2020 +0000
    +++ b/lua/gplugin-lua-loader.c Tue Feb 25 04:37:20 2020 +0000
    @@ -81,7 +81,7 @@
    * GPluginLoaderInterface API
    *****************************************************************************/
    static GSList *
    -gplugin_lua_loader_class_supported_extensions(G_GNUC_UNUSED GPluginLoaderClass *klass) {
    +gplugin_lua_loader_supported_extensions(G_GNUC_UNUSED GPluginLoader *l) {
    return g_slist_append(NULL, "lua");
    }
    @@ -174,7 +174,7 @@
    GPluginLoaderClass *loader_class = GPLUGIN_LOADER_CLASS(klass);
    loader_class->supported_extensions =
    - gplugin_lua_loader_class_supported_extensions;
    + gplugin_lua_loader_supported_extensions;
    loader_class->query = gplugin_lua_loader_query;
    loader_class->load = gplugin_lua_loader_load;
    loader_class->unload = gplugin_lua_loader_unload;
    --- a/perl/gplugin-perl-core.c Tue Feb 25 04:25:47 2020 +0000
    +++ b/perl/gplugin-perl-core.c Tue Feb 25 04:37:20 2020 +0000
    @@ -54,9 +54,7 @@
    gplugin_perl_plugin_register(plugin);
    gplugin_perl_loader_register(plugin);
    - gplugin_manager_register_loader(GPLUGIN_PERL_TYPE_LOADER);
    -
    - return TRUE;
    + return gplugin_manager_register_loader(GPLUGIN_PERL_TYPE_LOADER, error);
    }
    G_MODULE_EXPORT gboolean
    --- a/perl/gplugin-perl-loader.c Tue Feb 25 04:25:47 2020 +0000
    +++ b/perl/gplugin-perl-loader.c Tue Feb 25 04:37:20 2020 +0000
    @@ -167,7 +167,7 @@
    * GPluginLoaderInterface API
    *****************************************************************************/
    static GSList *
    -gplugin_perl_loader_class_supported_extensions(G_GNUC_UNUSED GPluginLoaderClass *klass) {
    +gplugin_perl_loader_supported_extensions(G_GNUC_UNUSED GPluginLoader *l) {
    return g_slist_append(NULL, "pl");
    }
    @@ -279,7 +279,7 @@
    GPluginLoaderClass *loader_class = GPLUGIN_LOADER_CLASS(klass);
    loader_class->supported_extensions =
    - gplugin_perl_loader_class_supported_extensions;
    + gplugin_perl_loader_supported_extensions;
    loader_class->query = gplugin_perl_loader_query;
    loader_class->load = gplugin_perl_loader_load;
    loader_class->unload = gplugin_perl_loader_unload;
    --- a/python/gplugin-python3-core.c Tue Feb 25 04:25:47 2020 +0000
    +++ b/python/gplugin-python3-core.c Tue Feb 25 04:37:20 2020 +0000
    @@ -55,9 +55,7 @@
    gplugin_python3_plugin_register(plugin);
    gplugin_python3_loader_register(plugin);
    - gplugin_manager_register_loader(GPLUGIN_PYTHON3_TYPE_LOADER);
    -
    - return TRUE;
    + return gplugin_manager_register_loader(GPLUGIN_PYTHON3_TYPE_LOADER, error);
    }
    G_MODULE_EXPORT gboolean
    --- a/python/gplugin-python3-loader.c Tue Feb 25 04:25:47 2020 +0000
    +++ b/python/gplugin-python3-loader.c Tue Feb 25 04:37:20 2020 +0000
    @@ -41,7 +41,7 @@
    * GPluginLoader Implementation
    *****************************************************************************/
    static GSList *
    -gplugin_python3_loader_class_supported_extensions(G_GNUC_UNUSED GPluginLoaderClass *klass) {
    +gplugin_python3_loader_supported_extensions(G_GNUC_UNUSED GPluginLoader *l) {
    return g_slist_append(NULL, "py");
    }
    @@ -356,7 +356,7 @@
    GPluginLoaderClass *loader_class = GPLUGIN_LOADER_CLASS(klass);
    loader_class->supported_extensions =
    - gplugin_python3_loader_class_supported_extensions;
    + gplugin_python3_loader_supported_extensions;
    loader_class->query = gplugin_python3_loader_query;
    loader_class->load = gplugin_python3_loader_load;
    loader_class->unload = gplugin_python3_loader_unload;
    --- a/tcc/gplugin-tcc-core.c Tue Feb 25 04:25:47 2020 +0000
    +++ b/tcc/gplugin-tcc-core.c Tue Feb 25 04:37:20 2020 +0000
    @@ -49,15 +49,11 @@
    }
    G_MODULE_EXPORT gboolean
    -gplugin_load(GPluginNativePlugin *plugin,
    - G_GNUC_UNUSED GError **error)
    -{
    +gplugin_load(GPluginNativePlugin *plugin, GError **error) {
    gplugin_tcc_loader_register(plugin);
    gplugin_tcc_plugin_register(plugin);
    - gplugin_manager_register_loader(GPLUGIN_TCC_TYPE_LOADER);
    -
    - return TRUE;
    + return gplugin_manager_register_loader(GPLUGIN_TCC_TYPE_LOADER, error);
    }
    G_MODULE_EXPORT gboolean
    --- a/tcc/gplugin-tcc-loader.c Tue Feb 25 04:25:47 2020 +0000
    +++ b/tcc/gplugin-tcc-loader.c Tue Feb 25 04:37:20 2020 +0000
    @@ -33,12 +33,8 @@
    * GPluginLoaderInterface API
    *****************************************************************************/
    static GSList *
    -gplugin_tcc_loader_class_supported_extensions(G_GNUC_UNUSED const GPluginLoaderClass *klass) {
    - GSList *exts = NULL;
    -
    - exts = g_slist_append(exts, "c");
    -
    - return exts;
    +gplugin_tcc_loader_supported_extensions(G_GNUC_UNUSED GPluginLoader *l) {
    + return g_list_append(NULL, "c");
    }
    static GPluginPlugin *
    @@ -161,7 +157,7 @@
    GPluginLoaderClass *loader_class = GPLUGIN_LOADER_CLASS(klass);
    loader_class->supported_extensions =
    - gplugin_tcc_loader_class_supported_extensions;
    + gplugin_tcc_loader_supported_extensions;
    loader_class->query = gplugin_tcc_loader_query;
    loader_class->load = gplugin_tcc_loader_load;
    loader_class->unload = gplugin_tcc_loader_unload;