glib/tests/logging.c

   1 #include <stdlib.h>
   2 #include <glib.h>
   3
   4 /* Test g_warn macros */
   5 static void
   6 test_warnings (void)
   7 {
   8   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
   9     {
  10       g_warn_if_reached ();
  11     }
  12   g_test_trap_assert_failed();
  13   g_test_trap_assert_stderr ("*WARNING*test_warnings*should not be reached*");
  14
  15   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
  16     {
  17       g_warn_if_fail (FALSE);
  18     }
  19   g_test_trap_assert_failed();
  20   g_test_trap_assert_stderr ("*WARNING*test_warnings*runtime check failed*");
  21 }
  22
  23 static guint log_count = 0;
  24
  25 static void
  26 log_handler (const gchar    *log_domain,
  27              GLogLevelFlags  log_level,
  28              const gchar    *message,
  29              gpointer        user_data)
  30 {
  31   g_assert_cmpstr (log_domain, ==, "bu");
  32   g_assert_cmpint (log_level, ==, G_LOG_LEVEL_INFO);
  33
  34   log_count++;
  35 }
  36
  37 /* test that custom log handlers only get called for
  38  * their domain and level
  39  */
  40 static void
  41 test_set_handler (void)
  42 {
  43   guint id;
  44
  45   id = g_log_set_handler ("bu", G_LOG_LEVEL_INFO, log_handler, NULL);
  46
  47   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
  48     {
  49       g_log ("bu", G_LOG_LEVEL_DEBUG, "message");
  50       g_log ("ba", G_LOG_LEVEL_DEBUG, "message");
  51       g_log ("bu", G_LOG_LEVEL_INFO, "message");
  52       g_log ("ba", G_LOG_LEVEL_INFO, "message");
  53
  54       g_assert_cmpint (log_count, ==, 1);
  55       exit (0);
  56     }
  57   g_test_trap_assert_passed ();
  58
  59   g_log_remove_handler ("bu", id);
  60 }
  61
  62 static void
  63 test_default_handler (void)
  64 {
  65   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
  66     {
  67       g_error ("message1");
  68       exit (0);
  69     }
  70   g_test_trap_assert_failed ();
  71   g_test_trap_assert_stderr ("*ERROR*message1*");
  72
  73   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
  74     {
  75       g_critical ("message2");
  76       exit (0);
  77     }
  78   g_test_trap_assert_failed ();
  79   g_test_trap_assert_stderr ("*CRITICAL*message2*");
  80
  81   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
  82     {
  83       g_warning ("message3");
  84       exit (0);
  85     }
  86   g_test_trap_assert_failed ();
  87   g_test_trap_assert_stderr ("*WARNING*message3*");
  88
  89   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
  90     {
  91       g_message ("message4");
  92       exit (0);
  93     }
  94   g_test_trap_assert_passed ();
  95   g_test_trap_assert_stderr ("*Message*message4*");
  96
  97   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
  98     {
  99       g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, "message5");
 100       exit (0);
 101     }
 102   g_test_trap_assert_passed ();
 103   g_test_trap_assert_stdout_unmatched ("*INFO*message5*");
 104
 105   g_setenv ("G_MESSAGES_DEBUG", "foo bar baz", TRUE);
 106   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
 107     {
 108       g_log ("bar", G_LOG_LEVEL_INFO, "message5");
 109       exit (0);
 110     }
 111   g_test_trap_assert_passed ();
 112   g_test_trap_assert_stdout ("*INFO*message5*");
 113
 114   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
 115     {
 116       g_log ("baz", G_LOG_LEVEL_DEBUG, "message6");
 117       exit (0);
 118     }
 119   g_test_trap_assert_passed ();
 120   g_test_trap_assert_stdout ("*DEBUG*message6*");
 121
 122   g_setenv ("G_MESSAGES_DEBUG", "all", TRUE);
 123   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
 124     {
 125       g_log ("foo", G_LOG_LEVEL_DEBUG, "6");
 126       g_log ("bar", G_LOG_LEVEL_DEBUG, "6");
 127       g_log ("baz", G_LOG_LEVEL_DEBUG, "6");
 128       exit (0);
 129     }
 130   g_test_trap_assert_passed ();
 131   g_test_trap_assert_stdout ("*DEBUG*6*6*6*");
 132
 133   g_unsetenv ("G_MESSAGES_DEBUG");
 134   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
 135     {
 136       g_log (G_LOG_DOMAIN, 1<<10, "message7");
 137       exit (0);
 138     }
 139   g_test_trap_assert_passed ();
 140   g_test_trap_assert_stdout ("*LOG-0x400*message7*");
 141 }
 142
 143 /* test that setting levels as fatal works */
 144 static void
 145 test_fatal_log_mask (void)
 146 {
 147   GLogLevelFlags flags;
 148
 149   flags = g_log_set_fatal_mask ("bu", G_LOG_LEVEL_INFO);
 150   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT))
 151     g_log ("bu", G_LOG_LEVEL_INFO, "fatal");
 152   g_test_trap_assert_failed ();
 153   g_log_set_fatal_mask ("bu", flags);
 154 }
 155
 156 static gint my_print_count = 0;
 157 static void
 158 my_print_handler (const gchar *text)
 159 {
 160   my_print_count++;
 161 }
 162
 163 static void
 164 test_print_handler (void)
 165 {
 166   GPrintFunc old_print_handler;
 167
 168   old_print_handler = g_set_print_handler (my_print_handler);
 169   g_assert (old_print_handler == NULL);
 170
 171   my_print_count = 0;
 172   g_print ("bu ba");
 173   g_assert_cmpint (my_print_count, ==, 1);
 174
 175   g_set_print_handler (NULL);
 176 }
 177
 178 static void
 179 test_printerr_handler (void)
 180 {
 181   GPrintFunc old_printerr_handler;
 182
 183   old_printerr_handler = g_set_printerr_handler (my_print_handler);
 184   g_assert (old_printerr_handler == NULL);
 185
 186   my_print_count = 0;
 187   g_printerr ("bu ba");
 188   g_assert_cmpint (my_print_count, ==, 1);
 189
 190   g_set_printerr_handler (NULL);
 191 }
 192
 193 static char *fail_str = "foo";
 194 static char *log_str = "bar";
 195
 196 static gboolean
 197 good_failure_handler (const gchar    *log_domain,
 198                       GLogLevelFlags  log_level,
 199                       const gchar    *msg,
 200                       gpointer        user_data)
 201 {
 202   g_test_message ("The Good Fail Message Handler\n");
 203   g_assert ((char *)user_data != log_str);
 204   g_assert ((char *)user_data == fail_str);
 205
 206   return FALSE;
 207 }
 208
 209 static gboolean
 210 bad_failure_handler (const gchar    *log_domain,
 211                      GLogLevelFlags  log_level,
 212                      const gchar    *msg,
 213                      gpointer        user_data)
 214 {
 215   g_test_message ("The Bad Fail Message Handler\n");
 216   g_assert ((char *)user_data == log_str);
 217   g_assert ((char *)user_data != fail_str);
 218
 219   return FALSE;
 220 }
 221
 222 static void
 223 test_handler (const gchar    *log_domain,
 224               GLogLevelFlags  log_level,
 225               const gchar    *msg,
 226               gpointer        user_data)
 227 {
 228   g_test_message ("The Log Message Handler\n");
 229   g_assert ((char *)user_data != fail_str);
 230   g_assert ((char *)user_data == log_str);
 231 }
 232
 233 static void
 234 bug653052 (void)
 235 {
 236   g_test_bug ("653052");
 237
 238   g_test_log_set_fatal_handler (good_failure_handler, fail_str);
 239   g_log_set_default_handler (test_handler, log_str);
 240
 241   g_return_if_fail (0);
 242
 243   g_test_log_set_fatal_handler (bad_failure_handler, fail_str);
 244   g_log_set_default_handler (test_handler, log_str);
 245
 246   g_return_if_fail (0);
 247 }
 248
 249 int
 250 main (int argc, char *argv[])
 251 {
 252   g_test_init (&argc, &argv, NULL);
 253   g_test_bug_base ("http://bugzilla.gnome.org/");
 254
 255   g_test_add_func ("/logging/default-handler", test_default_handler);
 256   g_test_add_func ("/logging/warnings", test_warnings);
 257   g_test_add_func ("/logging/fatal-log-mask", test_fatal_log_mask);
 258   g_test_add_func ("/logging/set-handler", test_set_handler);
 259   g_test_add_func ("/logging/print-handler", test_print_handler);
 260   g_test_add_func ("/logging/printerr-handler", test_printerr_handler);
 261   g_test_add_func ("/logging/653052", bug653052);
 262
 263   return g_test_run ();
 264 }
 265