winedump: Move WineHQ URLs to https.
[wine.git] / dlls / msvcrt / tests / heap.c
blob4a3c7a81700f2245a843e9aee8b9e2f95946a9c0
1 /*
2 * Unit test suite for memory functions
4 * Copyright 2003 Dimitrie O. Paun
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #include <stdlib.h>
22 #include <malloc.h>
23 #include <errno.h>
24 #include "wine/test.h"
26 static void (__cdecl *p_aligned_free)(void*) = NULL;
27 static void * (__cdecl *p_aligned_malloc)(size_t,size_t) = NULL;
28 static void * (__cdecl *p_aligned_offset_malloc)(size_t,size_t,size_t) = NULL;
29 static void * (__cdecl *p_aligned_realloc)(void*,size_t,size_t) = NULL;
30 static void * (__cdecl *p_aligned_offset_realloc)(void*,size_t,size_t,size_t) = NULL;
32 static void test_aligned_malloc(unsigned int size, unsigned int alignment)
34 void *mem;
36 mem = p_aligned_malloc(size, alignment);
38 if ((alignment & (alignment - 1)) == 0)
39 ok(mem != NULL, "_aligned_malloc(%d, %d) failed\n", size, alignment);
40 else
41 ok(mem == NULL, "_aligned_malloc(%d, %d) should have failed\n", size, alignment);
43 if (mem)
45 ok(((DWORD_PTR)mem & (alignment ? alignment - 1 : 0)) == 0,
46 "_aligned_malloc(%d, %d) not aligned: %p\n", size, alignment, mem);
47 if (winetest_debug > 1)
49 void *saved;
50 saved = *(void **)((DWORD_PTR)((char *)mem - sizeof(void *)) & ~(sizeof(void *) - 1));
51 trace("_aligned_malloc(%3d, %3d) returns %p, saved = %p\n", size, alignment, mem, saved );
53 p_aligned_free(mem);
55 else
56 ok(errno == EINVAL, "_aligned_malloc(%d, %d) errno: %d != %d\n", size, alignment, errno, EINVAL);
59 static void test_aligned_offset_malloc(unsigned int size, unsigned int alignment, unsigned int offset)
61 void *mem;
63 mem = p_aligned_offset_malloc(size, alignment, offset);
65 if ((alignment & (alignment - 1)) == 0)
66 if (offset < size)
67 ok(mem != NULL, "_aligned_offset_malloc(%d, %d, %d) failed\n", size, alignment, offset);
68 else
69 ok(errno == EINVAL, "_aligned_offset_malloc(%d, %d, %d) errno: %d != %d\n", size, alignment, offset, errno, EINVAL);
70 else
71 ok(mem == NULL, "_aligned_offset_malloc(%d, %d, %d) should have failed\n", size, alignment, offset);
73 if (mem)
75 ok(((DWORD_PTR)((char *)mem + offset) & (alignment ? alignment - 1 : 0)) == 0,
76 "_aligned_offset_malloc(%d, %d, %d) not aligned: %p\n", size, alignment, offset, mem);
77 if (winetest_debug > 1)
79 void *saved;
80 saved = *(void **)((DWORD_PTR)((char *)mem - sizeof(void *)) & ~(sizeof(void *) - 1));
81 trace("_aligned_offset_malloc(%3d, %3d, %3d) returns %p, saved = %p\n",
82 size, alignment, offset, mem, saved);
84 p_aligned_free(mem);
86 else
87 ok(errno == EINVAL, "_aligned_offset_malloc(%d, %d, %d) errno: %d != %d\n", size, alignment, offset, errno, EINVAL);
90 static void test_aligned_realloc(unsigned int size1, unsigned int size2, unsigned int alignment)
92 void *mem, *mem1, *mem2;
94 mem = p_aligned_malloc(size1, alignment);
96 if ((alignment & (alignment - 1)) == 0)
97 ok(mem != NULL, "_aligned_malloc(%d, %d) failed\n", size1, alignment);
98 else
99 ok(mem == NULL, "_aligned_malloc(%d, %d) should have failed\n", size1, alignment);
101 if (mem)
103 mem1 = malloc(size1);
104 if (mem1)
106 unsigned int i;
107 for (i = 0; i < size1; i++)
108 ((char *)mem)[i] = i + 1;
109 memcpy(mem1, mem, size1);
112 ok(((DWORD_PTR)mem & (alignment ? alignment - 1 : 0)) == 0,
113 "_aligned_malloc(%d, %d) not aligned: %p\n", size1, alignment, mem);
114 if (winetest_debug > 1)
116 void *saved;
117 saved = *(void **)((DWORD_PTR)((char *)mem - sizeof(void *)) & ~(sizeof(void *) - 1));
118 trace("_aligned_malloc(%3d, %3d) returns %p, saved = %p\n", size1, alignment, mem, saved);
121 mem2 = p_aligned_realloc(mem, size2, alignment);
123 ok(mem2 != NULL, "_aligned_realloc(%p, %d, %d) failed\n", mem, size2, alignment);
125 if (mem2)
127 ok(((DWORD_PTR)mem2 & (alignment ? alignment - 1 : 0)) == 0,
128 "_aligned_realloc(%p, %d, %d) not aligned: %p\n", mem, size2, alignment, mem2);
129 if (winetest_debug > 1)
131 void *saved;
132 saved = *(void **)((DWORD_PTR)((char *)mem2 - sizeof(void *)) & ~(sizeof(void *) - 1));
133 trace("_aligned_realloc(%p, %3d, %3d) returns %p, saved = %p\n",
134 mem, size2, alignment, mem2, saved);
136 if (mem1)
138 ok(memcmp(mem2, mem1, min(size1, size2))==0, "_aligned_realloc(%p, %d, %d) has different data\n", mem, size2, alignment);
139 if (memcmp(mem2, mem1, min(size1, size2)) && winetest_debug > 1)
141 unsigned int i;
142 for (i = 0; i < min(size1, size2); i++)
144 if (((char *)mem2)[i] != ((char *)mem1)[i])
145 trace("%d: %02x != %02x\n", i, ((char *)mem2)[i] & 0xff, ((char *)mem1)[i] & 0xff);
149 p_aligned_free(mem2);
150 } else {
151 ok(errno == EINVAL, "_aligned_realloc(%p, %d, %d) errno: %d != %d\n", mem, size2, alignment, errno, EINVAL);
152 p_aligned_free(mem);
155 free(mem1);
157 else
158 ok(errno == EINVAL, "_aligned_malloc(%d, %d) errno: %d != %d\n", size1, alignment, errno, EINVAL);
161 static void test_aligned_offset_realloc(unsigned int size1, unsigned int size2,
162 unsigned int alignment, unsigned int offset)
164 void *mem, *mem1, *mem2;
166 mem = p_aligned_offset_malloc(size1, alignment, offset);
168 if ((alignment & (alignment - 1)) == 0)
169 ok(mem != NULL, "_aligned_offset_malloc(%d, %d, %d) failed\n", size1, alignment, offset);
170 else
171 ok(mem == NULL, "_aligned_offset_malloc(%d, %d, %d) should have failed\n", size1, alignment, offset);
173 if (mem)
175 mem1 = malloc(size1);
176 if (mem1)
178 unsigned int i;
179 for (i = 0; i < size1; i++)
180 ((char *)mem)[i] = i + 1;
181 memcpy(mem1, mem, size1);
184 ok(((DWORD_PTR)((char *)mem + offset) & (alignment ? alignment - 1 : 0)) == 0,
185 "_aligned_offset_malloc(%d, %d, %d) not aligned: %p\n", size1, alignment, offset, mem);
186 if (winetest_debug > 1)
188 void *saved;
189 saved = *(void **)((DWORD_PTR)((char *)mem - sizeof(void *)) & ~(sizeof(void *) - 1));
190 trace("_aligned_offset_malloc(%3d, %3d, %3d) returns %p, saved = %p\n",
191 size1, alignment, offset, mem, saved);
194 mem2 = p_aligned_offset_realloc(mem, size2, alignment, offset);
196 ok(mem2 != NULL, "_aligned_offset_realloc(%p, %d, %d, %d) failed\n", mem, size2, alignment, offset);
198 if (mem2)
200 ok(((DWORD_PTR)((char *)mem + offset) & (alignment ? alignment - 1 : 0)) == 0,
201 "_aligned_offset_realloc(%p, %d, %d, %d) not aligned: %p\n", mem, size2, alignment, offset, mem2);
202 if (winetest_debug > 1)
204 void *saved;
205 saved = *(void **)((DWORD_PTR)((char *)mem2 - sizeof(void *)) & ~(sizeof(void *) - 1));
206 trace("_aligned_offset_realloc(%p, %3d, %3d, %3d) returns %p, saved = %p\n",
207 mem, size2, alignment, offset, mem2, saved);
209 if (mem1)
211 ok(memcmp(mem2, mem1, min(size1, size2))==0, "_aligned_offset_realloc(%p, %d, %d, %d) has different data\n", mem, size2, alignment, offset);
212 if (memcmp(mem2, mem1, min(size1, size2)) && winetest_debug > 1)
214 unsigned int i;
215 for (i = 0; i < min(size1, size2); i++)
217 if (((char *)mem2)[i] != ((char *)mem1)[i])
218 trace("%d: %02x != %02x\n", i, ((char *)mem2)[i] & 0xff, ((char *)mem1)[i] & 0xff);
222 p_aligned_free(mem2);
223 } else {
224 ok(errno == EINVAL, "_aligned_offset_realloc(%p, %d, %d, %d) errno: %d != %d\n", mem, size2, alignment, offset, errno, EINVAL);
225 p_aligned_free(mem);
228 free(mem1);
230 else
231 ok(errno == EINVAL, "_aligned_offset_malloc(%d, %d) errno: %d != %d\n", size1, alignment, errno, EINVAL);
234 static void test_aligned(void)
236 HMODULE msvcrt = GetModuleHandleA("msvcrt.dll");
238 if (msvcrt == NULL)
239 return;
241 p_aligned_free = (void*)GetProcAddress(msvcrt, "_aligned_free");
242 p_aligned_malloc = (void*)GetProcAddress(msvcrt, "_aligned_malloc");
243 p_aligned_offset_malloc = (void*)GetProcAddress(msvcrt, "_aligned_offset_malloc");
244 p_aligned_realloc = (void*)GetProcAddress(msvcrt, "_aligned_realloc");
245 p_aligned_offset_realloc = (void*)GetProcAddress(msvcrt, "_aligned_offset_realloc");
247 if (!p_aligned_free || !p_aligned_malloc || !p_aligned_offset_malloc || !p_aligned_realloc || !p_aligned_offset_realloc)
249 skip("aligned memory tests skipped\n");
250 return;
253 test_aligned_malloc(256, 0);
254 test_aligned_malloc(256, 1);
255 test_aligned_malloc(256, 2);
256 test_aligned_malloc(256, 3);
257 test_aligned_malloc(256, 4);
258 test_aligned_malloc(256, 8);
259 test_aligned_malloc(256, 16);
260 test_aligned_malloc(256, 32);
261 test_aligned_malloc(256, 64);
262 test_aligned_malloc(256, 127);
263 test_aligned_malloc(256, 128);
265 test_aligned_offset_malloc(256, 0, 0);
266 test_aligned_offset_malloc(256, 1, 0);
267 test_aligned_offset_malloc(256, 2, 0);
268 test_aligned_offset_malloc(256, 3, 0);
269 test_aligned_offset_malloc(256, 4, 0);
270 test_aligned_offset_malloc(256, 8, 0);
271 test_aligned_offset_malloc(256, 16, 0);
272 test_aligned_offset_malloc(256, 32, 0);
273 test_aligned_offset_malloc(256, 64, 0);
274 test_aligned_offset_malloc(256, 127, 0);
275 test_aligned_offset_malloc(256, 128, 0);
277 test_aligned_offset_malloc(256, 0, 4);
278 test_aligned_offset_malloc(256, 1, 4);
279 test_aligned_offset_malloc(256, 2, 4);
280 test_aligned_offset_malloc(256, 3, 4);
281 test_aligned_offset_malloc(256, 4, 4);
282 test_aligned_offset_malloc(256, 8, 4);
283 test_aligned_offset_malloc(256, 16, 4);
284 test_aligned_offset_malloc(256, 32, 4);
285 test_aligned_offset_malloc(256, 64, 4);
286 test_aligned_offset_malloc(256, 127, 4);
287 test_aligned_offset_malloc(256, 128, 4);
289 test_aligned_offset_malloc(256, 8, 7);
290 test_aligned_offset_malloc(256, 8, 9);
291 test_aligned_offset_malloc(256, 8, 16);
292 test_aligned_offset_malloc(256, 8, 17);
293 test_aligned_offset_malloc(256, 8, 254);
294 test_aligned_offset_malloc(256, 8, 255);
295 test_aligned_offset_malloc(256, 8, 256);
296 test_aligned_offset_malloc(256, 8, 512);
298 test_aligned_realloc(256, 512, 0);
299 test_aligned_realloc(256, 128, 0);
300 test_aligned_realloc(256, 512, 4);
301 test_aligned_realloc(256, 128, 4);
302 test_aligned_realloc(256, 512, 8);
303 test_aligned_realloc(256, 128, 8);
304 test_aligned_realloc(256, 512, 16);
305 test_aligned_realloc(256, 128, 16);
306 test_aligned_realloc(256, 512, 32);
307 test_aligned_realloc(256, 128, 32);
308 test_aligned_realloc(256, 512, 64);
309 test_aligned_realloc(256, 128, 64);
311 test_aligned_offset_realloc(256, 512, 0, 0);
312 test_aligned_offset_realloc(256, 128, 0, 0);
313 test_aligned_offset_realloc(256, 512, 4, 0);
314 test_aligned_offset_realloc(256, 128, 4, 0);
315 test_aligned_offset_realloc(256, 512, 8, 0);
316 test_aligned_offset_realloc(256, 128, 8, 0);
317 test_aligned_offset_realloc(256, 512, 16, 0);
318 test_aligned_offset_realloc(256, 128, 16, 0);
319 test_aligned_offset_realloc(256, 512, 32, 0);
320 test_aligned_offset_realloc(256, 128, 32, 0);
321 test_aligned_offset_realloc(256, 512, 64, 0);
322 test_aligned_offset_realloc(256, 128, 64, 0);
324 test_aligned_offset_realloc(256, 512, 0, 4);
325 test_aligned_offset_realloc(256, 128, 0, 4);
326 test_aligned_offset_realloc(256, 512, 4, 4);
327 test_aligned_offset_realloc(256, 128, 4, 4);
328 test_aligned_offset_realloc(256, 512, 8, 4);
329 test_aligned_offset_realloc(256, 128, 8, 4);
330 test_aligned_offset_realloc(256, 512, 16, 4);
331 test_aligned_offset_realloc(256, 128, 16, 4);
332 test_aligned_offset_realloc(256, 512, 32, 4);
333 test_aligned_offset_realloc(256, 128, 32, 4);
334 test_aligned_offset_realloc(256, 512, 64, 4);
335 test_aligned_offset_realloc(256, 128, 64, 4);
337 test_aligned_offset_realloc(256, 512, 0, 8);
338 test_aligned_offset_realloc(256, 128, 0, 8);
339 test_aligned_offset_realloc(256, 512, 4, 8);
340 test_aligned_offset_realloc(256, 128, 4, 8);
341 test_aligned_offset_realloc(256, 512, 8, 8);
342 test_aligned_offset_realloc(256, 128, 8, 8);
343 test_aligned_offset_realloc(256, 512, 16, 8);
344 test_aligned_offset_realloc(256, 128, 16, 8);
345 test_aligned_offset_realloc(256, 512, 32, 8);
346 test_aligned_offset_realloc(256, 128, 32, 8);
347 test_aligned_offset_realloc(256, 512, 64, 8);
348 test_aligned_offset_realloc(256, 128, 64, 8);
350 test_aligned_offset_realloc(256, 512, 0, 16);
351 test_aligned_offset_realloc(256, 128, 0, 16);
352 test_aligned_offset_realloc(256, 512, 4, 16);
353 test_aligned_offset_realloc(256, 128, 4, 16);
354 test_aligned_offset_realloc(256, 512, 8, 16);
355 test_aligned_offset_realloc(256, 128, 8, 16);
356 test_aligned_offset_realloc(256, 512, 16, 16);
357 test_aligned_offset_realloc(256, 128, 16, 16);
358 test_aligned_offset_realloc(256, 512, 32, 16);
359 test_aligned_offset_realloc(256, 128, 32, 16);
360 test_aligned_offset_realloc(256, 512, 64, 16);
361 test_aligned_offset_realloc(256, 128, 64, 16);
363 test_aligned_offset_realloc(256, 512, 0, 32);
364 test_aligned_offset_realloc(256, 128, 0, 32);
365 test_aligned_offset_realloc(256, 512, 4, 32);
366 test_aligned_offset_realloc(256, 128, 4, 32);
367 test_aligned_offset_realloc(256, 512, 8, 32);
368 test_aligned_offset_realloc(256, 128, 8, 32);
369 test_aligned_offset_realloc(256, 512, 16, 32);
370 test_aligned_offset_realloc(256, 128, 16, 32);
371 test_aligned_offset_realloc(256, 512, 32, 32);
372 test_aligned_offset_realloc(256, 128, 32, 32);
373 test_aligned_offset_realloc(256, 512, 64, 32);
374 test_aligned_offset_realloc(256, 128, 64, 32);
376 test_aligned_offset_realloc(256, 512, 0, 64);
377 test_aligned_offset_realloc(256, 128, 0, 64);
378 test_aligned_offset_realloc(256, 512, 4, 64);
379 test_aligned_offset_realloc(256, 128, 4, 64);
380 test_aligned_offset_realloc(256, 512, 8, 64);
381 test_aligned_offset_realloc(256, 128, 8, 64);
382 test_aligned_offset_realloc(256, 512, 16, 64);
383 test_aligned_offset_realloc(256, 128, 16, 64);
384 test_aligned_offset_realloc(256, 512, 32, 64);
385 test_aligned_offset_realloc(256, 128, 32, 64);
386 test_aligned_offset_realloc(256, 512, 64, 64);
387 test_aligned_offset_realloc(256, 128, 64, 64);
389 test_aligned_offset_realloc(256, 512, 0, 96);
390 test_aligned_offset_realloc(256, 128, 0, 96);
391 test_aligned_offset_realloc(256, 512, 4, 96);
392 test_aligned_offset_realloc(256, 128, 4, 96);
393 test_aligned_offset_realloc(256, 512, 8, 96);
394 test_aligned_offset_realloc(256, 128, 8, 96);
395 test_aligned_offset_realloc(256, 512, 16, 96);
396 test_aligned_offset_realloc(256, 128, 16, 96);
397 test_aligned_offset_realloc(256, 512, 32, 96);
398 test_aligned_offset_realloc(256, 128, 32, 96);
399 test_aligned_offset_realloc(256, 512, 64, 96);
400 test_aligned_offset_realloc(256, 128, 64, 96);
402 test_aligned_offset_realloc(256, 512, 0, 112);
403 test_aligned_offset_realloc(256, 128, 0, 112);
404 test_aligned_offset_realloc(256, 512, 4, 112);
405 test_aligned_offset_realloc(256, 128, 4, 112);
406 test_aligned_offset_realloc(256, 512, 8, 112);
407 test_aligned_offset_realloc(256, 128, 8, 112);
408 test_aligned_offset_realloc(256, 512, 16, 112);
409 test_aligned_offset_realloc(256, 128, 16, 112);
410 test_aligned_offset_realloc(256, 512, 32, 112);
411 test_aligned_offset_realloc(256, 128, 32, 112);
412 test_aligned_offset_realloc(256, 512, 64, 112);
413 test_aligned_offset_realloc(256, 128, 64, 112);
416 static void test_sbheap(void)
418 void *mem;
419 int threshold;
421 if(sizeof(void*) == 8) {
422 ok(!_set_sbh_threshold(0), "_set_sbh_threshold succeeded\n");
423 ok(!_set_sbh_threshold(1000), "_set_sbh_threshold succeeded\n");
424 return;
427 mem = malloc(1);
428 ok(mem != NULL, "malloc failed\n");
430 ok(_set_sbh_threshold(1), "_set_sbh_threshold failed\n");
431 threshold = _get_sbh_threshold();
432 ok(threshold == 16, "threshold = %d\n", threshold);
434 ok(_set_sbh_threshold(8), "_set_sbh_threshold failed\n");
435 threshold = _get_sbh_threshold();
436 ok(threshold == 16, "threshold = %d\n", threshold);
438 ok(_set_sbh_threshold(1000), "_set_sbh_threshold failed\n");
439 threshold = _get_sbh_threshold();
440 ok(threshold == 1008, "threshold = %d\n", threshold);
442 free(mem);
444 mem = malloc(1);
445 ok(mem != NULL, "malloc failed\n");
446 ok(!((UINT_PTR)mem & 0xf), "incorrect alignment (%p)\n", mem);
448 mem = realloc(mem, 10);
449 ok(mem != NULL, "realloc failed\n");
450 ok(!((UINT_PTR)mem & 0xf), "incorrect alignment (%p)\n", mem);
452 ok(_set_sbh_threshold(0), "_set_sbh_threshold failed\n");
453 threshold = _get_sbh_threshold();
454 ok(threshold == 0, "threshold = %d\n", threshold);
456 free(mem);
459 static void test_calloc(void)
461 void *ptr;
463 ptr = calloc(1, 0);
464 ok(ptr != NULL, "got %p\n", ptr);
465 free(ptr);
467 ptr = calloc(0, 0);
468 ok(ptr != NULL, "got %p\n", ptr);
469 free(ptr);
471 ptr = calloc(0, 1);
472 ok(ptr != NULL, "got %p\n", ptr);
473 free(ptr);
475 errno = 0;
476 ptr = calloc(~(size_t)0 / 2, ~(size_t)0 / 2);
477 ok(ptr == NULL || broken(ptr != NULL) /* winxp sp0 */, "got %p\n", ptr);
478 ok(errno == ENOMEM || broken(errno == 0) /* winxp, win2k3 */, "got errno %d\n", errno);
479 free(ptr);
482 START_TEST(heap)
484 void *mem;
486 mem = malloc(0);
487 ok(mem != NULL, "memory not allocated for size 0\n");
488 free(mem);
490 mem = realloc(NULL, 10);
491 ok(mem != NULL, "memory not allocated\n");
493 mem = realloc(mem, 20);
494 ok(mem != NULL, "memory not reallocated\n");
496 mem = realloc(mem, 0);
497 ok(mem == NULL, "memory not freed\n");
499 mem = realloc(NULL, 0);
500 ok(mem != NULL, "memory not (re)allocated for size 0\n");
502 free(mem);
504 test_aligned();
505 test_sbheap();
506 test_calloc();