mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2025-03-28 10:30:03 +01:00
9e8f07b156
It is common to declare a mutex locker variable and to not use it in the scope. That causes clang to warn about unused variable which is not entirely true since the cleanup function IS the intended usage. Work around that issue with a new macro that uses G_GNUC_UNUSED and has the extra advantage of being less verbose. Fixes: #3223.
852 lines
21 KiB
C
852 lines
21 KiB
C
#include <glib.h>
|
||
#include <string.h>
|
||
|
||
typedef struct _HNVC HasNonVoidCleanup;
|
||
HasNonVoidCleanup * non_void_cleanup (HasNonVoidCleanup *);
|
||
|
||
/* Should not cause any warnings with -Wextra */
|
||
G_DEFINE_AUTOPTR_CLEANUP_FUNC(HasNonVoidCleanup, non_void_cleanup)
|
||
|
||
static void
|
||
test_autofree (void)
|
||
{
|
||
#ifdef __clang_analyzer__
|
||
g_test_skip ("autofree tests aren’t understood by the clang analyser");
|
||
#else
|
||
g_autofree gchar *p = NULL;
|
||
g_autofree gchar *p2 = NULL;
|
||
g_autofree gchar *alwaysnull = NULL;
|
||
|
||
p = g_malloc (10);
|
||
p2 = g_malloc (42);
|
||
|
||
p[0] = 1;
|
||
p2[0] = 1;
|
||
|
||
if (TRUE)
|
||
{
|
||
g_autofree guint8 *buf = g_malloc (128);
|
||
g_autofree gchar *alwaysnull_again = NULL;
|
||
|
||
buf[0] = 1;
|
||
|
||
g_assert_null (alwaysnull_again);
|
||
}
|
||
|
||
if (TRUE)
|
||
{
|
||
g_autofree guint8 *buf2 = g_malloc (256);
|
||
|
||
buf2[255] = 42;
|
||
}
|
||
|
||
g_assert_null (alwaysnull);
|
||
#endif /* __clang_analyzer__ */
|
||
}
|
||
|
||
static void
|
||
test_g_async_queue (void)
|
||
{
|
||
g_autoptr(GAsyncQueue) val = g_async_queue_new ();
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_bookmark_file (void)
|
||
{
|
||
g_autoptr(GBookmarkFile) val = g_bookmark_file_new ();
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_bytes (void)
|
||
{
|
||
g_autoptr(GBytes) val = g_bytes_new ("foo", 3);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_checksum (void)
|
||
{
|
||
g_autoptr(GChecksum) val = g_checksum_new (G_CHECKSUM_SHA256);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_date (void)
|
||
{
|
||
g_autoptr(GDate) val = g_date_new ();
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_date_time (void)
|
||
{
|
||
g_autoptr(GDateTime) val = g_date_time_new_now_utc ();
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_dir (void)
|
||
{
|
||
g_autoptr(GDir) val = g_dir_open (".", 0, NULL);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_error (void)
|
||
{
|
||
g_autoptr(GError) val = g_error_new_literal (G_FILE_ERROR, G_FILE_ERROR_FAILED, "oops");
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_hash_table (void)
|
||
{
|
||
g_autoptr(GHashTable) val = g_hash_table_new (NULL, NULL);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_hmac (void)
|
||
{
|
||
g_autoptr(GHmac) val = g_hmac_new (G_CHECKSUM_SHA256, (guint8*)"hello", 5);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_io_channel (void)
|
||
{
|
||
#ifdef G_OS_WIN32
|
||
const gchar *devnull = "nul";
|
||
#else
|
||
const gchar *devnull = "/dev/null";
|
||
#endif
|
||
|
||
g_autoptr(GIOChannel) val = g_io_channel_new_file (devnull, "r", NULL);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_key_file (void)
|
||
{
|
||
g_autoptr(GKeyFile) val = g_key_file_new ();
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_list (void)
|
||
{
|
||
g_autoptr(GList) val = NULL;
|
||
g_autoptr(GList) val2 = g_list_prepend (NULL, "foo");
|
||
g_assert_null (val);
|
||
g_assert_nonnull (val2);
|
||
}
|
||
|
||
static void
|
||
test_g_array (void)
|
||
{
|
||
g_autoptr(GArray) val = g_array_new (0, 0, sizeof (gpointer));
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_ptr_array (void)
|
||
{
|
||
g_autoptr(GPtrArray) val = g_ptr_array_new ();
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_byte_array (void)
|
||
{
|
||
g_autoptr(GByteArray) val = g_byte_array_new ();
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_main_context (void)
|
||
{
|
||
g_autoptr(GMainContext) val = g_main_context_new ();
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_main_context_pusher (void)
|
||
{
|
||
GMainContext *context, *old_thread_default;
|
||
|
||
context = g_main_context_new ();
|
||
old_thread_default = g_main_context_get_thread_default ();
|
||
g_assert_false (old_thread_default == context);
|
||
|
||
if (TRUE)
|
||
{
|
||
g_autoptr(GMainContextPusher) val = g_main_context_pusher_new (context);
|
||
g_assert_nonnull (val);
|
||
|
||
/* Check it’s now the thread-default main context */
|
||
g_assert_true (g_main_context_get_thread_default () == context);
|
||
}
|
||
|
||
/* Check it’s now the old thread-default main context */
|
||
g_assert_false (g_main_context_get_thread_default () == context);
|
||
g_assert_true (g_main_context_get_thread_default () == old_thread_default);
|
||
|
||
g_main_context_unref (context);
|
||
}
|
||
|
||
static void
|
||
test_g_main_loop (void)
|
||
{
|
||
g_autoptr(GMainLoop) val = g_main_loop_new (NULL, TRUE);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_source (void)
|
||
{
|
||
g_autoptr(GSource) val = g_timeout_source_new_seconds (2);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_mapped_file (void)
|
||
{
|
||
g_autoptr(GMappedFile) val = g_mapped_file_new (g_test_get_filename (G_TEST_DIST, "keyfiletest.ini", NULL), FALSE, NULL);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
parser_start (GMarkupParseContext *context,
|
||
const gchar *element_name,
|
||
const gchar **attribute_names,
|
||
const gchar **attribute_values,
|
||
gpointer user_data,
|
||
GError **error)
|
||
{
|
||
}
|
||
|
||
static void
|
||
parser_end (GMarkupParseContext *context,
|
||
const gchar *element_name,
|
||
gpointer user_data,
|
||
GError **error)
|
||
{
|
||
}
|
||
|
||
static GMarkupParser parser = {
|
||
.start_element = parser_start,
|
||
.end_element = parser_end
|
||
};
|
||
|
||
static void
|
||
test_g_markup_parse_context (void)
|
||
{
|
||
g_autoptr(GMarkupParseContext) val = g_markup_parse_context_new (&parser,
|
||
G_MARKUP_DEFAULT_FLAGS,
|
||
NULL, NULL);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_node (void)
|
||
{
|
||
g_autoptr(GNode) val = g_node_new ("hello");
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_option_context (void)
|
||
{
|
||
g_autoptr(GOptionContext) val = g_option_context_new ("hello");
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_option_group (void)
|
||
{
|
||
g_autoptr(GOptionGroup) val = g_option_group_new ("hello", "world", "helpme", NULL, NULL);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_pattern_spec (void)
|
||
{
|
||
g_autoptr(GPatternSpec) val = g_pattern_spec_new ("plaid");
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_queue (void)
|
||
{
|
||
g_autoptr(GQueue) val = g_queue_new ();
|
||
g_auto(GQueue) stackval = G_QUEUE_INIT;
|
||
g_assert_nonnull (val);
|
||
g_assert_null (stackval.head);
|
||
}
|
||
|
||
static void
|
||
test_g_rand (void)
|
||
{
|
||
g_autoptr(GRand) val = g_rand_new ();
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_regex (void)
|
||
{
|
||
g_autoptr(GRegex) val = g_regex_new (".*", G_REGEX_DEFAULT,
|
||
G_REGEX_MATCH_DEFAULT, NULL);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_match_info (void)
|
||
{
|
||
g_autoptr(GRegex) regex = g_regex_new (".*", G_REGEX_DEFAULT,
|
||
G_REGEX_MATCH_DEFAULT, NULL);
|
||
g_autoptr(GMatchInfo) match = NULL;
|
||
|
||
if (!g_regex_match (regex, "hello", 0, &match))
|
||
g_assert_not_reached ();
|
||
}
|
||
|
||
static void
|
||
test_g_scanner (void)
|
||
{
|
||
GScannerConfig config = { 0, };
|
||
g_autoptr(GScanner) val = g_scanner_new (&config);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_sequence (void)
|
||
{
|
||
g_autoptr(GSequence) val = g_sequence_new (NULL);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_slist (void)
|
||
{
|
||
g_autoptr(GSList) val = NULL;
|
||
g_autoptr(GSList) nonempty_val = g_slist_prepend (NULL, "hello");
|
||
g_assert_null (val);
|
||
g_assert_nonnull (nonempty_val);
|
||
}
|
||
|
||
static void
|
||
test_g_string (void)
|
||
{
|
||
g_autoptr(GString) val = g_string_new ("");
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_string_chunk (void)
|
||
{
|
||
g_autoptr(GStringChunk) val = g_string_chunk_new (42);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static gpointer
|
||
mythread (gpointer data)
|
||
{
|
||
g_usleep (G_USEC_PER_SEC);
|
||
return NULL;
|
||
}
|
||
|
||
static void
|
||
test_g_thread (void)
|
||
{
|
||
g_autoptr(GThread) val = g_thread_new ("bob", mythread, NULL);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_mutex (void)
|
||
{
|
||
g_auto(GMutex) val;
|
||
|
||
g_mutex_init (&val);
|
||
}
|
||
|
||
/* Thread function to check that a mutex given in @data is locked */
|
||
static gpointer
|
||
mutex_locked_thread (gpointer data)
|
||
{
|
||
GMutex *mutex = (GMutex *) data;
|
||
g_assert_false (g_mutex_trylock (mutex));
|
||
return NULL;
|
||
}
|
||
|
||
/* Thread function to check that a mutex given in @data is unlocked */
|
||
static gpointer
|
||
mutex_unlocked_thread (gpointer data)
|
||
{
|
||
GMutex *mutex = (GMutex *) data;
|
||
g_assert_true (g_mutex_trylock (mutex));
|
||
g_mutex_unlock (mutex);
|
||
return NULL;
|
||
}
|
||
|
||
static void
|
||
test_g_mutex_locker (void)
|
||
{
|
||
GMutex mutex;
|
||
GThread *thread;
|
||
|
||
g_mutex_init (&mutex);
|
||
|
||
if (TRUE)
|
||
{
|
||
/* val is unused in this scope but compiler should not warn. */
|
||
G_MUTEX_AUTO_LOCK (&mutex, val);
|
||
}
|
||
|
||
if (TRUE)
|
||
{
|
||
g_autoptr(GMutexLocker) val = g_mutex_locker_new (&mutex);
|
||
|
||
g_assert_nonnull (val);
|
||
|
||
/* Verify that the mutex is actually locked */
|
||
thread = g_thread_new ("mutex locked", mutex_locked_thread, &mutex);
|
||
g_thread_join (thread);
|
||
}
|
||
|
||
/* Verify that the mutex is unlocked again */
|
||
thread = g_thread_new ("mutex unlocked", mutex_unlocked_thread, &mutex);
|
||
g_thread_join (thread);
|
||
}
|
||
|
||
/* Thread function to check that a recursive mutex given in @data is locked */
|
||
static gpointer
|
||
rec_mutex_locked_thread (gpointer data)
|
||
{
|
||
GRecMutex *rec_mutex = (GRecMutex *) data;
|
||
g_assert_false (g_rec_mutex_trylock (rec_mutex));
|
||
return NULL;
|
||
}
|
||
|
||
/* Thread function to check that a recursive mutex given in @data is unlocked */
|
||
static gpointer
|
||
rec_mutex_unlocked_thread (gpointer data)
|
||
{
|
||
GRecMutex *rec_mutex = (GRecMutex *) data;
|
||
g_assert_true (g_rec_mutex_trylock (rec_mutex));
|
||
g_rec_mutex_unlock (rec_mutex);
|
||
return NULL;
|
||
}
|
||
|
||
static void
|
||
test_g_rec_mutex_locker (void)
|
||
{
|
||
GRecMutex rec_mutex;
|
||
GThread *thread;
|
||
|
||
g_rec_mutex_init (&rec_mutex);
|
||
|
||
if (TRUE)
|
||
{
|
||
/* val is unused in this scope but compiler should not warn. */
|
||
G_REC_MUTEX_AUTO_LOCK (&rec_mutex, val);
|
||
}
|
||
|
||
if (TRUE)
|
||
{
|
||
g_autoptr(GRecMutexLocker) val = g_rec_mutex_locker_new (&rec_mutex);
|
||
g_autoptr(GRecMutexLocker) other = NULL;
|
||
|
||
g_assert_nonnull (val);
|
||
|
||
/* Verify that the mutex is actually locked */
|
||
thread = g_thread_new ("rec mutex locked", rec_mutex_locked_thread, &rec_mutex);
|
||
g_thread_join (g_steal_pointer (&thread));
|
||
|
||
other = g_rec_mutex_locker_new (&rec_mutex);
|
||
thread = g_thread_new ("rec mutex locked", rec_mutex_locked_thread, &rec_mutex);
|
||
g_thread_join (g_steal_pointer (&thread));
|
||
}
|
||
|
||
/* Verify that the mutex is unlocked again */
|
||
thread = g_thread_new ("rec mutex unlocked", rec_mutex_unlocked_thread, &rec_mutex);
|
||
g_thread_join (thread);
|
||
|
||
g_rec_mutex_clear (&rec_mutex);
|
||
}
|
||
|
||
/* Thread function to check that an rw lock given in @data cannot be writer locked */
|
||
static gpointer
|
||
rw_lock_cannot_take_writer_lock_thread (gpointer data)
|
||
{
|
||
GRWLock *lock = (GRWLock *) data;
|
||
g_assert_false (g_rw_lock_writer_trylock (lock));
|
||
return NULL;
|
||
}
|
||
|
||
/* Thread function to check that an rw lock given in @data can be reader locked */
|
||
static gpointer
|
||
rw_lock_can_take_reader_lock_thread (gpointer data)
|
||
{
|
||
GRWLock *lock = (GRWLock *) data;
|
||
g_assert_true (g_rw_lock_reader_trylock (lock));
|
||
g_rw_lock_reader_unlock (lock);
|
||
return NULL;
|
||
}
|
||
|
||
static void
|
||
test_g_rw_lock_lockers (void)
|
||
{
|
||
GRWLock lock;
|
||
GThread *thread;
|
||
|
||
g_rw_lock_init (&lock);
|
||
|
||
if (TRUE)
|
||
{
|
||
/* val is unused in this scope but compiler should not warn. */
|
||
G_RW_LOCK_WRITER_AUTO_LOCK (&lock, val);
|
||
}
|
||
|
||
if (TRUE)
|
||
{
|
||
/* val is unused in this scope but compiler should not warn. */
|
||
G_RW_LOCK_READER_AUTO_LOCK (&lock, val);
|
||
}
|
||
|
||
if (TRUE)
|
||
{
|
||
g_autoptr(GRWLockWriterLocker) val = g_rw_lock_writer_locker_new (&lock);
|
||
|
||
g_assert_nonnull (val);
|
||
|
||
/* Verify that we cannot take another writer lock as a writer lock is currently held */
|
||
thread = g_thread_new ("rw lock cannot take writer lock", rw_lock_cannot_take_writer_lock_thread, &lock);
|
||
g_thread_join (thread);
|
||
|
||
/* Verify that we cannot take a reader lock as a writer lock is currently held */
|
||
g_assert_false (g_rw_lock_reader_trylock (&lock));
|
||
}
|
||
|
||
if (TRUE)
|
||
{
|
||
g_autoptr(GRWLockReaderLocker) val = g_rw_lock_reader_locker_new (&lock);
|
||
|
||
g_assert_nonnull (val);
|
||
|
||
/* Verify that we can take another reader lock from another thread */
|
||
thread = g_thread_new ("rw lock can take reader lock", rw_lock_can_take_reader_lock_thread, &lock);
|
||
g_thread_join (thread);
|
||
|
||
/* ... and also that recursive reader locking from the same thread works */
|
||
g_assert_true (g_rw_lock_reader_trylock (&lock));
|
||
g_rw_lock_reader_unlock (&lock);
|
||
|
||
/* Verify that we cannot take a writer lock as a reader lock is currently held */
|
||
thread = g_thread_new ("rw lock cannot take writer lock", rw_lock_cannot_take_writer_lock_thread, &lock);
|
||
g_thread_join (thread);
|
||
}
|
||
|
||
/* Verify that we can take a writer lock again: this can only work if all of
|
||
* the locks taken above have been correctly released. */
|
||
g_assert_true (g_rw_lock_writer_trylock (&lock));
|
||
g_rw_lock_writer_unlock (&lock);
|
||
|
||
g_rw_lock_clear (&lock);
|
||
}
|
||
|
||
G_LOCK_DEFINE (test_g_auto_lock);
|
||
|
||
static void
|
||
test_g_auto_lock (void)
|
||
{
|
||
GThread *thread;
|
||
|
||
if (TRUE)
|
||
{
|
||
G_AUTO_LOCK (test_g_auto_lock);
|
||
|
||
/* Verify that the mutex is actually locked */
|
||
thread = g_thread_new ("mutex locked", mutex_locked_thread, &G_LOCK_NAME (test_g_auto_lock));
|
||
g_thread_join (thread);
|
||
}
|
||
|
||
/* Verify that the mutex is unlocked again */
|
||
thread = g_thread_new ("mutex unlocked", mutex_unlocked_thread, &G_LOCK_NAME (test_g_auto_lock));
|
||
g_thread_join (thread);
|
||
}
|
||
|
||
static void
|
||
test_g_cond (void)
|
||
{
|
||
g_auto(GCond) val;
|
||
g_cond_init (&val);
|
||
}
|
||
|
||
static void
|
||
test_g_timer (void)
|
||
{
|
||
g_autoptr(GTimer) val = g_timer_new ();
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_time_zone (void)
|
||
{
|
||
g_autoptr(GTimeZone) val = g_time_zone_new_utc ();
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_tree (void)
|
||
{
|
||
g_autoptr(GTree) val = g_tree_new ((GCompareFunc)strcmp);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_variant (void)
|
||
{
|
||
g_autoptr(GVariant) val = g_variant_new_string ("hello");
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_variant_builder (void)
|
||
{
|
||
g_autoptr(GVariantBuilder) val = g_variant_builder_new (G_VARIANT_TYPE ("as"));
|
||
g_auto(GVariantBuilder) stackval;
|
||
|
||
g_assert_nonnull (val);
|
||
g_variant_builder_init (&stackval, G_VARIANT_TYPE ("as"));
|
||
}
|
||
|
||
static void
|
||
test_g_variant_iter (void)
|
||
{
|
||
g_autoptr(GVariant) var = g_variant_new_fixed_array (G_VARIANT_TYPE_UINT32, "", 0, sizeof(guint32));
|
||
g_autoptr(GVariantIter) val = g_variant_iter_new (var);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_variant_dict (void)
|
||
{
|
||
g_autoptr(GVariant) data = g_variant_new_from_data (G_VARIANT_TYPE ("a{sv}"), "", 0, FALSE, NULL, NULL);
|
||
g_auto(GVariantDict) stackval;
|
||
g_autoptr(GVariantDict) val = g_variant_dict_new (data);
|
||
|
||
g_variant_dict_init (&stackval, data);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_g_variant_type (void)
|
||
{
|
||
g_autoptr(GVariantType) val = g_variant_type_new ("s");
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_strv (void)
|
||
{
|
||
g_auto(GStrv) val = g_strsplit("a:b:c", ":", -1);
|
||
g_assert_nonnull (val);
|
||
}
|
||
|
||
static void
|
||
test_refstring (void)
|
||
{
|
||
g_autoptr(GRefString) str = g_ref_string_new ("hello, world");
|
||
g_assert_nonnull (str);
|
||
}
|
||
|
||
static void
|
||
test_pathbuf (void)
|
||
{
|
||
#if defined(G_OS_UNIX)
|
||
g_autoptr(GPathBuf) buf1 = g_path_buf_new_from_path ("/bin/sh");
|
||
g_auto(GPathBuf) buf2 = G_PATH_BUF_INIT;
|
||
|
||
g_path_buf_push (&buf2, "/bin/sh");
|
||
#elif defined(G_OS_WIN32)
|
||
g_autoptr(GPathBuf) buf1 = g_path_buf_new_from_path ("C:\\windows\\system32.dll");
|
||
g_auto(GPathBuf) buf2 = G_PATH_BUF_INIT;
|
||
|
||
g_path_buf_push (&buf2, "C:\\windows\\system32.dll");
|
||
#else
|
||
g_test_skip ("Unsupported platform");
|
||
return;
|
||
#endif
|
||
|
||
g_autofree char *path1 = g_path_buf_to_path (buf1);
|
||
g_autofree char *path2 = g_path_buf_to_path (&buf2);
|
||
|
||
g_assert_cmpstr (path1, ==, path2);
|
||
}
|
||
|
||
static void
|
||
mark_freed (gpointer ptr)
|
||
{
|
||
gboolean *freed = ptr;
|
||
*freed = TRUE;
|
||
}
|
||
|
||
static void
|
||
test_autolist (void)
|
||
{
|
||
char data[1] = {0};
|
||
gboolean freed1 = FALSE;
|
||
gboolean freed2 = FALSE;
|
||
gboolean freed3 = FALSE;
|
||
GBytes *b1 = g_bytes_new_with_free_func (data, sizeof(data), mark_freed, &freed1);
|
||
GBytes *b2 = g_bytes_new_with_free_func (data, sizeof(data), mark_freed, &freed2);
|
||
GBytes *b3 = g_bytes_new_with_free_func (data, sizeof(data), mark_freed, &freed3);
|
||
|
||
{
|
||
g_autolist(GBytes) l = NULL;
|
||
|
||
l = g_list_prepend (l, b1);
|
||
l = g_list_prepend (l, b3);
|
||
|
||
/* Squash warnings about dead stores */
|
||
(void) l;
|
||
}
|
||
|
||
/* Only assert if autoptr works */
|
||
#ifdef __GNUC__
|
||
g_assert_true (freed1);
|
||
g_assert_true (freed3);
|
||
#endif
|
||
g_assert_false (freed2);
|
||
|
||
g_bytes_unref (b2);
|
||
g_assert_true (freed2);
|
||
}
|
||
|
||
static void
|
||
test_autoslist (void)
|
||
{
|
||
char data[1] = {0};
|
||
gboolean freed1 = FALSE;
|
||
gboolean freed2 = FALSE;
|
||
gboolean freed3 = FALSE;
|
||
GBytes *b1 = g_bytes_new_with_free_func (data, sizeof(data), mark_freed, &freed1);
|
||
GBytes *b2 = g_bytes_new_with_free_func (data, sizeof(data), mark_freed, &freed2);
|
||
GBytes *b3 = g_bytes_new_with_free_func (data, sizeof(data), mark_freed, &freed3);
|
||
|
||
{
|
||
g_autoslist(GBytes) l = NULL;
|
||
|
||
l = g_slist_prepend (l, b1);
|
||
l = g_slist_prepend (l, b3);
|
||
}
|
||
|
||
/* Only assert if autoptr works */
|
||
#ifdef __GNUC__
|
||
g_assert_true (freed1);
|
||
g_assert_true (freed3);
|
||
#endif
|
||
g_assert_false (freed2);
|
||
|
||
g_bytes_unref (b2);
|
||
g_assert_true (freed2);
|
||
}
|
||
|
||
static void
|
||
test_autoqueue (void)
|
||
{
|
||
char data[1] = {0};
|
||
gboolean freed1 = FALSE;
|
||
gboolean freed2 = FALSE;
|
||
gboolean freed3 = FALSE;
|
||
GBytes *b1 = g_bytes_new_with_free_func (data, sizeof(data), mark_freed, &freed1);
|
||
GBytes *b2 = g_bytes_new_with_free_func (data, sizeof(data), mark_freed, &freed2);
|
||
GBytes *b3 = g_bytes_new_with_free_func (data, sizeof(data), mark_freed, &freed3);
|
||
|
||
{
|
||
g_autoqueue(GBytes) q = g_queue_new ();
|
||
|
||
g_queue_push_head (q, b1);
|
||
g_queue_push_tail (q, b3);
|
||
}
|
||
|
||
/* Only assert if autoptr works */
|
||
#ifdef __GNUC__
|
||
g_assert_true (freed1);
|
||
g_assert_true (freed3);
|
||
#endif
|
||
g_assert_false (freed2);
|
||
|
||
g_bytes_unref (b2);
|
||
g_assert_true (freed2);
|
||
}
|
||
|
||
int
|
||
main (int argc, gchar *argv[])
|
||
{
|
||
g_test_init (&argc, &argv, NULL);
|
||
|
||
g_test_add_func ("/autoptr/autofree", test_autofree);
|
||
g_test_add_func ("/autoptr/g_async_queue", test_g_async_queue);
|
||
g_test_add_func ("/autoptr/g_bookmark_file", test_g_bookmark_file);
|
||
g_test_add_func ("/autoptr/g_bytes", test_g_bytes);
|
||
g_test_add_func ("/autoptr/g_checksum", test_g_checksum);
|
||
g_test_add_func ("/autoptr/g_date", test_g_date);
|
||
g_test_add_func ("/autoptr/g_date_time", test_g_date_time);
|
||
g_test_add_func ("/autoptr/g_dir", test_g_dir);
|
||
g_test_add_func ("/autoptr/g_error", test_g_error);
|
||
g_test_add_func ("/autoptr/g_hash_table", test_g_hash_table);
|
||
g_test_add_func ("/autoptr/g_hmac", test_g_hmac);
|
||
g_test_add_func ("/autoptr/g_io_channel", test_g_io_channel);
|
||
g_test_add_func ("/autoptr/g_key_file", test_g_key_file);
|
||
g_test_add_func ("/autoptr/g_list", test_g_list);
|
||
g_test_add_func ("/autoptr/g_array", test_g_array);
|
||
g_test_add_func ("/autoptr/g_ptr_array", test_g_ptr_array);
|
||
g_test_add_func ("/autoptr/g_byte_array", test_g_byte_array);
|
||
g_test_add_func ("/autoptr/g_main_context", test_g_main_context);
|
||
g_test_add_func ("/autoptr/g_main_context_pusher", test_g_main_context_pusher);
|
||
g_test_add_func ("/autoptr/g_main_loop", test_g_main_loop);
|
||
g_test_add_func ("/autoptr/g_source", test_g_source);
|
||
g_test_add_func ("/autoptr/g_mapped_file", test_g_mapped_file);
|
||
g_test_add_func ("/autoptr/g_markup_parse_context", test_g_markup_parse_context);
|
||
g_test_add_func ("/autoptr/g_node", test_g_node);
|
||
g_test_add_func ("/autoptr/g_option_context", test_g_option_context);
|
||
g_test_add_func ("/autoptr/g_option_group", test_g_option_group);
|
||
g_test_add_func ("/autoptr/g_pattern_spec", test_g_pattern_spec);
|
||
g_test_add_func ("/autoptr/g_queue", test_g_queue);
|
||
g_test_add_func ("/autoptr/g_rand", test_g_rand);
|
||
g_test_add_func ("/autoptr/g_regex", test_g_regex);
|
||
g_test_add_func ("/autoptr/g_match_info", test_g_match_info);
|
||
g_test_add_func ("/autoptr/g_scanner", test_g_scanner);
|
||
g_test_add_func ("/autoptr/g_sequence", test_g_sequence);
|
||
g_test_add_func ("/autoptr/g_slist", test_g_slist);
|
||
g_test_add_func ("/autoptr/g_string", test_g_string);
|
||
g_test_add_func ("/autoptr/g_string_chunk", test_g_string_chunk);
|
||
g_test_add_func ("/autoptr/g_thread", test_g_thread);
|
||
g_test_add_func ("/autoptr/g_mutex", test_g_mutex);
|
||
g_test_add_func ("/autoptr/g_mutex_locker", test_g_mutex_locker);
|
||
g_test_add_func ("/autoptr/g_rec_mutex_locker", test_g_rec_mutex_locker);
|
||
g_test_add_func ("/autoptr/g_rw_lock_lockers", test_g_rw_lock_lockers);
|
||
g_test_add_func ("/autoptr/g_auto_lock", test_g_auto_lock);
|
||
g_test_add_func ("/autoptr/g_cond", test_g_cond);
|
||
g_test_add_func ("/autoptr/g_timer", test_g_timer);
|
||
g_test_add_func ("/autoptr/g_time_zone", test_g_time_zone);
|
||
g_test_add_func ("/autoptr/g_tree", test_g_tree);
|
||
g_test_add_func ("/autoptr/g_variant", test_g_variant);
|
||
g_test_add_func ("/autoptr/g_variant_builder", test_g_variant_builder);
|
||
g_test_add_func ("/autoptr/g_variant_iter", test_g_variant_iter);
|
||
g_test_add_func ("/autoptr/g_variant_dict", test_g_variant_dict);
|
||
g_test_add_func ("/autoptr/g_variant_type", test_g_variant_type);
|
||
g_test_add_func ("/autoptr/strv", test_strv);
|
||
g_test_add_func ("/autoptr/refstring", test_refstring);
|
||
g_test_add_func ("/autoptr/pathbuf", test_pathbuf);
|
||
g_test_add_func ("/autoptr/autolist", test_autolist);
|
||
g_test_add_func ("/autoptr/autoslist", test_autoslist);
|
||
g_test_add_func ("/autoptr/autoqueue", test_autoqueue);
|
||
|
||
return g_test_run ();
|
||
}
|