ReactOS  0.4.13-dev-563-g0561610
heap.c
Go to the documentation of this file.
1 /*
2  * Unit test suite for memory functions
3  *
4  * Copyright 2003 Dimitrie O. Paun
5  *
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.
10  *
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.
15  *
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
19  */
20 
21 #include <stdlib.h>
22 #include <malloc.h>
23 #include <errno.h>
24 #include "wine/test.h"
25 
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;
31 
32 static void test_aligned_malloc(unsigned int size, unsigned int alignment)
33 {
34  void *mem;
35 
36  mem = p_aligned_malloc(size, alignment);
37 
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);
42 
43  if (mem)
44  {
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)
48  {
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 );
52  }
53  p_aligned_free(mem);
54  }
55  else
56  ok(errno == EINVAL, "_aligned_malloc(%d, %d) errno: %d != %d\n", size, alignment, errno, EINVAL);
57 }
58 
59 static void test_aligned_offset_malloc(unsigned int size, unsigned int alignment, unsigned int offset)
60 {
61  void *mem;
62 
63  mem = p_aligned_offset_malloc(size, alignment, offset);
64 
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);
72 
73  if (mem)
74  {
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)
78  {
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);
83  }
84  p_aligned_free(mem);
85  }
86  else
87  ok(errno == EINVAL, "_aligned_offset_malloc(%d, %d, %d) errno: %d != %d\n", size, alignment, offset, errno, EINVAL);
88 }
89 
90 static void test_aligned_realloc(unsigned int size1, unsigned int size2, unsigned int alignment)
91 {
92  void *mem, *mem1, *mem2;
93 
94  mem = p_aligned_malloc(size1, alignment);
95 
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);
100 
101  if (mem)
102  {
103  mem1 = malloc(size1);
104  if (mem1)
105  {
106  unsigned int i;
107  for (i = 0; i < size1; i++)
108  ((char *)mem)[i] = i + 1;
109  memcpy(mem1, mem, size1);
110  }
111 
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)
115  {
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);
119  }
120 
121  mem2 = p_aligned_realloc(mem, size2, alignment);
122 
123  ok(mem2 != NULL, "_aligned_realloc(%p, %d, %d) failed\n", mem, size2, alignment);
124 
125  if (mem2)
126  {
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)
130  {
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);
135  }
136  if (mem1)
137  {
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)
140  {
141  unsigned int i;
142  for (i = 0; i < min(size1, size2); i++)
143  {
144  if (((char *)mem2)[i] != ((char *)mem1)[i])
145  trace("%d: %02x != %02x\n", i, ((char *)mem2)[i] & 0xff, ((char *)mem1)[i] & 0xff);
146  }
147  }
148  }
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);
153  }
154 
155  free(mem1);
156  }
157  else
158  ok(errno == EINVAL, "_aligned_malloc(%d, %d) errno: %d != %d\n", size1, alignment, errno, EINVAL);
159 }
160 
161 static void test_aligned_offset_realloc(unsigned int size1, unsigned int size2,
162  unsigned int alignment, unsigned int offset)
163 {
164  void *mem, *mem1, *mem2;
165 
166  mem = p_aligned_offset_malloc(size1, alignment, offset);
167 
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);
172 
173  if (mem)
174  {
175  mem1 = malloc(size1);
176  if (mem1)
177  {
178  unsigned int i;
179  for (i = 0; i < size1; i++)
180  ((char *)mem)[i] = i + 1;
181  memcpy(mem1, mem, size1);
182  }
183 
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)
187  {
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);
192  }
193 
194  mem2 = p_aligned_offset_realloc(mem, size2, alignment, offset);
195 
196  ok(mem2 != NULL, "_aligned_offset_realloc(%p, %d, %d, %d) failed\n", mem, size2, alignment, offset);
197 
198  if (mem2)
199  {
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)
203  {
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);
208  }
209  if (mem1)
210  {
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)
213  {
214  unsigned int i;
215  for (i = 0; i < min(size1, size2); i++)
216  {
217  if (((char *)mem2)[i] != ((char *)mem1)[i])
218  trace("%d: %02x != %02x\n", i, ((char *)mem2)[i] & 0xff, ((char *)mem1)[i] & 0xff);
219  }
220  }
221  }
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);
226  }
227 
228  free(mem1);
229  }
230  else
231  ok(errno == EINVAL, "_aligned_offset_malloc(%d, %d) errno: %d != %d\n", size1, alignment, errno, EINVAL);
232 }
233 
234 static void test_aligned(void)
235 {
236  HMODULE msvcrt = GetModuleHandleA("msvcrt.dll");
237 
238  if (msvcrt == NULL)
239  return;
240 
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");
246 
248  {
249  skip("aligned memory tests skipped\n");
250  return;
251  }
252 
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);
264 
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);
276 
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);
288 
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);
297 
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);
310 
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);
323 
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);
336 
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);
349 
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);
362 
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);
375 
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);
388 
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);
401 
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);
414 }
415 
416 static void test_sbheap(void)
417 {
418  void *mem;
419  int threshold;
420 
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;
425  }
426 
427  mem = malloc(1);
428  ok(mem != NULL, "malloc failed\n");
429 
430  ok(_set_sbh_threshold(1), "_set_sbh_threshold failed\n");
431  threshold = _get_sbh_threshold();
432  ok(threshold == 16, "threshold = %d\n", threshold);
433 
434  ok(_set_sbh_threshold(8), "_set_sbh_threshold failed\n");
435  threshold = _get_sbh_threshold();
436  ok(threshold == 16, "threshold = %d\n", threshold);
437 
438  ok(_set_sbh_threshold(1000), "_set_sbh_threshold failed\n");
439  threshold = _get_sbh_threshold();
440  ok(threshold == 1008, "threshold = %d\n", threshold);
441 
442  free(mem);
443 
444  mem = malloc(1);
445  ok(mem != NULL, "malloc failed\n");
446  ok(!((UINT_PTR)mem & 0xf), "incorrect alignment (%p)\n", mem);
447 
448  mem = realloc(mem, 10);
449  ok(mem != NULL, "realloc failed\n");
450  ok(!((UINT_PTR)mem & 0xf), "incorrect alignment (%p)\n", mem);
451 
452  ok(_set_sbh_threshold(0), "_set_sbh_threshold failed\n");
453  threshold = _get_sbh_threshold();
454  ok(threshold == 0, "threshold = %d\n", threshold);
455 
456  free(mem);
457 }
458 
459 static void test_calloc(void)
460 {
461  void *ptr;
462 
463  ptr = calloc(1, 0);
464  ok(ptr != NULL, "got %p\n", ptr);
465  free(ptr);
466 
467  ptr = calloc(0, 0);
468  ok(ptr != NULL, "got %p\n", ptr);
469  free(ptr);
470 
471  ptr = calloc(0, 1);
472  ok(ptr != NULL, "got %p\n", ptr);
473  free(ptr);
474 
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);
480 }
481 
483 {
484  void *mem;
485 
486  mem = malloc(0);
487  ok(mem != NULL, "memory not allocated for size 0\n");
488  free(mem);
489 
490  mem = realloc(NULL, 10);
491  ok(mem != NULL, "memory not allocated\n");
492 
493  mem = realloc(mem, 20);
494  ok(mem != NULL, "memory not reallocated\n");
495 
496  mem = realloc(mem, 0);
497  ok(mem == NULL, "memory not freed\n");
498 
499  mem = realloc(NULL, 0);
500  ok(mem != NULL, "memory not (re)allocated for size 0\n");
501 
502  free(mem);
503 
504  test_aligned();
505  test_sbheap();
506  test_calloc();
507 }
void CDECL free(void *ptr)
Definition: heap.c:299
#define trace(...)
Definition: kmt_test.h:217
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define __cdecl
Definition: accygwin.h:79
Definition: arc.h:39
GLintptr offset
Definition: glext.h:5920
void *CDECL realloc(void *ptr, size_t size)
Definition: heap.c:319
int errno
int winetest_debug
Definition: arc.h:48
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
void *CDECL malloc(size_t size)
Definition: heap.c:308
static void test_calloc(void)
Definition: heap.c:459
static void test_aligned_realloc(unsigned int size1, unsigned int size2, unsigned int alignment)
Definition: heap.c:90
static PVOID ptr
Definition: dispmode.c:27
#define ok(value,...)
smooth NULL
Definition: ftsmooth.c:416
static void *__cdecl * p_aligned_malloc(size_t, size_t)
static void test_sbheap(void)
Definition: heap.c:416
GLsizeiptr size
Definition: glext.h:5919
static void(__cdecl *p_aligned_free)(void *)
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:819
static void test_aligned_offset_realloc(unsigned int size1, unsigned int size2, unsigned int alignment, unsigned int offset)
Definition: heap.c:161
uint32_t DWORD_PTR
Definition: typedefs.h:63
#define broken(x)
Definition: _sntprintf.h:21
size_t CDECL _get_sbh_threshold(void)
Definition: heap.c:338
static void *__cdecl * p_aligned_offset_malloc(size_t, size_t, size_t)
int CDECL _set_sbh_threshold(size_t threshold)
Definition: heap.c:346
static void *__cdecl * p_aligned_offset_realloc(void *, size_t, size_t, size_t)
static void test_aligned_malloc(unsigned int size, unsigned int alignment)
Definition: heap.c:32
#define min(a, b)
Definition: monoChain.cc:55
void *CDECL calloc(size_t count, size_t size)
Definition: heap.c:291
#define skip(...)
START_TEST(heap)
Definition: heap.c:1219
Definition: mem.c:156
#define GetProcAddress(x, y)
Definition: compat.h:410
static void test_aligned_offset_malloc(unsigned int size, unsigned int alignment, unsigned int offset)
Definition: heap.c:59
static void *__cdecl * p_aligned_realloc(void *, size_t, size_t)
static void test_aligned(void)
Definition: heap.c:234