[libgda] DataModelErrors: modernized

[Daniel Espinosa Ortiz <despinosa src gnome org>]

commit afa637531517d1db40430197aac0fa37505260a7
Author: Daniel Espinosa <esodan gmail com>
Date:   Wed Apr 3 11:44:54 2019 -0600

    DataModelErrors: modernized
    
    Included in GDA namespace and using G_DEFINE/G_DECLARE

 testing/gdaui-test-errors.c            |   2 +-
 tests/data-model-errors.c              | 264 +++++++++++++--------------------
 tests/data-model-errors.h              |  21 +--
 tests/data-models/check_model_errors.c |   4 +-
 4 files changed, 110 insertions(+), 181 deletions(-)
---
diff --git a/testing/gdaui-test-errors.c b/testing/gdaui-test-errors.c
index 0f561e882..9a1eb8c8c 100644
--- a/testing/gdaui-test-errors.c
+++ b/testing/gdaui-test-errors.c
@@ -54,7 +54,7 @@ main (int argc, char *argv[])
 
        /* create data model */
        GdaDataModel *model; 
-        model = data_model_errors_new ();
+        model = gda_data_model_errors_new ();
        gda_data_model_dump (model, NULL);
        
        /* create UI */
diff --git a/tests/data-model-errors.c b/tests/data-model-errors.c
index ea3e319ff..89bcff1c7 100644
--- a/tests/data-model-errors.c
+++ b/tests/data-model-errors.c
@@ -43,52 +43,54 @@ ARow data[] = {
        {"Cell 3,0", "Cell 3,1", "-",        NULL      },
 };
 
-struct _DataModelErrorsPrivate {
-       GSList    *columns; /* list of GdaColumn objects */
-       GPtrArray *rows; /* array of GdaRow pointers */
-};
 
-static void data_model_errors_class_init (DataModelErrorsClass *klass);
-static void data_model_errors_init       (DataModelErrors *model,
-                                         DataModelErrorsClass *klass);
-static void data_model_errors_dispose    (GObject *object);
+static void gda_data_model_errors_class_init (GdaDataModelErrorsClass *klass);
+static void gda_data_model_errors_init       (GdaDataModelErrors *model);
+static void gda_data_model_errors_dispose    (GObject *object);
 
 /* GdaDataModel interface */
-static void                 data_model_errors_data_model_init (GdaDataModelInterface *iface);
-static gint                 data_model_errors_get_n_rows      (GdaDataModel *model);
-static gint                 data_model_errors_get_n_columns   (GdaDataModel *model);
-static GdaColumn           *data_model_errors_describe_column (GdaDataModel *model, gint col);
-static GdaDataModelAccessFlags data_model_errors_get_access_flags(GdaDataModel *model);
-static const GValue        *data_model_errors_get_value_at    (GdaDataModel *model, gint col, gint row, 
GError **error);
-static GdaValueAttribute    data_model_errors_get_attributes_at (GdaDataModel *model, gint col, gint row);
+static void                 gda_data_model_errors_data_model_init (GdaDataModelInterface *iface);
+static gint                 gda_data_model_errors_get_n_rows      (GdaDataModel *model);
+static gint                 gda_data_model_errors_get_n_columns   (GdaDataModel *model);
+static GdaColumn           *gda_data_model_errors_describe_column (GdaDataModel *model, gint col);
+static GdaDataModelAccessFlags gda_data_model_errors_get_access_flags(GdaDataModel *model);
+static const GValue        *gda_data_model_errors_get_value_at    (GdaDataModel *model, gint col, gint row, 
GError **error);
+static GdaValueAttribute    gda_data_model_errors_get_attributes_at (GdaDataModel *model, gint col, gint 
row);
 
-static gboolean             data_model_errors_set_value_at (GdaDataModel *model, gint col, gint row, const 
GValue *value, GError **error);
-static gint                 data_model_errors_append_values (GdaDataModel *model, const GList *values, 
GError **error);
-static gboolean             data_model_errors_remove_row (GdaDataModel *model, gint row, GError **error);
+static gboolean             gda_data_model_errors_set_value_at (GdaDataModel *model, gint col, gint row, 
const GValue *value, GError **error);
+static gint                 gda_data_model_errors_append_values (GdaDataModel *model, const GList *values, 
GError **error);
+static gboolean             gda_data_model_errors_remove_row (GdaDataModel *model, gint row, GError **error);
 
