luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-08-02 07:23:41 +02:00
Code Issues Packages Projects Releases Wiki Activity

New directory, framework for automated GObject tests.

Browse Source 
Fri Sep 12 16:26:21 2003  Owen Taylor  <otaylor@redhat.com>

        * tests/gobject/ configure.in: New directory, framework
        for automated GObject tests.

        * tests/gobject/override.c: Move testoverride.c
        here, automate.

        * tests/gobject/ifaceinit.c: Move testifaceinit.c here.

        * tests/gobject/accumulator.c: Test signal accumulators,
        including g_signal_accumulator_true_handled.
This commit is contained in:
Owen Taylor
2003-09-12 20:37:09 +00:00
committed by Owen Taylor
parent 32bc3c4197
commit 4ec041d593
14 changed files with 676 additions and 299 deletions
Download Patch File Download Diff File Expand all files Collapse all files

421
tests/gobject/override.c
View File

@@ -1,379 +1,324 @@
/* -*- mode: C; c-basic-offset: 4 -*- */
/* GObject - GLib Type, Object, Parameter and Signal Library
* override.c: Closure override test program
* Copyright (C) 2001, James Henstridge
* Copyright (C) 2003, Red Hat, Inc.
*
* 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, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*/
#undef G_LOG_DOMAIN
#define G_LOG_DOMAIN "TestOverride"
#undef G_DISABLE_ASSERT
#undef G_DISABLE_CHECKS
#undef G_DISABLE_CAST_CHECKS
#undef VERBOSE
#include <string.h>
#include <glib.h>
#include <glib-object.h>
#include "testcommon.h"
static guint foo_signal_id = 0;
static guint bar_signal_id = 0;
static GType test_i_get_type (void);
static GType test_a_get_type (void);
static GType test_b_get_type (void);
static GType test_c_get_type (void);
static void record (const gchar *str);
#define TEST_TYPE_I (test_i_get_type ())
#define TEST_I(object) (G_TYPE_CHECK_INSTANCE_CAST((object), TEST_TYPE_I, TestI))
#define TEST_I_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST((vtable), TEST_TYPE_I, TestIClass))
#define TEST_IS_I(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), TEST_TYPE_I))
#define TEST_IS_I_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE((vtable), TEST_TYPE_I))
#define TEST_I_GET_CLASS(object) (G_TYPE_INSTANCE_GET_INTERFACE((object), TEST_TYPE_I, TestIClass))
typedef struct _TestI TestI;
typedef struct _TestIClass TestIClass;
struct _TestIClass {
GTypeInterface base_iface;
struct _TestIClass
{
GTypeInterface base_iface;
};
static void
test_i_foo (TestI *self)
{
g_print("TestI::foo called.\n");
record ("TestI::foo");
}
static void
test_i_base_init (gpointer g_class)
test_i_default_init (gpointer g_class)
{
static gboolean initialised = FALSE;
if (!initialised) {
foo_signal_id = g_signal_newv("foo",
TEST_TYPE_I,
G_SIGNAL_RUN_LAST,
g_cclosure_new(G_CALLBACK(test_i_foo),
NULL, NULL),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0, NULL);
}
initialised = TRUE;
foo_signal_id = g_signal_newv ("foo",
TEST_TYPE_I,
G_SIGNAL_RUN_LAST,
g_cclosure_new(G_CALLBACK(test_i_foo),
NULL, NULL),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0, NULL);
}
static GType
test_i_get_type (void)
{
static GType type = 0;
if (!type) {
static const GTypeInfo type_info = {
sizeof (TestIClass),
(GBaseInitFunc) test_i_base_init, /* base_init */
NULL, /* base_finalize */
};
type = g_type_register_static (G_TYPE_INTERFACE, "TestI",
&type_info, 0);
}
return type;
}
static DEFINE_IFACE (TestI, test_i, NULL, test_i_default_init)
#define TEST_TYPE_A (test_a_get_type())
#define TEST_A(object) (G_TYPE_CHECK_INSTANCE_CAST((object), TEST_TYPE_A, TestA))
#define TEST_A_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TEST_TYPE_A, TestAClass))
#define TEST_IS_A(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), TEST_TYPE_A))
#define TEST_IS_A_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TEST_TYPE_A))
#define TEST_A_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TEST_TYPE_A, TestAClass))
typedef struct _TestA TestA;
typedef struct _TestAClass TestAClass;
typedef struct _TestA TestA;
typedef struct _TestAClass TestAClass;
struct _TestA {
GObject parent;
GObject parent;
};
struct _TestAClass {
GObjectClass parent_class;
GObjectClass parent_class;
void (* bar) (TestA *self);
void (* bar) (TestA *self);
};
static void
test_a_foo (TestI *self)
{
GValue args[1] = { { 0, } };
GValue args[1] = { { 0, } };
g_print("TestA::foo called. Chaining up.\n");
record ("TestA::foo");
g_value_init (&args[0], TEST_TYPE_A);
g_value_set_object (&args[0], self);
g_value_init (&args[0], TEST_TYPE_A);
g_value_set_object (&args[0], self);
g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);
g_signal_chain_from_overridden (args, NULL);
g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);
g_signal_chain_from_overridden (args, NULL);
g_value_unset (&args[0]);
g_value_unset (&args[0]);
}
static void
test_a_bar (TestA *self)
{
g_print("TestA::bar called.\n");
record ("TestA::bar");
}
static void
test_a_class_init (TestAClass *class)
{
class->bar = test_a_bar;
class->bar = test_a_bar;
bar_signal_id = g_signal_new("bar",
TEST_TYPE_A,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (TestAClass, bar),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
bar_signal_id = g_signal_new ("bar",
TEST_TYPE_A,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (TestAClass, bar),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0, NULL);
}
static void
test_a_interface_init (TestIClass *iface)
{
g_signal_override_class_closure (foo_signal_id,
TEST_TYPE_A,
g_cclosure_new (G_CALLBACK (test_a_foo),
NULL, NULL));
g_signal_override_class_closure (foo_signal_id,
TEST_TYPE_A,
g_cclosure_new (G_CALLBACK (test_a_foo),
NULL, NULL));
}
static GType
test_a_get_type (void)
{
static GType type = 0;
if (!type) {
static const GTypeInfo type_info = {
sizeof(TestAClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) test_a_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof(TestAClass),
0, /* n_preallocs */
(GInstanceInitFunc) NULL,
};
static const GInterfaceInfo interface_info = {
(GInterfaceInitFunc) test_a_interface_init,
NULL,
NULL
};
type = g_type_register_static (G_TYPE_OBJECT, "TestA",
&type_info, 0);
g_type_add_interface_static (type, TEST_TYPE_I, &interface_info);
}
return type;
}
static DEFINE_TYPE_FULL (TestA, test_a,
test_a_class_init, NULL, NULL,
G_TYPE_OBJECT,
INTERFACE (test_a_interface_init, TEST_TYPE_I))
#define TEST_TYPE_B (test_b_get_type())
#define TEST_B(object) (G_TYPE_CHECK_INSTANCE_CAST((object), TEST_TYPE_B, TestB))
#define TEST_B_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TEST_TYPE_B, TestBClass))
#define TEST_IS_B(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), TEST_TYPE_B))
#define TEST_IS_B_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TEST_TYPE_B))
#define TEST_B_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TEST_TYPE_B, TestBClass))
typedef struct _TestB TestB;
typedef struct _TestBClass TestBClass;
struct _TestB {
TestA parent;
TestA parent;
};
struct _TestBClass {
TestAClass parent_class;
TestAClass parent_class;
};
static void
test_b_foo (TestA *self)
{
GValue args[1] = { { 0, } };
GValue args[1] = { { 0, } };
g_print("TestB::foo called. Chaining up.\n");
record ("TestB::foo");
g_value_init (&args[0], TEST_TYPE_A);
g_value_set_object (&args[0], self);
g_value_init (&args[0], TEST_TYPE_A);
g_value_set_object (&args[0], self);
g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);
g_signal_chain_from_overridden (args, NULL);
g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);
g_signal_chain_from_overridden (args, NULL);
g_value_unset (&args[0]);
g_value_unset (&args[0]);
}
static void
test_b_bar (TestI *self)
{
GValue args[1] = { { 0, } };
GValue args[1] = { { 0, } };
g_print("TestB::bar called. Chaining up.\n");
record ("TestB::bar");
g_value_init (&args[0], TEST_TYPE_A);
g_value_set_object (&args[0], self);
g_value_init (&args[0], TEST_TYPE_A);
g_value_set_object (&args[0], self);
g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id);
g_signal_chain_from_overridden (args, NULL);
g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id);
g_signal_chain_from_overridden (args, NULL);
g_value_unset (&args[0]);
g_value_unset (&args[0]);
}
static void
test_b_class_init (TestBClass *class)
{
g_signal_override_class_closure (foo_signal_id,
TEST_TYPE_B,
g_cclosure_new (G_CALLBACK (test_b_foo),
NULL, NULL));
g_signal_override_class_closure (bar_signal_id,
TEST_TYPE_B,
g_cclosure_new (G_CALLBACK (test_b_bar),
NULL, NULL));
}
static GType
test_b_get_type (void)
{
static GType type = 0;
if (!type) {
static const GTypeInfo type_info = {
sizeof(TestBClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) test_b_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof(TestBClass),
0, /* n_preallocs */
(GInstanceInitFunc) NULL,
};
type = g_type_register_static (TEST_TYPE_A, "TestB",
&type_info, 0);
}
return type;
g_signal_override_class_closure (foo_signal_id,
TEST_TYPE_B,
g_cclosure_new (G_CALLBACK (test_b_foo),
NULL, NULL));
g_signal_override_class_closure (bar_signal_id,
TEST_TYPE_B,
g_cclosure_new (G_CALLBACK (test_b_bar),
NULL, NULL));
}
static DEFINE_TYPE (TestB, test_b,
test_b_class_init, NULL, NULL,
TEST_TYPE_A)
#define TEST_TYPE_C (test_c_get_type())
#define TEST_C(object) (G_TYPE_CHECK_INSTANCE_CAST((object), TEST_TYPE_C, TestC))
#define TEST_C_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TEST_TYPE_C, TestCClass))
#define TEST_IS_C(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), TEST_TYPE_C))
#define TEST_IS_C_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TEST_TYPE_C))
#define TEST_C_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TEST_TYPE_C, TestCClass))
typedef struct _TestC TestC;
typedef struct _TestCClass TestCClass;
struct _TestC {
TestB parent;
TestB parent;
};
struct _TestCClass {
TestBClass parent_class;
TestBClass parent_class;
};
static void
test_c_foo (TestA *self)
{
GValue args[1] = { { 0, } };
GValue args[1] = { { 0, } };
g_print("TestC::foo called. Chaining up.\n");
record ("TestC::foo");
g_value_init (&args[0], TEST_TYPE_A);
g_value_set_object (&args[0], self);
g_value_init (&args[0], TEST_TYPE_A);
g_value_set_object (&args[0], self);
g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);
g_signal_chain_from_overridden (args, NULL);
g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);
g_signal_chain_from_overridden (args, NULL);
g_value_unset (&args[0]);
g_value_unset (&args[0]);
}
static void
test_c_bar (TestI *self)
{
GValue args[1] = { { 0, } };
GValue args[1] = { { 0, } };
g_print("TestC::bar called. Chaining up.\n");
record ("TestC::bar");
g_value_init (&args[0], TEST_TYPE_A);
g_value_set_object (&args[0], self);
g_value_init (&args[0], TEST_TYPE_A);
g_value_set_object (&args[0], self);
g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id);
g_signal_chain_from_overridden (args, NULL);
g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id);
g_signal_chain_from_overridden (args, NULL);
g_value_unset (&args[0]);
g_value_unset (&args[0]);
}
static void
test_c_class_init (TestBClass *class)
{
g_signal_override_class_closure (foo_signal_id,
TEST_TYPE_C,
g_cclosure_new (G_CALLBACK (test_c_foo),
NULL, NULL));
g_signal_override_class_closure (bar_signal_id,
TEST_TYPE_C,
g_cclosure_new (G_CALLBACK (test_c_bar),
NULL, NULL));
g_signal_override_class_closure (foo_signal_id,
TEST_TYPE_C,
g_cclosure_new (G_CALLBACK (test_c_foo),
NULL, NULL));
g_signal_override_class_closure (bar_signal_id,
TEST_TYPE_C,
g_cclosure_new (G_CALLBACK (test_c_bar),
NULL, NULL));
}
static GType
test_c_get_type (void)
static DEFINE_TYPE (TestC, test_c,
test_c_class_init, NULL, NULL,
TEST_TYPE_B)
static GString *test_string = NULL;
gboolean failed = FALSE;
static void
record (const gchar *str)
{
static GType type = 0;
if (!type) {
static const GTypeInfo type_info = {
sizeof(TestCClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) test_c_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof(TestCClass),
0, /* n_preallocs */
(GInstanceInitFunc) NULL,
};
type = g_type_register_static (TEST_TYPE_B, "TestC",
&type_info, 0);
}
return type;
if (test_string->len)
g_string_append_c (test_string, ',');
g_string_append (test_string, str);
}
static void
test (GType type,
const gchar *signal,
const gchar *expected)
{
GObject *self = g_object_new (type, NULL);
test_string = g_string_new (NULL);
g_signal_emit_by_name (self, signal, 0);
#ifndef VERBOSE
if (strcmp (test_string->str, expected) != 0)
#endif
{
g_printerr ("*** emitting %s on a %s instance\n"
" Expecting: %s\n"
" Got: %s\n",
signal, g_type_name (type),
expected,
test_string->str);
if (strcmp (test_string->str, expected) != 0)
failed = TRUE;
}
g_string_free (test_string, TRUE);
}
int
main (int argc, char **argv)
{
GObject *self;
g_log_set_always_fatal (g_log_set_always_fatal (G_LOG_FATAL_MASK) |
G_LOG_LEVEL_WARNING |
G_LOG_LEVEL_CRITICAL);
g_type_init();
g_type_init();
test (TEST_TYPE_A, "foo", "TestA::foo,TestI::foo");
test (TEST_TYPE_A, "bar", "TestA::bar");
self = g_object_new(TEST_TYPE_A, NULL);
g_print("*** emiting foo on a TestA instance (expect chain A->I)\n");
g_signal_emit(self, foo_signal_id, 0);
g_print("*** emiting bar on a TestA instance\n");
g_signal_emit(self, bar_signal_id, 0);
g_object_unref(self);
test (TEST_TYPE_B, "foo", "TestB::foo,TestA::foo,TestI::foo");
test (TEST_TYPE_B, "bar", "TestB::bar,TestA::bar");
g_print("\n");
test (TEST_TYPE_C, "foo", "TestC::foo,TestB::foo,TestA::foo,TestI::foo");
test (TEST_TYPE_C, "bar", "TestC::bar,TestB::bar,TestA::bar");
self = g_object_new(TEST_TYPE_B, NULL);
g_print("*** emiting foo on a TestB instance (expect chain B->A->I)\n");
g_signal_emit(self, foo_signal_id, 0);
g_print("*** emiting bar on a TestB instance (expect chain B->A)\n");
g_signal_emit(self, bar_signal_id, 0);
g_object_unref(self);
g_print("\n");
self = g_object_new(TEST_TYPE_C, NULL);
g_print("*** emiting foo on a TestC instance (expect chain C->B->A->I)\n");
g_signal_emit(self, foo_signal_id, 0);
g_print("*** emiting bar on a TestC instance (expect chain C->B->A)\n");
g_signal_emit(self, bar_signal_id, 0);
g_object_unref(self);
return 0;
return failed ? 1 : 0;
}