glib/tests/mem-overflow.c

   1 /* Unit tests for g
   2  * Copyright (C) 2010 Red Hat, Inc.
   3  *
   4  * This work is provided "as is"; redistribution and modification
   5  * in whole or in part, in any medium, physical or electronic is
   6  * permitted without restriction.
   7  *
   8  * This work is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  11  *
  12  * In no event shall the authors or contributors be liable for any
  13  * direct, indirect, incidental, special, exemplary, or consequential
  14  * damages (including, but not limited to, procurement of substitute
  15  * goods or services; loss of use, data, or profits; or business
  16  * interruption) however caused and on any theory of liability, whether
  17  * in contract, strict liability, or tort (including negligence or
  18  * otherwise) arising in any way out of the use of this software, even
  19  * if advised of the possibility of such damage.
  20  */
  21
  22 /* We test for errors in optimize-only definitions in gmem.h */
  23
  24 #ifdef __GNUC__
  25 #pragma GCC optimize (1)
  26 #pragma GCC diagnostic push
  27 #pragma GCC diagnostic ignored "-Walloc-size-larger-than="
  28 #endif
  29
  30 #include "glib.h"
  31 #include <stdlib.h>
  32
  33 static gsize a = G_MAXSIZE / 10 + 10;
  34 static gsize b = 10;
  35 typedef char X[10];
  36
  37 #define MEM_OVERFLOW_TEST(name, code) \
  38 static void                           \
  39 mem_overflow_ ## name (void)          \
  40 {                                     \
  41   gpointer p;                         \
  42   code;                               \
  43   g_free (p);                         \
  44   exit (0);                           \
  45 }
  46
  47 MEM_OVERFLOW_TEST (malloc_n_a_a, p = g_malloc_n (a, a))
  48 MEM_OVERFLOW_TEST (malloc_n_a_b, p = g_malloc_n (a, b))
  49 MEM_OVERFLOW_TEST (malloc_n_b_a, p = g_malloc_n (b, a))
  50 MEM_OVERFLOW_TEST (malloc_n_b_b, p = g_malloc_n (b, b))
  51
  52 MEM_OVERFLOW_TEST (malloc0_n_a_a, p = g_malloc0_n (a, a))
  53 MEM_OVERFLOW_TEST (malloc0_n_a_b, p = g_malloc0_n (a, b))
  54 MEM_OVERFLOW_TEST (malloc0_n_b_a, p = g_malloc0_n (b, a))
  55 MEM_OVERFLOW_TEST (malloc0_n_b_b, p = g_malloc0_n (b, b))
  56
  57 MEM_OVERFLOW_TEST (realloc_n_a_a, p = g_malloc (1); p = g_realloc_n (p, a, a))
  58 MEM_OVERFLOW_TEST (realloc_n_a_b, p = g_malloc (1); p = g_realloc_n (p, a, b))
  59 MEM_OVERFLOW_TEST (realloc_n_b_a, p = g_malloc (1); p = g_realloc_n (p, b, a))
  60 MEM_OVERFLOW_TEST (realloc_n_b_b, p = g_malloc (1); p = g_realloc_n (p, b, b))
  61
  62 MEM_OVERFLOW_TEST (new_a, p = g_new (X, a))
  63 MEM_OVERFLOW_TEST (new_b, p = g_new (X, b))
  64
  65 MEM_OVERFLOW_TEST (new0_a, p = g_new0 (X, a))
  66 MEM_OVERFLOW_TEST (new0_b, p = g_new0 (X, b))
  67
  68 MEM_OVERFLOW_TEST (renew_a, p = g_malloc (1); p = g_renew (X, p, a))
  69 MEM_OVERFLOW_TEST (renew_b, p = g_malloc (1); p = g_renew (X, p, b))
  70
  71 static void
  72 mem_overflow_malloc_0 (void)
  73 {
  74   gpointer p;
  75
  76   p = g_malloc (0);
  77   g_assert (p == NULL);
  78 }
  79
  80 static void
  81 mem_overflow_realloc_0 (void)
  82 {
  83   gpointer p;
  84
  85   p = g_malloc (10);
  86   g_assert (p != NULL);
  87   p = g_realloc (p, 0);
  88   g_assert (p == NULL);
  89 }
  90
  91 static void
  92 mem_overflow (void)
  93 {
  94   gpointer p, q;
  95
  96   /* "FAIL" here apparently means "fail to overflow"... */
  97 #define CHECK_PASS(P)   p = (P); g_assert (p == NULL);
  98 #define CHECK_FAIL(P)   p = (P); g_assert (p != NULL);
  99
 100   CHECK_PASS (g_try_malloc_n (a, a));
 101   CHECK_PASS (g_try_malloc_n (a, b));
 102   CHECK_PASS (g_try_malloc_n (b, a));
 103   CHECK_FAIL (g_try_malloc_n (b, b));
 104   g_free (p);
 105
 106   CHECK_PASS (g_try_malloc0_n (a, a));
 107   CHECK_PASS (g_try_malloc0_n (a, b));
 108   CHECK_PASS (g_try_malloc0_n (b, a));
 109   CHECK_FAIL (g_try_malloc0_n (b, b));
 110   g_free (p);
 111
 112   q = g_malloc (1);
 113   CHECK_PASS (g_try_realloc_n (q, a, a));
 114   CHECK_PASS (g_try_realloc_n (q, a, b));
 115   CHECK_PASS (g_try_realloc_n (q, b, a));
 116   CHECK_FAIL (g_try_realloc_n (q, b, b));
 117   g_free (p);
 118
 119   CHECK_PASS (g_try_new (X, a));
 120   CHECK_FAIL (g_try_new (X, b));
 121   g_free (p);
 122
 123   CHECK_PASS (g_try_new0 (X, a));
 124   CHECK_FAIL (g_try_new0 (X, b));
 125   g_free (p);
 126
 127   q = g_try_malloc (1);
 128   CHECK_PASS (g_try_renew (X, q, a));
 129   CHECK_FAIL (g_try_renew (X, q, b));
 130   free (p);
 131
 132 #define CHECK_SUBPROCESS_FAIL(name) do { \
 133       if (g_test_undefined ()) \
 134         { \
 135           g_test_trap_subprocess ("/mem/overflow/subprocess/" #name, 0, 0); \
 136           g_test_trap_assert_failed(); \
 137         } \
 138     } while (0)
 139
 140 #define CHECK_SUBPROCESS_PASS(name) do { \
 141       if (g_test_undefined ()) \
 142         { \
 143           g_test_trap_subprocess ("/mem/overflow/subprocess/" #name, 0, 0); \
 144           g_test_trap_assert_passed(); \
 145         } \
 146     } while (0)
 147
 148   CHECK_SUBPROCESS_FAIL (malloc_n_a_a);
 149   CHECK_SUBPROCESS_FAIL (malloc_n_a_b);
 150   CHECK_SUBPROCESS_FAIL (malloc_n_b_a);
 151   CHECK_SUBPROCESS_PASS (malloc_n_b_b);
 152
 153   CHECK_SUBPROCESS_FAIL (malloc0_n_a_a);
 154   CHECK_SUBPROCESS_FAIL (malloc0_n_a_b);
 155   CHECK_SUBPROCESS_FAIL (malloc0_n_b_a);
 156   CHECK_SUBPROCESS_PASS (malloc0_n_b_b);
 157
 158   CHECK_SUBPROCESS_FAIL (realloc_n_a_a);
 159   CHECK_SUBPROCESS_FAIL (realloc_n_a_b);
 160   CHECK_SUBPROCESS_FAIL (realloc_n_b_a);
 161   CHECK_SUBPROCESS_PASS (realloc_n_b_b);
 162
 163   CHECK_SUBPROCESS_FAIL (new_a);
 164   CHECK_SUBPROCESS_PASS (new_b);
 165
 166   CHECK_SUBPROCESS_FAIL (new0_a);
 167   CHECK_SUBPROCESS_PASS (new0_b);
 168
 169   CHECK_SUBPROCESS_FAIL (renew_a);
 170   CHECK_SUBPROCESS_PASS (renew_b);
 171
 172   CHECK_SUBPROCESS_PASS (malloc_0);
 173   CHECK_SUBPROCESS_PASS (realloc_0);
 174 }
 175
 176 #ifdef __GNUC__
 177 typedef struct
 178 {
 179 } Empty;
 180
 181 static void
 182 empty_alloc_subprocess (void)
 183 {
 184   Empty *empty;
 185
 186   empty = g_new0 (Empty, 1);
 187   g_assert (empty == NULL);
 188   exit (0);
 189 }
 190
 191 static void
 192 empty_alloc (void)
 193 {
 194   g_test_bug ("615379");
 195
 196   g_assert_cmpint (sizeof (Empty), ==, 0);
 197
 198   g_test_trap_subprocess ("/mem/empty-alloc/subprocess", 0, 0);
 199   g_test_trap_assert_passed ();
 200 }
 201 #endif
 202
 203 #ifdef __GNUC__
 204 #pragma GCC diagnostic pop
 205 #endif
 206
 207 int
 208 main (int   argc,
 209       char *argv[])
 210 {
 211   g_test_init (&argc, &argv, NULL);
 212
 213   g_test_bug_base ("http://bugzilla.gnome.org/");
 214
 215   g_test_add_func ("/mem/overflow", mem_overflow);
 216   g_test_add_func ("/mem/overflow/subprocess/malloc_n_a_a", mem_overflow_malloc_n_a_a);
 217   g_test_add_func ("/mem/overflow/subprocess/malloc_n_a_b", mem_overflow_malloc_n_a_b);
 218   g_test_add_func ("/mem/overflow/subprocess/malloc_n_b_a", mem_overflow_malloc_n_b_a);
 219   g_test_add_func ("/mem/overflow/subprocess/malloc_n_b_b", mem_overflow_malloc_n_b_b);
 220   g_test_add_func ("/mem/overflow/subprocess/malloc0_n_a_a", mem_overflow_malloc0_n_a_a);
 221   g_test_add_func ("/mem/overflow/subprocess/malloc0_n_a_b", mem_overflow_malloc0_n_a_b);
 222   g_test_add_func ("/mem/overflow/subprocess/malloc0_n_b_a", mem_overflow_malloc0_n_b_a);
 223   g_test_add_func ("/mem/overflow/subprocess/malloc0_n_b_b", mem_overflow_malloc0_n_b_b);
 224   g_test_add_func ("/mem/overflow/subprocess/realloc_n_a_a", mem_overflow_realloc_n_a_a);
 225   g_test_add_func ("/mem/overflow/subprocess/realloc_n_a_b", mem_overflow_realloc_n_a_b);
 226   g_test_add_func ("/mem/overflow/subprocess/realloc_n_b_a", mem_overflow_realloc_n_b_a);
 227   g_test_add_func ("/mem/overflow/subprocess/realloc_n_b_b", mem_overflow_realloc_n_b_b);
 228   g_test_add_func ("/mem/overflow/subprocess/new_a", mem_overflow_new_a);
 229   g_test_add_func ("/mem/overflow/subprocess/new_b", mem_overflow_new_b);
 230   g_test_add_func ("/mem/overflow/subprocess/new0_a", mem_overflow_new0_a);
 231   g_test_add_func ("/mem/overflow/subprocess/new0_b", mem_overflow_new0_b);
 232   g_test_add_func ("/mem/overflow/subprocess/renew_a", mem_overflow_renew_a);
 233   g_test_add_func ("/mem/overflow/subprocess/renew_b", mem_overflow_renew_b);
 234   g_test_add_func ("/mem/overflow/subprocess/malloc_0", mem_overflow_malloc_0);
 235   g_test_add_func ("/mem/overflow/subprocess/realloc_0", mem_overflow_realloc_0);
 236
 237 #ifdef __GNUC__
 238   g_test_add_func ("/mem/empty-alloc", empty_alloc);
 239   g_test_add_func ("/mem/empty-alloc/subprocess", empty_alloc_subprocess);
 240 #endif
 241
 242   return g_test_run();
 243 }