-static GObjectClass *parent_class = NULL;
-#define CLASS(model) (DATA_MODEL_ERRORS_CLASS (G_OBJECT_GET_CLASS (model)))
+
+typedef struct {
+       GSList    *columns; /* list of GdaColumn objects */
+       GPtrArray *rows; /* array of GdaRow pointers */
+} GdaDataModelErrorsPrivate;
+
+G_DEFINE_TYPE_WITH_CODE (GdaDataModelErrors, gda_data_model_errors, G_TYPE_OBJECT,
+                         G_ADD_PRIVATE (GdaDataModelErrors)
+                         G_IMPLEMENT_INTERFACE(GDA_TYPE_DATA_MODEL,gda_data_model_errors_data_model_init))
 
 /*
  * Object init and dispose
  */
 static void
-data_model_errors_data_model_init (GdaDataModelInterface *iface)
+gda_data_model_errors_data_model_init (GdaDataModelInterface *iface)
 {
-        iface->get_n_rows = data_model_errors_get_n_rows;
-        iface->get_n_columns = data_model_errors_get_n_columns;
-        iface->describe_column = data_model_errors_describe_column;
-        iface->get_access_flags = data_model_errors_get_access_flags;
-        iface->get_value_at = data_model_errors_get_value_at;
-        iface->get_attributes_at = data_model_errors_get_attributes_at;
+        iface->get_n_rows = gda_data_model_errors_get_n_rows;
+        iface->get_n_columns = gda_data_model_errors_get_n_columns;
+        iface->describe_column = gda_data_model_errors_describe_column;
+        iface->get_access_flags = gda_data_model_errors_get_access_flags;
+        iface->get_value_at = gda_data_model_errors_get_value_at;
+        iface->get_attributes_at = gda_data_model_errors_get_attributes_at;
 
         iface->create_iter = NULL;
 
-        iface->set_value_at = data_model_errors_set_value_at;
+        iface->set_value_at = gda_data_model_errors_set_value_at;
         iface->set_values = NULL;
-        iface->append_values = data_model_errors_append_values;
+        iface->append_values = gda_data_model_errors_append_values;
         iface->append_row = NULL;
-        iface->remove_row = data_model_errors_remove_row;
+        iface->remove_row = gda_data_model_errors_remove_row;
         iface->find_row = NULL;
 
         iface->freeze = NULL;
@@ -98,16 +100,15 @@ data_model_errors_data_model_init (GdaDataModelInterface *iface)
 }
 
 static void
-data_model_errors_init (DataModelErrors *model,
-                       G_GNUC_UNUSED DataModelErrorsClass *klass)
+gda_data_model_errors_init (GdaDataModelErrors *model)
 {
        gsize i;
-       g_return_if_fail (IS_DATA_MODEL_ERRORS (model));
+       g_return_if_fail (GDA_IS_DATA_MODEL_ERRORS (model));
 
-       model->priv = g_new0 (DataModelErrorsPrivate, 1);
+       GdaDataModelErrorsPrivate *priv = gda_data_model_errors_get_instance_private (model);
        
        /* columns */
-       model->priv->columns = NULL;
+       priv->columns = NULL;
        for (i = 0; i < NCOLS; i++) {
                GdaColumn *col;
                gchar *str;
@@ -119,11 +120,11 @@ data_model_errors_init (DataModelErrors *model,
                g_object_set (G_OBJECT (col), "id", str, NULL);
                g_free (str);
 
-               model->priv->columns = g_slist_append (model->priv->columns, col);
+               priv->columns = g_slist_append (priv->columns, col);
        }
 
        /* rows */
-       model->priv->rows = g_ptr_array_new (); /* array of GdaRow pointers */
+       priv->rows = g_ptr_array_new (); /* array of GdaRow pointers */
        for (i = 0; i < (sizeof (data) / sizeof (ARow)); i++) {
                ARow *arow = &(data[i]);
                GdaRow *row = gda_row_new (NCOLS);
@@ -168,139 +169,89 @@ data_model_errors_init (DataModelErrors *model,
                        }
                }
 
-               g_ptr_array_add (model->priv->rows, row);
+               g_ptr_array_add (priv->rows, row);
        }
 }
 
 static void
