ntdll,server: Fixed access checks for OpenFileMapping and MapViewOfFile.
[wine] / dlls / kernel32 / tests / alloc.c
1 /*
2  * Unit test suite for memory allocation functions.
3  *
4  * Copyright 2002 Geoffrey Hausheer
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 <stdarg.h>
22
23 #include "wine/test.h"
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winerror.h"
27
28
29  /* The following functions don't have tests, because either I don't know how
30    to test them, or they are WinNT only, or require multiple threads.
31    Since the last two issues shouldn't really stop the tests from being
32    written, assume for now that it is all due to the first case
33        HeapCompact
34        HeapLock
35        HeapQueryInformation
36        HeapSetInformation
37        HeapUnlock
38        HeapValidate
39        HeapWalk
40 */
41 /* In addition, these features aren't being tested
42        HEAP_NO_SERIALIZE
43        HEAP_GENERATE_EXCEPTIONS
44        STATUS_ACCESS_VIOLATION (error code from HeapAlloc)
45 */
46
47 static void test_Heap(void)
48 {
49     SYSTEM_INFO sysInfo;
50     ULONG memchunk;
51     HANDLE heap;
52     LPVOID mem1,mem1a,mem3;
53     UCHAR *mem2,*mem2a;
54     UINT error,i;
55     DWORD dwSize;
56
57 /* Retrieve the page size for this system */
58     sysInfo.dwPageSize=0;
59     GetSystemInfo(&sysInfo);
60     ok(sysInfo.dwPageSize>0,"GetSystemInfo should return a valid page size\n");
61
62 /* Create a Heap with a minimum and maximum size */
63 /* Note that Windows and Wine seem to behave a bit differently with respect
64    to memory allocation.  In Windows, you can't access all the memory
65    specified in the heap (due to overhead), so choosing a reasonable maximum
66    size for the heap was done mostly by trial-and-error on Win2k.  It may need
67    more tweaking for otherWindows variants.
68 */
69     memchunk=10*sysInfo.dwPageSize;
70     heap=HeapCreate(0,2*memchunk,5*memchunk);
71
72 /* Check that HeapCreate allocated the right amount of ram */
73     todo_wine {
74     /* Today HeapCreate seems to return a memory block larger than specified.
75        MSDN says the maximum heap size should be dwMaximumSize rounded up to the
76        nearest page boundary
77     */
78       mem1=HeapAlloc(heap,0,5*memchunk+1);
79       ok(mem1==NULL,"HeapCreate allocated more Ram than it should have\n");
80       HeapFree(heap,0,mem1);
81     }
82
83 /* Check that a normal alloc works */
84     mem1=HeapAlloc(heap,0,memchunk);
85     ok(mem1!=NULL,"HeapAlloc failed\n");
86     if(mem1) {
87       ok(HeapSize(heap,0,mem1)>=memchunk, "HeapAlloc should return a big enough memory block\n");
88     }
89
90 /* Check that a 'zeroing' alloc works */
91     mem2=HeapAlloc(heap,HEAP_ZERO_MEMORY,memchunk);
92     ok(mem2!=NULL,"HeapAlloc failed\n");
93     if(mem2) {
94       ok(HeapSize(heap,0,mem2)>=memchunk,"HeapAlloc should return a big enough memory block\n");
95       error=0;
96       for(i=0;i<memchunk;i++) {
97         if(mem2[i]!=0) {
98           error=1;
99         }
100       }
101       ok(!error,"HeapAlloc should have zeroed out it's allocated memory\n");
102     }
103
104 /* Check that HeapAlloc returns NULL when requested way too much memory */
105     mem3=HeapAlloc(heap,0,5*memchunk);
106     ok(mem3==NULL,"HeapAlloc should return NULL\n");
107     if(mem3) {
108       ok(HeapFree(heap,0,mem3),"HeapFree didn't pass successfully\n");
109     }
110
111 /* Check that HeapRealloc works */
112     mem2a=HeapReAlloc(heap,HEAP_ZERO_MEMORY,mem2,memchunk+5*sysInfo.dwPageSize);
113     ok(mem2a!=NULL,"HeapReAlloc failed\n");
114     if(mem2a) {
115       ok(HeapSize(heap,0,mem2a)>=memchunk+5*sysInfo.dwPageSize,"HeapReAlloc failed\n");
116       error=0;
117       for(i=0;i<5*sysInfo.dwPageSize;i++) {
118         if(mem2a[memchunk+i]!=0) {
119           error=1;
120         }
121       }
122       ok(!error,"HeapReAlloc should have zeroed out it's allocated memory\n");
123     }
124
125 /* Check that HeapRealloc honours HEAP_REALLOC_IN_PLACE_ONLY */
126     error=0;
127     mem1a=HeapReAlloc(heap,HEAP_REALLOC_IN_PLACE_ONLY,mem1,memchunk+sysInfo.dwPageSize);
128     if(mem1a!=NULL) {
129       if(mem1a!=mem1) {
130         error=1;
131       }
132     }
133     ok(mem1a==NULL || error==0,"HeapReAlloc didn't honour HEAP_REALLOC_IN_PLACE_ONLY\n");
134
135 /* Check that HeapFree works correctly */
136    if(mem1a) {
137      ok(HeapFree(heap,0,mem1a),"HeapFree failed\n");
138    } else {
139      ok(HeapFree(heap,0,mem1),"HeapFree failed\n");
140    }
141    if(mem2a) {
142      ok(HeapFree(heap,0,mem2a),"HeapFree failed\n");
143    } else {
144      ok(HeapFree(heap,0,mem2),"HeapFree failed\n");
145    }
146
147    /* 0-length buffer */
148    mem1 = HeapAlloc(heap, 0, 0);
149    ok(mem1 != NULL, "Reserved memory\n");
150
151    dwSize = HeapSize(heap, 0, mem1);
152    /* should work with 0-length buffer */
153    ok(dwSize < 0xFFFFFFFF, "The size of the 0-length buffer\n");
154    ok(HeapFree(heap, 0, mem1), "Freed the 0-length buffer\n");
155
156 /* Check that HeapDestry works */
157    ok(HeapDestroy(heap),"HeapDestroy failed\n");
158 }
159
160 /* The following functions don't have tests, because either I don't know how
161    to test them, or they are WinNT only, or require multiple threads.
162    Since the last two issues shouldn't really stop the tests from being
163    written, assume for now that it is all due to the first case
164        GlobalFlags
165        GlobalMemoryStatus
166        GlobalMemoryStatusEx
167 */
168 /* In addition, these features aren't being tested
169        GMEM_DISCARDABLE
170        GMEM_NOCOMPACT
171 */
172 static void test_Global(void)
173 {
174     ULONG memchunk;
175     HGLOBAL mem1,mem2,mem2a,mem2b;
176     UCHAR *mem2ptr;
177     UINT error,i;
178     memchunk=100000;
179
180     SetLastError(NO_ERROR);
181 /* Check that a normal alloc works */
182     mem1=GlobalAlloc(0,memchunk);
183     ok(mem1!=NULL,"GlobalAlloc failed\n");
184     if(mem1) {
185       ok(GlobalSize(mem1)>=memchunk, "GlobalAlloc should return a big enough memory block\n");
186     }
187
188 /* Check that a 'zeroing' alloc works */
189     mem2=GlobalAlloc(GMEM_ZEROINIT,memchunk);
190     ok(mem2!=NULL,"GlobalAlloc failed: error=%d\n",GetLastError());
191     if(mem2) {
192       ok(GlobalSize(mem2)>=memchunk,"GlobalAlloc should return a big enough memory block\n");
193       mem2ptr=GlobalLock(mem2);
194       ok(mem2ptr==mem2,"GlobalLock should have returned the same memory as was allocated\n");
195       if(mem2ptr) {
196         error=0;
197         for(i=0;i<memchunk;i++) {
198           if(mem2ptr[i]!=0) {
199             error=1;
200           }
201         }
202         ok(!error,"GlobalAlloc should have zeroed out it's allocated memory\n");
203       }
204    }
205 /* Check that GlobalReAlloc works */
206 /* Check that we can change GMEM_FIXED to GMEM_MOVEABLE */
207     mem2a=GlobalReAlloc(mem2,0,GMEM_MODIFY | GMEM_MOVEABLE);
208     if(mem2a!=NULL) {
209       mem2=mem2a;
210       mem2ptr=GlobalLock(mem2a);
211       ok(mem2ptr!=NULL && !GlobalUnlock(mem2a)&&GetLastError()==NO_ERROR,
212          "Converting from FIXED to MOVEABLE didn't REALLY work\n");
213     }
214
215 /* Check that ReAllocing memory works as expected */
216     mem2a=GlobalReAlloc(mem2,2*memchunk,GMEM_MOVEABLE | GMEM_ZEROINIT);
217     ok(mem2a!=NULL,"GlobalReAlloc failed\n");
218     if(mem2a) {
219       ok(GlobalSize(mem2a)>=2*memchunk,"GlobalReAlloc failed\n");
220       mem2ptr=GlobalLock(mem2a);
221       ok(mem2ptr!=NULL,"GlobalLock Failed\n");
222       if(mem2ptr) {
223         error=0;
224         for(i=0;i<memchunk;i++) {
225           if(mem2ptr[memchunk+i]!=0) {
226             error=1;
227           }
228         }
229         ok(!error,"GlobalReAlloc should have zeroed out it's allocated memory\n");
230
231 /* Check that GlobalHandle works */
232         mem2b=GlobalHandle(mem2ptr);
233         ok(mem2b==mem2a,"GlobalHandle didn't return the correct memory handle\n");
234
235 /* Check that we can't discard locked memory */
236         mem2b=GlobalDiscard(mem2a);
237         if(mem2b==NULL) {
238           ok(!GlobalUnlock(mem2a) && GetLastError()==NO_ERROR,"GlobalUnlock Failed\n");
239         }
240       }
241     }
242     if(mem1) {
243       ok(GlobalFree(mem1)==NULL,"GlobalFree failed\n");
244     }
245     if(mem2a) {
246       ok(GlobalFree(mem2a)==NULL,"GlobalFree failed\n");
247     } else {
248       ok(GlobalFree(mem2)==NULL,"GlobalFree failed\n");
249     }
250 }
251
252
253 /* The following functions don't have tests, because either I don't know how
254    to test them, or they are WinNT only, or require multiple threads.
255    Since the last two issues shouldn't really stop the tests from being
256    written, assume for now that it is all due to the first case
257        LocalDiscard
258        LocalFlags
259 */
260 /* In addition, these features aren't being tested
261        LMEM_DISCARDABLE
262        LMEM_NOCOMPACT
263 */
264 static void test_Local(void)
265 {
266     ULONG memchunk;
267     HLOCAL mem1,mem2,mem2a,mem2b;
268     UCHAR *mem2ptr;
269     UINT error,i;
270     memchunk=100000;
271
272 /* Check that a normal alloc works */
273     mem1=LocalAlloc(0,memchunk);
274     ok(mem1!=NULL,"LocalAlloc failed: error=%d\n",GetLastError());
275     if(mem1) {
276       ok(LocalSize(mem1)>=memchunk, "LocalAlloc should return a big enough memory block\n");
277     }
278
279 /* Check that a 'zeroing' and lock alloc works */
280     mem2=LocalAlloc(LMEM_ZEROINIT|LMEM_MOVEABLE,memchunk);
281     ok(mem2!=NULL,"LocalAlloc failed: error=%d\n",GetLastError());
282     if(mem2) {
283       ok(LocalSize(mem2)>=memchunk,"LocalAlloc should return a big enough memory block\n");
284       mem2ptr=LocalLock(mem2);
285       ok(mem2ptr!=NULL,"LocalLock: error=%d\n",GetLastError());
286       if(mem2ptr) {
287         error=0;
288         for(i=0;i<memchunk;i++) {
289           if(mem2ptr[i]!=0) {
290             error=1;
291           }
292         }
293         ok(!error,"LocalAlloc should have zeroed out it's allocated memory\n");
294         SetLastError(0);
295         error=LocalUnlock(mem2);
296         ok(error==0 && GetLastError()==NO_ERROR,
297            "LocalUnlock Failed: rc=%d err=%d\n",error,GetLastError());
298       }
299     }
300    mem2a=LocalFree(mem2);
301    ok(mem2a==NULL, "LocalFree failed: %p\n",mem2a);
302
303 /* Reallocate mem2 as moveable memory */
304    mem2=LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT,memchunk);
305    ok(mem2!=NULL, "LocalAlloc failed to create moveable memory, error=%d\n",GetLastError());
306
307 /* Check that ReAllocing memory works as expected */
308     mem2a=LocalReAlloc(mem2,2*memchunk,LMEM_MOVEABLE | LMEM_ZEROINIT);
309     ok(mem2a!=NULL,"LocalReAlloc failed, error=%d\n",GetLastError());
310     if(mem2a) {
311       ok(LocalSize(mem2a)>=2*memchunk,"LocalReAlloc failed\n");
312       mem2ptr=LocalLock(mem2a);
313       ok(mem2ptr!=NULL,"LocalLock Failed\n");
314       if(mem2ptr) {
315         error=0;
316         for(i=0;i<memchunk;i++) {
317           if(mem2ptr[memchunk+i]!=0) {
318             error=1;
319           }
320         }
321         ok(!error,"LocalReAlloc should have zeroed out it's allocated memory\n");
322 /* Check that LocalHandle works */
323         mem2b=LocalHandle(mem2ptr);
324         ok(mem2b==mem2a,"LocalHandle didn't return the correct memory handle\n");
325 /* Check that we can't discard locked memory */
326         mem2b=LocalDiscard(mem2a);
327         ok(mem2b==NULL,"Discarded memory we shouldn't have\n");
328         SetLastError(NO_ERROR);
329         ok(!LocalUnlock(mem2a) && GetLastError()==NO_ERROR, "LocalUnlock Failed\n");
330       }
331     }
332     if(mem1) {
333       ok(LocalFree(mem1)==NULL,"LocalFree failed\n");
334     }
335     if(mem2a) {
336       ok(LocalFree(mem2a)==NULL,"LocalFree failed\n");
337     } else {
338       ok(LocalFree(mem2)==NULL,"LocalFree failed\n");
339     }
340 }
341
342 /* The Virtual* routines are not tested as thoroughly,
343    since I don't really understand how to use them correctly :)
344    The following routines are not tested at all
345       VirtualAllocEx
346       VirtualFreeEx
347       VirtualLock
348       VirtualProtect
349       VirtualProtectEx
350       VirtualQuery
351       VirtualQueryEx
352       VirtualUnlock
353     And the only features (flags) being tested are
354       MEM_COMMIT
355       MEM_RELEASE
356       PAGE_READWRITE
357     Testing the rest requires using exceptions, which I really don't
358     understand well
359 */
360 static void test_Virtual(void)
361 {
362     SYSTEM_INFO sysInfo;
363     ULONG memchunk;
364     UCHAR *mem1;
365     UINT error,i;
366
367 /* Retrieve the page size for this system */
368     sysInfo.dwPageSize=0;
369     GetSystemInfo(&sysInfo);
370     ok(sysInfo.dwPageSize>0,"GetSystemInfo should return a valid page size\n");
371
372 /* Choose a reasonable allocation size */
373     memchunk=10*sysInfo.dwPageSize;
374
375 /* Check that a normal alloc works */
376     mem1=VirtualAlloc(NULL,memchunk,MEM_COMMIT,PAGE_READWRITE);
377     ok(mem1!=NULL,"VirtualAlloc failed\n");
378     if(mem1) {
379 /* check that memory is initialized to 0 */
380       error=0;
381       for(i=0;i<memchunk;i++) {
382         if(mem1[i]!=0) {
383           error=1;
384         }
385       }
386       ok(!error,"VirtualAlloc did not initialize memory to '0's\n");
387 /* Check that we can read/write to memory */
388       error=0;
389       for(i=0;i<memchunk;i+=100) {
390         mem1[i]='a';
391         if(mem1[i]!='a') {
392           error=1;
393         }
394       }
395       ok(!error,"Virtual memory was not writable\n");
396     }
397     ok(VirtualFree(mem1,0,MEM_RELEASE),"VirtualFree failed\n");
398 }
399 START_TEST(alloc)
400 {
401     test_Heap();
402     test_Global();
403     test_Local();
404     test_Virtual();
405 }