1 /* GObject - GLib Type, Object, Parameter and Signal Library

     2  * Copyright (C) 2005 Red Hat, Inc.

     3  * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     4  * This library is free software; you can redistribute it and/or

     5  * modify it under the terms of the GNU Lesser General Public

     6  * License as published by the Free Software Foundation; either

     7  * version 2 of the License, or (at your option) any later version.

     8  *

     9  * This library is distributed in the hope that it will be useful,

    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12  * Lesser General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU Lesser General

    15  * Public License along with this library; if not, write to the

    16  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,

    17  * Boston, MA 02111-1307, USA.

    18  */

    19 

    20 #undef	G_LOG_DOMAIN

    21 #define	G_LOG_DOMAIN "TestReferences"

    22 

    23 #undef G_DISABLE_ASSERT

    24 #undef G_DISABLE_CHECKS

    25 #undef G_DISABLE_CAST_CHECKS

    26 

    27   

    28 #include	<glib-object.h>

    29 

    30 #ifdef SYMBIAN

    31   #include "mrt2_glib2_test.h"

    32   #endif /*SYMBIAN*/

    33 

    34 /* This test tests weak and toggle references

    35  */

    36 static GObject *global_object;

    37 

    38 static gboolean object_destroyed;

    39 static gboolean weak_ref1_notified;

    40 static gboolean weak_ref2_notified;

    41 static gboolean toggle_ref1_weakened;

    42 static gboolean toggle_ref1_strengthened;

    43 static gboolean toggle_ref2_weakened;

    44 static gboolean toggle_ref2_strengthened;

    45 static gboolean toggle_ref3_weakened;

    46 static gboolean toggle_ref3_strengthened;

    47 

    48 /*

    49  * TestObject, a parent class for TestObject

    50  */

    51 #define TEST_TYPE_OBJECT          (test_object_get_type ())

    52 typedef struct _TestObject        TestObject;

    53 typedef struct _TestObjectClass   TestObjectClass;

    54 

    55 struct _TestObject

    56 {

    57   GObject parent_instance;

    58 };

    59 struct _TestObjectClass

    60 {

    61   GObjectClass parent_class;

    62 };

    63 

    64 G_DEFINE_TYPE (TestObject, test_object, G_TYPE_OBJECT);

    65 

    66 static void

    67 test_object_finalize (GObject *object)

    68 {

    69   object_destroyed = TRUE;

    70   

    71   G_OBJECT_CLASS (test_object_parent_class)->finalize (object);

    72 }

    73 

    74 static void

    75 test_object_class_init (TestObjectClass *class)

    76 {

    77   GObjectClass *object_class = G_OBJECT_CLASS (class);

    78 

    79   object_class->finalize = test_object_finalize;

    80 }

    81 

    82 static void

    83 test_object_init (TestObject *test_object)

    84 {

    85 }

    86 

    87 static void

    88 clear_flags (void)

    89 {

    90   object_destroyed = FALSE;

    91   weak_ref1_notified = FALSE;

    92   weak_ref2_notified = FALSE;

    93   toggle_ref1_weakened = FALSE;

    94   toggle_ref1_strengthened = FALSE;

    95   toggle_ref2_weakened = FALSE;

    96   toggle_ref2_strengthened = FALSE;

    97   toggle_ref3_weakened = FALSE;

    98   toggle_ref3_strengthened = FALSE;

    99 }

   100 

   101 static void

   102 weak_ref1 (gpointer data,

   103 	   GObject *object)

   104 {

   105   g_assert (object == global_object);

   106   g_assert (data == GUINT_TO_POINTER (42));

   107 

   108   weak_ref1_notified = TRUE;

   109 }

   110 

   111 static void

   112 weak_ref2 (gpointer data,

   113 	   GObject *object)

   114 {

   115   g_assert (object == global_object);

   116   g_assert (data == GUINT_TO_POINTER (24));

   117 

   118   weak_ref2_notified = TRUE;

   119 }

   120 

   121 static void

   122 toggle_ref1 (gpointer data,

   123 	     GObject *object,

   124 	     gboolean is_last_ref)

   125 {

   126   g_assert (object == global_object);

   127   g_assert (data == GUINT_TO_POINTER (42));

   128 

   129   if (is_last_ref)

   130     toggle_ref1_weakened = TRUE;

   131   else

   132     toggle_ref1_strengthened = TRUE;

   133 }

   134 

   135 static void

   136 toggle_ref2 (gpointer data,

   137 	     GObject *object,

   138 	     gboolean is_last_ref)

   139 {

   140   g_assert (object == global_object);

   141   g_assert (data == GUINT_TO_POINTER (24));

   142 

   143   if (is_last_ref)

   144     toggle_ref2_weakened = TRUE;

   145   else

   146     toggle_ref2_strengthened = TRUE;

   147 }

   148 

   149 static void

   150 toggle_ref3 (gpointer data,

   151 	     GObject *object,

   152 	     gboolean is_last_ref)

   153 {

   154   g_assert (object == global_object);

   155   g_assert (data == GUINT_TO_POINTER (34));

   156 

   157   if (is_last_ref)

   158     {

   159       toggle_ref3_weakened = TRUE;

   160       g_object_remove_toggle_ref (object, toggle_ref3, GUINT_TO_POINTER (34));

   161     }

   162   else

   163     toggle_ref3_strengthened = TRUE;

   164 }

   165 

   166 int

   167 main (int   argc,

   168       char *argv[])

   169 {

   170   GObject *object;

   171 	

   172   g_log_set_always_fatal (g_log_set_always_fatal (G_LOG_FATAL_MASK) |

   173 			  G_LOG_LEVEL_WARNING |

   174 			  G_LOG_LEVEL_CRITICAL);

   175   g_type_init ();

   176 

   177 

   178   #ifdef SYMBIAN

   179   g_log_set_handler (NULL,  G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);

   180   #endif /*SYMBIAN*/

   181   /* Test basic weak reference operation

   182    */

   183   global_object = object = g_object_new (TEST_TYPE_OBJECT, NULL);

   184   

   185   g_object_weak_ref (object, weak_ref1, GUINT_TO_POINTER (42));

   186 

   187   clear_flags ();

   188   g_object_unref (object);

   189   g_assert (weak_ref1_notified == TRUE);

   190   g_assert (object_destroyed == TRUE);

   191 

   192   /* Test two weak references at once

   193    */

   194   global_object = object = g_object_new (TEST_TYPE_OBJECT, NULL);

   195   

   196   g_object_weak_ref (object, weak_ref1, GUINT_TO_POINTER (42));

   197   g_object_weak_ref (object, weak_ref2, GUINT_TO_POINTER (24));

   198 

   199   clear_flags ();

   200   g_object_unref (object);

   201   g_assert (weak_ref1_notified == TRUE);

   202   g_assert (weak_ref2_notified == TRUE);

   203   g_assert (object_destroyed == TRUE);

   204 

   205   /* Test remove weak references

   206    */

   207   global_object = object = g_object_new (TEST_TYPE_OBJECT, NULL);

   208   

   209   g_object_weak_ref (object, weak_ref1, GUINT_TO_POINTER (42));

   210   g_object_weak_ref (object, weak_ref2, GUINT_TO_POINTER (24));

   211   g_object_weak_unref (object, weak_ref1, GUINT_TO_POINTER (42));

   212 

   213   clear_flags ();

   214   g_object_unref (object);

   215   g_assert (weak_ref1_notified == FALSE);

   216   g_assert (weak_ref2_notified == TRUE);

   217   g_assert (object_destroyed == TRUE);

   218 

   219   /* Test basic toggle reference operation

   220    */

   221   global_object = object = g_object_new (TEST_TYPE_OBJECT, NULL);

   222   

   223   g_object_add_toggle_ref (object, toggle_ref1, GUINT_TO_POINTER (42));

   224 

   225   clear_flags ();

   226   g_object_unref (object);

   227   g_assert (toggle_ref1_weakened == TRUE);

   228   g_assert (toggle_ref1_strengthened == FALSE);

   229   g_assert (object_destroyed == FALSE);

   230 

   231   clear_flags ();

   232   g_object_ref (object);

   233   g_assert (toggle_ref1_weakened == FALSE);

   234   g_assert (toggle_ref1_strengthened == TRUE);

   235   g_assert (object_destroyed == FALSE);

   236 

   237   g_object_unref (object);

   238 

   239   clear_flags ();

   240   g_object_remove_toggle_ref (object, toggle_ref1, GUINT_TO_POINTER (42));

   241   g_assert (toggle_ref1_weakened == FALSE);

   242   g_assert (toggle_ref1_strengthened == FALSE);

   243   g_assert (object_destroyed == TRUE);

   244 

   245   global_object = object = g_object_new (TEST_TYPE_OBJECT, NULL);

   246 

   247   /* Test two toggle references at once

   248    */

   249   g_object_add_toggle_ref (object, toggle_ref1, GUINT_TO_POINTER (42));

   250   g_object_add_toggle_ref (object, toggle_ref2, GUINT_TO_POINTER (24));

   251 

   252   clear_flags ();

   253   g_object_unref (object);

   254   g_assert (toggle_ref1_weakened == FALSE);

   255   g_assert (toggle_ref1_strengthened == FALSE);

   256   g_assert (toggle_ref2_weakened == FALSE);

   257   g_assert (toggle_ref2_strengthened == FALSE);

   258   g_assert (object_destroyed == FALSE);

   259 

   260   clear_flags ();

   261   g_object_remove_toggle_ref (object, toggle_ref1, GUINT_TO_POINTER (42));

   262   g_assert (toggle_ref1_weakened == FALSE);

   263   g_assert (toggle_ref1_strengthened == FALSE);

   264   g_assert (toggle_ref2_weakened == TRUE);

   265   g_assert (toggle_ref2_strengthened == FALSE);

   266   g_assert (object_destroyed == FALSE);

   267 

   268   clear_flags ();

   269   g_object_remove_toggle_ref (object, toggle_ref2, GUINT_TO_POINTER (24));

   270   g_assert (toggle_ref1_weakened == FALSE);

   271   g_assert (toggle_ref1_strengthened == FALSE);

   272   g_assert (toggle_ref2_weakened == FALSE);

   273   g_assert (toggle_ref2_strengthened == FALSE);

   274   g_assert (object_destroyed == TRUE);

   275   

   276   /* Test a toggle reference that removes itself

   277    */

   278   global_object = object = g_object_new (TEST_TYPE_OBJECT, NULL);

   279   

   280   g_object_add_toggle_ref (object, toggle_ref3, GUINT_TO_POINTER (34));

   281 

   282   clear_flags ();

   283   g_object_unref (object);

   284   g_assert (toggle_ref3_weakened == TRUE);

   285   g_assert (toggle_ref3_strengthened == FALSE);

   286   g_assert (object_destroyed == TRUE);

   287 

   288   #ifdef SYMBIAN

   289   testResultXml("references");

   290   #endif /*SYMBIAN*/

   291   return 0;

   292 }