-data_model_errors_class_init (DataModelErrorsClass *klass)
+gda_data_model_errors_class_init (GdaDataModelErrorsClass *klass)
 {
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-       parent_class = g_type_class_peek_parent (klass);
-
        /* virtual functions */
-       object_class->dispose = data_model_errors_dispose;
+       object_class->dispose = gda_data_model_errors_dispose;
 }
 
 static void
-data_model_errors_dispose (GObject * object)
-{
-       DataModelErrors *model = (DataModelErrors *) object;
-
-       g_return_if_fail (IS_DATA_MODEL_ERRORS (model));
-
-       if (model->priv) {
-               if (model->priv->columns) {
-                        g_slist_foreach (model->priv->columns, (GFunc) g_object_unref, NULL);
-                        g_slist_free (model->priv->columns);
-                        model->priv->columns = NULL;
-                }
-
-               /* DONT: g_ptr_array_foreach (model->priv->rows, (GFunc) g_object_unref, NULL);
-                * because we use the convention that G_VALUE_TYPE() == G_TYPE_INVALID for errors */
-               g_ptr_array_free (model->priv->rows, TRUE);
-               g_free (model->priv);
-               model->priv = NULL;
-       }
-
-       parent_class->dispose (object);
-}
-
-GType
-data_model_errors_get_type (void)
+gda_data_model_errors_dispose (GObject * object)
 {
-       static GType type = 0;
-
-       if (G_UNLIKELY (type == 0)) {
-               static GMutex registering;
-               static const GTypeInfo info = {
-                       sizeof (DataModelErrorsClass),
-                       (GBaseInitFunc) NULL,
-                       (GBaseFinalizeFunc) NULL,
-                       (GClassInitFunc) data_model_errors_class_init,
-                       NULL,
-                       NULL,
-                       sizeof (DataModelErrors),
-                       0,
-                       (GInstanceInitFunc) data_model_errors_init,
-                       0
-               };
-               static const GInterfaceInfo data_model_info = {
-                        (GInterfaceInitFunc) data_model_errors_data_model_init,
-                        NULL,
-                        NULL
-                };
-
-               g_mutex_lock (&registering);
-               if (type == 0) {
-                       type = g_type_register_static (G_TYPE_OBJECT, "DataModelErrors", &info, 0);
-                       g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
-               }
-               g_mutex_unlock (&registering);
-       }
-       return type;
+       GdaDataModelErrors *model = (GdaDataModelErrors *) object;
+
+       g_return_if_fail (GDA_IS_DATA_MODEL_ERRORS (model));
+       GdaDataModelErrorsPrivate *priv = gda_data_model_errors_get_instance_private (model);
+
+  if (priv->columns) {
+    g_slist_free_full (priv->columns, (GDestroyNotify) g_object_unref);
+    priv->columns = NULL;
+  }
+       /* DONT: g_ptr_array_foreach (priv->rows, (GFunc) g_object_unref, NULL);
+        * because we use the convention that G_VALUE_TYPE() == G_TYPE_INVALID for errors */
+  if (priv->rows != NULL) {
+         g_ptr_array_free (priv->rows, TRUE);
+    priv->rows = NULL;
+  }
+
+       G_OBJECT_CLASS (gda_data_model_errors_parent_class)->dispose (object);
 }
 
 /*
- * data_model_errors_new
+ * gda_data_model_errors_new
  *
  * Creates a new #GdaDataModel object
  *
  * Returns: a new #GdaDataModel
  */
 GdaDataModel *
-data_model_errors_new (void)
+gda_data_model_errors_new (void)
 {
        GdaDataModel *model;
-       model = (GdaDataModel *) g_object_new (TYPE_DATA_MODEL_ERRORS, NULL); 
+       model = (GdaDataModel *) g_object_new (GDA_TYPE_DATA_MODEL_ERRORS, NULL);
 
        return model;
 }
 
 static gint
-data_model_errors_get_n_rows (GdaDataModel *model)
+gda_data_model_errors_get_n_rows (GdaDataModel *model)
 {
-       DataModelErrors *imodel = (DataModelErrors *) model;
+       GdaDataModelErrors *imodel = (GdaDataModelErrors *) model;
 
-       g_return_val_if_fail (IS_DATA_MODEL_ERRORS (imodel), 0);
-       g_return_val_if_fail (imodel->priv != NULL, 0);
+       g_return_val_if_fail (GDA_IS_DATA_MODEL_ERRORS (imodel), 0);
+       GdaDataModelErrorsPrivate *priv = gda_data_model_errors_get_instance_private (imodel);
 
-       return imodel->priv->rows->len;
+       return priv->rows->len;
 }
 
 static gint
