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