unittest-support.h

/********************************************************************
 * unittest-support.h: Support structures for GLib Unit Testing     *
 * Copyright 2011-12 John Ralls <[email protected]>                *
 * Copyright 2011 Muslim Chochlov <[email protected]>       *
 *                                                                  *
 * This program is free software; you can redistribute it and/or    *
 * modify it under the terms of the GNU General Public License as   *
 * published by the Free Software Foundation; either version 2 of   *
 * the License, or (at your option) any later version.              *
 *                                                                  *
 * This program 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 General Public License for more details.                     *
 *                                                                  *
 * You should have received a copy of the GNU General Public License*
 * along with this program; if not, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       [email protected]                   *
********************************************************************/
#ifndef UNITTEST_SUPPORT_H
#define UNITTEST_SUPPORT_H

#include <glib.h>
#include <qof.h>

#define GNC_TEST_ADD( suite, path, fixture, data, setup, test, teardown )\
{\
    gchar *testpath = g_strdup_printf( "%s/%s", suite, path );\
    g_test_add( testpath, fixture, data, setup, test, teardown );\
    g_free( testpath );\
}

#define GNC_TEST_ADD_FUNC( suite, path, test )\
{\
    gchar *testpath = g_strdup_printf( "%s/%s", suite, path );\
    g_test_add_func( testpath, test );\
    g_free( testpath );\
}

typedef struct
{
    GLogLevelFlags log_level;
    gchar *log_domain;
    gchar *msg;
    guint hits;
} TestErrorStruct;

TestErrorStruct* test_error_struct_new (gchar *log_domain,
                                        GLogLevelFlags log_level,
                                        gchar *msg);

void test_error_struct_free (TestErrorStruct *);

typedef struct
{
    TestErrorStruct *error;
    gint handler;
    gboolean list_handler;
} TestLogHandler;


GSList *test_log_set_handler (GSList *list, TestErrorStruct *error,
                              GLogFunc handler);

GSList *test_log_set_fatal_handler (GSList *list, TestErrorStruct *error,
                                    GLogFunc handler);

/* Clears all the log handlers. Pass this to g_slist_free() in teardown */
void test_free_log_handler (gpointer item);

gboolean test_checked_handler (const char *log_domain, GLogLevelFlags log_level,
                               const gchar *msg, gpointer user_data);

gboolean test_log_handler (const char *log_domain, GLogLevelFlags log_level,
                           const gchar *msg, gpointer user_data);
gboolean test_null_handler (const char *log_domain, GLogLevelFlags log_level,
                            const gchar *msg, gpointer user_data );
void test_add_error (TestErrorStruct *error);
void test_clear_error_list (void);

gboolean test_list_handler (const char *log_domain,
                            GLogLevelFlags log_level,
                            const gchar *msg, gpointer user_data );
void test_set_called( const gboolean val );

gboolean test_reset_called( void );

void test_set_data( gpointer data );

gpointer test_reset_data( void );

void test_free( gpointer data );

/* TestSignal is an opaque struct used to mock handling signals
 * emitted by functions-under-test. It registers a handler and counts
 * how many times it is called with the right instance and type.  The
 * struct is allocated using g_slice_new, and it registers a
 * qof_event_handler; test_signal_free cleans up at the end of the
 * test function (or sooner, if you want to reuse a TestSignal).  If
 * event_data isn't NULL, the mock signal handler will test that it
 * matches the event_data passed with the signal and assert if it
 * isn't the same object (pointer comparison). If the actual event
 * data is a local variable, it won't be accessible, so the event_data
 * passed to test_signal_new should be NULL to avoid the test.
 */
typedef gpointer TestSignal;
TestSignal test_signal_new (QofInstance *entity, QofEventId eventType,
                            gpointer event_data);
/* test_signal_return_hits gets the number of times the TestSignal has
 * been called.
 */
guint test_signal_return_hits (TestSignal sig);

/* test_signal_assert_hits is a convenience macro which wraps
 * test_signal_return_hits with and equality assertion.
 */

#define test_signal_assert_hits(sig, hits) \
    g_assert_cmpint (test_signal_return_hits (sig), ==, hits)

void test_signal_free (TestSignal sig);

/* test_object_checked_destroy unrefs obj and returns true if its finalize
 * method was called.
 */

gboolean test_object_checked_destroy (GObject *obj);

#define test_destroy(obj) \
    g_assert (obj != NULL && G_IS_OBJECT (obj));                \
    g_assert (test_object_checked_destroy (G_OBJECT (obj)))

/* For Scheme testing access:
void gnc_log_init_filename_special (gchar *filename);
void gnc_log_shutdown (void);
void gnc_log_set_handler (guint logdomain, gchar *logdomain, GLogFunc * func, gpointer data);
*/

#endif /*UNITTEST_SUPPORT_H*/