-data_model_errors_get_n_columns (GdaDataModel *model)
+gda_data_model_errors_get_n_columns (GdaDataModel *model)
 {
-       DataModelErrors *imodel;
-       g_return_val_if_fail (IS_DATA_MODEL_ERRORS (model), 0);
-       imodel = DATA_MODEL_ERRORS (model);
-       g_return_val_if_fail (imodel->priv, 0);
-
        return NCOLS;
 }
 
 static GdaColumn *
-data_model_errors_describe_column (GdaDataModel *model, gint col)
+gda_data_model_errors_describe_column (GdaDataModel *model, gint col)
 {
-       DataModelErrors *imodel;
-       g_return_val_if_fail (IS_DATA_MODEL_ERRORS (model), NULL);
-       imodel = DATA_MODEL_ERRORS (model);
-       g_return_val_if_fail (imodel->priv, NULL);
+       GdaDataModelErrors *imodel;
+       g_return_val_if_fail (GDA_IS_DATA_MODEL_ERRORS (model), NULL);
+       imodel = GDA_DATA_MODEL_ERRORS (model);
+       GdaDataModelErrorsPrivate *priv = gda_data_model_errors_get_instance_private (imodel);
 
-       return g_slist_nth_data (imodel->priv->columns, col);
+       return g_slist_nth_data (priv->columns, col);
 }
 
 static GdaDataModelAccessFlags
-data_model_errors_get_access_flags (GdaDataModel *model)
+gda_data_model_errors_get_access_flags (GdaDataModel *model)
 {
-       DataModelErrors *imodel;
        GdaDataModelAccessFlags flags;
 
-       g_return_val_if_fail (IS_DATA_MODEL_ERRORS (model), 0);
-       imodel = DATA_MODEL_ERRORS (model);
-       g_return_val_if_fail (imodel->priv, 0);
-
        flags = GDA_DATA_MODEL_ACCESS_CURSOR_FORWARD | 
                GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD |
                GDA_DATA_MODEL_ACCESS_RANDOM |
@@ -310,15 +261,15 @@ data_model_errors_get_access_flags (GdaDataModel *model)
 }
 
 static const GValue *
-data_model_errors_get_value_at (GdaDataModel *model, gint col, gint row, GError **error)
+gda_data_model_errors_get_value_at (GdaDataModel *model, gint col, gint row, GError **error)
 {
-       DataModelErrors *imodel;
+       GdaDataModelErrors *imodel;
        GValue *value = NULL;
        GdaRow *drow;
 
-       g_return_val_if_fail (IS_DATA_MODEL_ERRORS (model), NULL);
-       imodel = DATA_MODEL_ERRORS (model);
-       g_return_val_if_fail (imodel->priv, NULL);
+       g_return_val_if_fail (GDA_IS_DATA_MODEL_ERRORS (model), NULL);
+       imodel = GDA_DATA_MODEL_ERRORS (model);
+       GdaDataModelErrorsPrivate *priv = gda_data_model_errors_get_instance_private (imodel);
 
        if ((col < 0) || (col > NCOLS)) {
                gchar *tmp;
@@ -329,11 +280,11 @@ data_model_errors_get_value_at (GdaDataModel *model, gint col, gint row, GError
                return NULL;
        }
 
-       if (row >= (gint)imodel->priv->rows->len) {
+       if (row >= (gint)priv->rows->len) {
                gchar *str;
-               if (imodel->priv->rows->len > 0)
+               if (priv->rows->len > 0)
                        str = g_strdup_printf ("Row %d out of range (0-%d)", row,
-                                              imodel->priv->rows->len - 1);
+                                              priv->rows->len - 1);
                else
                        str = g_strdup_printf ("Row %d not found (empty data model)", row);
                g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ROW_OUT_OF_RANGE_ERROR,
@@ -342,7 +293,7 @@ data_model_errors_get_value_at (GdaDataModel *model, gint col, gint row, GError
                 return NULL;
         }
 
-       drow =  g_ptr_array_index (imodel->priv->rows, row);
+       drow =  g_ptr_array_index (priv->rows, row);
        if (drow) {
                GValue *val = gda_row_get_value (drow, col);
                if (G_VALUE_TYPE (val) == G_TYPE_INVALID) {
@@ -361,14 +312,9 @@ data_model_errors_get_value_at (GdaDataModel *model, gint col, gint row, GError
 }
 
 static GdaValueAttribute
-data_model_errors_get_attributes_at (GdaDataModel *model, gint col, G_GNUC_UNUSED gint row)
+gda_data_model_errors_get_attributes_at (GdaDataModel *model, gint col, G_GNUC_UNUSED gint row)
 {
-       DataModelErrors *imodel;
        GdaValueAttribute flags = 0;
-       g_return_val_if_fail (IS_DATA_MODEL_ERRORS (model), 0);
-       imodel = DATA_MODEL_ERRORS (model);
-       g_return_val_if_fail (imodel->priv, 0);
-
        if ((col < 0) || (col > NCOLS)) {
                gchar *tmp;
                tmp = g_strdup_printf ("Column %d out of range (0-%d)", col, NCOLS-1);
@@ -381,14 +327,14 @@ data_model_errors_get_attributes_at (GdaDataModel *model, gint col, G_GNUC_UNUSE
 }
 
 static gboolean
-data_model_errors_set_value_at (GdaDataModel *model, gint col, gint row, const GValue *value, GError **error)
+gda_data_model_errors_set_value_at (GdaDataModel *model, gint col, gint row, const GValue *value, GError 
**error)
 {
        gboolean retval = TRUE;
-       DataModelErrors *imodel;
+       GdaDataModelErrors *imodel;
 
-       g_return_val_if_fail (IS_DATA_MODEL_ERRORS (model), FALSE);
-       imodel = DATA_MODEL_ERRORS (model);
-       g_return_val_if_fail (imodel->priv, FALSE);
+       g_return_val_if_fail (GDA_IS_DATA_MODEL_ERRORS (model), FALSE);
+       imodel = GDA_DATA_MODEL_ERRORS (model);
+       GdaDataModelErrorsPrivate *priv = gda_data_model_errors_get_instance_private (imodel);
 
        if ((col < 0) || (col > NCOLS)) {
                gchar *tmp;
@@ -399,7 +345,7 @@ data_model_errors_set_value_at (GdaDataModel *model, gint col, gint row, const G
        }
 
        GdaRow *drow;
-       drow =  g_ptr_array_index (imodel->priv->rows, row);
+       drow =  g_ptr_array_index (priv->rows, row);
        if (drow) {
                GValue *dvalue;
                dvalue = gda_row_get_value (drow, col);
@@ -419,14 +365,8 @@ data_model_errors_set_value_at (GdaDataModel *model, gint col, gint row, const G
 
 
 static gint
-data_model_errors_append_values (GdaDataModel *model, G_GNUC_UNUSED const GList *values, GError **error)
+gda_data_model_errors_append_values (GdaDataModel *model, G_GNUC_UNUSED const GList *values, GError **error)
 {
-       DataModelErrors *imodel;
-       
-       g_return_val_if_fail (IS_DATA_MODEL_ERRORS (model), -1);
-       imodel = (DataModelErrors *) model;
-       g_return_val_if_fail (imodel->priv, -1);
-
        TO_IMPLEMENT;
        g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_FEATURE_NON_SUPPORTED_ERROR,
                              "%s", "Not implemented");
@@ -434,19 +374,19 @@ data_model_errors_append_values (GdaDataModel *model, G_GNUC_UNUSED const GList
 }
 
 static gboolean
-data_model_errors_remove_row (GdaDataModel *model, gint row, GError **error)
+gda_data_model_errors_remove_row (GdaDataModel *model, gint row, GError **error)
 {
-       DataModelErrors *imodel;
+       GdaDataModelErrors *imodel;
 
-       g_return_val_if_fail (IS_DATA_MODEL_ERRORS (model), FALSE);
-       imodel = (DataModelErrors *) model;
-       g_return_val_if_fail (imodel->priv, FALSE);
+       g_return_val_if_fail (GDA_IS_DATA_MODEL_ERRORS (model), FALSE);
+       imodel = (GdaDataModelErrors *) model;
+       GdaDataModelErrorsPrivate *priv = gda_data_model_errors_get_instance_private (imodel);
 
-       if (row >= (gint)imodel->priv->rows->len) {
+       if (row >= (gint)priv->rows->len) {
                gchar *str;
-               if (imodel->priv->rows->len > 0)
+               if (priv->rows->len > 0)
                        str = g_strdup_printf ("Row %d out of range (0-%d)", row,
-                                              imodel->priv->rows->len - 1);
+                                              priv->rows->len - 1);
                else
                        str = g_strdup_printf ("Row %d not found (empty data model)", row);
                g_set_error (error, TEST_ERROR, TEST_ERROR_GENERIC, "%s", str);
@@ -455,10 +395,10 @@ data_model_errors_remove_row (GdaDataModel *model, gint row, GError **error)
         }
 
        GdaRow *drow;
-       drow =  g_ptr_array_index (imodel->priv->rows, row);
+       drow =  g_ptr_array_index (priv->rows, row);
        /* remove row from data model */
        g_object_unref (drow);
-       g_ptr_array_remove_index (imodel->priv->rows, row);
+       g_ptr_array_remove_index (priv->rows, row);
        gda_data_model_row_removed (model, row);
        
        return TRUE;
diff --git a/tests/data-model-errors.h b/tests/data-model-errors.h
index f697675fa..b09cc5d49 100644
--- a/tests/data-model-errors.h
+++ b/tests/data-model-errors.h
@@ -1,5 +1,6 @@
 /*
  * Copyright (C) 2010 - 2012 Vivien Malerba <malerba gnome-db org>
+ * Copyright (C) 2019 Daniel Espinosa <esodan gmail com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -23,27 +24,15 @@
 
 G_BEGIN_DECLS
 
-#define TYPE_DATA_MODEL_ERRORS            (data_model_errors_get_type())
-#define DATA_MODEL_ERRORS(obj)            (G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_DATA_MODEL_ERRORS, 
DataModelErrors))
-#define DATA_MODEL_ERRORS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST (klass, TYPE_DATA_MODEL_ERRORS, 
DataModelErrorsClass))
-#define IS_DATA_MODEL_ERRORS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE(obj, TYPE_DATA_MODEL_ERRORS))
-#define IS_DATA_MODEL_ERRORS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TYPE_DATA_MODEL_ERRORS))
+#define GDA_TYPE_DATA_MODEL_ERRORS            (gda_data_model_errors_get_type())
 
-typedef struct _DataModelErrors        DataModelErrors;
-typedef struct _DataModelErrorsClass   DataModelErrorsClass;
-typedef struct _DataModelErrorsPrivate DataModelErrorsPrivate;
+G_DECLARE_DERIVABLE_TYPE(GdaDataModelErrors, gda_data_model_errors, GDA, DATA_MODEL_ERRORS, GObject)
 
-struct _DataModelErrors {
-       GObject                 object;
-       DataModelErrorsPrivate *priv;
-};
-
-struct _DataModelErrorsClass {
+struct _GdaDataModelErrorsClass {
        GObjectClass            parent_class;
 };
 
-GType         data_model_errors_get_type     (void) G_GNUC_CONST;
-GdaDataModel *data_model_errors_new          (void);
+GdaDataModel *gda_data_model_errors_new          (void);
 
 G_END_DECLS
 
diff --git a/tests/data-models/check_model_errors.c b/tests/data-models/check_model_errors.c
index 1fae2d9ad..e8cb0648c 100644
--- a/tests/data-models/check_model_errors.c
+++ b/tests/data-models/check_model_errors.c
@@ -173,7 +173,7 @@ test1 (GdaConnection *cnc)
        GdaDataModel *model;
        gint nfailed = 0;
 
-       model = data_model_errors_new ();
+       model = gda_data_model_errors_new ();
        if (!model) {
                nfailed++;
 #ifdef CHECK_EXTRA_INFO
@@ -327,7 +327,7 @@ test2 (GdaConnection *cnc)
 
 #define TABLE_NAME "data"
 
-       model = data_model_errors_new ();
+       model = gda_data_model_errors_new ();
        if (!model) {
                nfailed++;
 #ifdef CHECK_EXTRA_INFO