ReactOS  0.4.14-dev-50-g13bb5e2
global_mem.c
Go to the documentation of this file.
1 /* File: global_mem.c
2 **
3 ** This program is a test application used for testing correctness of the
4 ** GlobalXXX memory API implementation.
5 **
6 ** Programmer: Mark Tempel
7 */
8 #include <windows.h>
9 #include <stdio.h>
10 #include <string.h>
11 
12 /*
13 ** All output is line wrapped to fit a 80 column screen.
14 ** these defines control that formatting. To shrink the
15 ** screen columns, just change the DISPLAY_COMUMNS macro.
16 */
17 #define DISPLAY_COLUMNS 78
18 #define LINE_BUFFER_SIZE DISPLAY_COLUMNS + 2
19 
20 /*
21 ** This define controls the size of a memory allocation request.
22 ** For this test suite to really be comprehensive, we should
23 ** probably be testing many different block sizes.
24 */
25 #define MEM_BLOCK_SIZE 0x80000
26 
27 /*
28 ** This enumeration is really the return value for the program.
29 ** All test return a TestStatus and test statuses can be combined
30 ** with the relation TEST_CombineStatus.
31 */
32 typedef enum TestStatus
33 {
34  FAILED = 0,
35  PASSED = 1,
36  SKIPPED = -1
37 } TEST_STATUS;
38 
39 /*---------------------------------------------------------------------------
40 ** This is a relation used to combine two test statuses.
41 ** The combine rules are as follows:
42 ** FAIL & Anything == FAIL
43 ** SKIPPED & Anything == Anything
44 **
45 */
47 {
49 
50  switch (a)
51  {
52  case PASSED: result = (PASSED == b || SKIPPED == b) ? (PASSED) : (FAILED); break;
53  case FAILED: result = FAILED; break;
54  case SKIPPED: result = b; break;
55  }
56 
57  return result;
58 }
59 
60 /*---------------------------------------------------------------------------
61 ** This outputs the banner border lines.
62 */
64 {
65  int c = 0;
66  printf("+");
67  for (c = 1; c < DISPLAY_COLUMNS; c++)
68  {
69  printf("-");
70  }
71  printf("\n");
72 }
73 
74 
75 /*---------------------------------------------------------------------------
76 ** This method prints a line that has a | on the left, and is line wrapped
77 ** to be no more that DISPLAY_COLUMNS +2 wide.
78 */
79 void OUTPUT_Line(const char *szLine)
80 {
81  int spaceIndex = 0;
83 
84  memset(output, 0, DISPLAY_COLUMNS + 2);
85 
86  /*If this line is longer than DISPLAY_COLUMNS,
87  * break it at the first space.
88  */
89  if (DISPLAY_COLUMNS - 2 < strlen(szLine))
90  {
91  for (spaceIndex = DISPLAY_COLUMNS / 2; spaceIndex < DISPLAY_COLUMNS - 2; spaceIndex++)
92  {
93  if (' ' == szLine[spaceIndex])
94  {
95  break;
96  }
97  }
98 
99  memcpy(output + 2, szLine, spaceIndex + 1);
100  output[0] = '|';
101  output[1] = ' ';
102  output[strlen(output)] = '\n';
103  printf(output);
104 
105  OUTPUT_Line(szLine + spaceIndex + 1);
106  }
107  else
108  {
109  sprintf(output,"| %s\n", szLine);
110  printf(output);
111  }
112 
113 }
114 
115 /*---------------------------------------------------------------------------
116 **
117 */
118 void OUTPUT_Banner(const char *szBanner)
119 {
121  OUTPUT_Line(szBanner);
123 }
124 
125 /*---------------------------------------------------------------------------
126 **
127 */
129 {
130  switch (status)
131  {
132  case PASSED: OUTPUT_Line("==> PASSED"); break;
133  case FAILED: OUTPUT_Line("*** FAILED"); break;
134  case SKIPPED: OUTPUT_Line("==> SKIPPED"); break;
135  }
136  OUTPUT_Line("");
137 }
138 
139 /*---------------------------------------------------------------------------
140 **
141 */
143 {
144  char buffer[32];
145  sprintf(buffer, "0x%lX",dw);
147 }
148 
150 {
151  char buffer[32];
152  sprintf(buffer, "0x%p", h);
154 }
155 
156 /*---------------------------------------------------------------------------
157 **
158 */
159 void OutputAllocFlags(UINT pFlags)
160 {
161  if (pFlags & GMEM_MOVEABLE)
162  {
163  OUTPUT_Line("Movable Memory");
164  }
165  else
166  {
167  OUTPUT_Line("Fixed Memory");
168  }
169 
170  if (pFlags & GMEM_ZEROINIT)
171  {
172  OUTPUT_Line("Zero Initialized Memory");
173  }
174 }
175 
176 /*---------------------------------------------------------------------------
177 **
178 */
180 {
181  char buffer[256];
182 
183  sprintf(buffer,"GetLastError() returned %lu", GetLastError());
184 
186 }
187 /*---------------------------------------------------------------------------
188 **
189 */
191 {
193 
194  if (0 == IsBadWritePtr(mem, cbSize))
195  {
196  result = PASSED;
197  }
198  return result;
199 }
200 
201 /*---------------------------------------------------------------------------
202 **
203 */
205 {
207 
208  if (0 == IsBadReadPtr(mem, cbSize))
209  {
210  result = PASSED;
211  }
212  return result;
213 }
214 
215 /*---------------------------------------------------------------------------
216 ** This method tests to see if a block of global memory is movable
217 ** by seeing if the value returned from GlobalLock is different from
218 ** the passed in value.
219 */
221 {
222  LPVOID pMem = 0;
223  int rc = 0;
224 
225  pMem = GlobalLock(hMem);
226  if (pMem != hMem)
227  {
228  rc = 1;
229  }
230  GlobalUnlock(hMem);
231 
232  return rc;
233 }
234 
235 /*---------------------------------------------------------------------------
236 **
237 */
239 {
241  HGLOBAL hTest = 0;
242  OUTPUT_Banner("Testing the GlobalAlloc and GlobalFree calls");
243  OUTPUT_Line("Allocate a buffer");
244 
245  OutputAllocFlags(allocFlags);
246 
247  status = FAILED;
248  hTest = GlobalAlloc(allocFlags, MEM_BLOCK_SIZE);
249  if (0 != hTest)
250  {
251  if (0 == GlobalFree(hTest))
252  {
253  status = PASSED;
254  }
255  }
256 
257  OUTPUT_Line("Result for this run:");
259  OUTPUT_Line("");
260 
261  return status;
262 }
263 
264 /*---------------------------------------------------------------------------
265 **
266 */
268 {
269  HGLOBAL hMem = 0;
270  LPVOID pMem = 0;
273 
274  OUTPUT_Banner("Testing the GlobalLock/Unlock functions.");
275  OutputAllocFlags(allocFlags);
276  OUTPUT_Line("");
277 
278  hMem = GlobalAlloc(allocFlags, MEM_BLOCK_SIZE);
279  if (0 != hMem)
280  {
281  OUTPUT_Line("Allocated a memory block");
282 
283  OUTPUT_Line("Testing Lock");
284  pMem = GlobalLock(hMem);
285  if (0 != pMem)
286  {
288 
289  OUTPUT_Line("Testing memory for read.");
293 
294 
295  OUTPUT_Line("Testing memory for write.");
299 
300 
301  OUTPUT_Line("Unlocking memory");
302  if (GlobalUnlock(hMem))
303  {
306  }
307  else
308  {
309  if (NO_ERROR == GetLastError())
310  {
313  }
314  else
315  {
316  OutputErrorCode();
319  }
320  }
321  }
322 
323  OUTPUT_Line("Freeing memory");
324  if (0 == GlobalFree(hMem))
325  {
328  }
329  else
330  {
331  OutputErrorCode();
334  }
335  }
336  return result;
337 }
338 
339 /*---------------------------------------------------------------------------
340 **
341 */
343 {
344  HGLOBAL hMem = 0;
345  HGLOBAL hReAlloced = 0;
346  LPVOID pMem = 0;
349 
350  OUTPUT_Line("Testing GlobalReAlloc() on memory allocated as GMEM_FIXED");
351 
352  /* Case 1: convert a fixed block to a movable block. */
353  OUTPUT_Line("Allocating buffer");
355  if (0 != hMem)
356  {
357  OUTPUT_Line("Testing to see if this is converted into a movable block");
358  hReAlloced = GlobalReAlloc(hMem, MEM_BLOCK_SIZE + 100, GMEM_MOVEABLE | GMEM_MODIFY);
359  if (0 == hReAlloced)
360  {
361  OUTPUT_Line("GlobalReAlloc failed-- returned NULL");
364  }
365  else
366  {
367  hMem = hReAlloced;
368  if (0 == IsMovable(hMem))
369  {
370  OUTPUT_Line("GlobalReAlloc returned a fixed pointer.");
373  }
374  else
375  {
376  pMem = GlobalLock(hMem);
379  if (FAILED == subtest)
380  {
381  OUTPUT_Line("Memory Read failed.");
382  }
384  if (FAILED == subtest)
385  {
386  OUTPUT_Line("Memory Write failed.");
387  }
388  GlobalUnlock(hMem);
389  }
390  }
391 
392  GlobalFree(hMem);
393  }
394  else
395  {
396  OUTPUT_Line("Global Alloc Failed.");
398  }
399  OUTPUT_Line("Subtest result:");
401  OUTPUT_Line("");
402 
404  subtest = SKIPPED;
405 
406  /* case 2 only move a fixed block */
407  OUTPUT_Line("Allocating buffer");
409  if (0 != hMem)
410  {
411  OUTPUT_Line("Testing to see if a new fixed block is returned.");
412  hReAlloced = GlobalReAlloc(hMem, MEM_BLOCK_SIZE - 100, GMEM_MOVEABLE);
413  if (0 == hReAlloced)
414  {
415  OUTPUT_Line("GlobalReAlloc failed-- returned NULL");
418  }
419  else
420  {
421  OUTPUT_Line("Alloced Handle: ");
422  OUTPUT_Handle(hMem);
423  OUTPUT_Line("ReAlloced Handle: ");
424  OUTPUT_Handle(hReAlloced);
425  if (hMem == hReAlloced)
426  {
427  OUTPUT_Line("GlobalReAlloc returned the same pointer. The documentation states that this is wrong, but Windows NT works this way.");
428  }
429 
430  hMem = hReAlloced;
434  }
435 
436  GlobalFree(hMem);
437  }
438  else
439  {
441  }
442  OUTPUT_Line("Subtest result:");
444  OUTPUT_Line("");
445 
447  subtest = SKIPPED;
448 
449  /* Case 3: re-allocate a fixed block in place */
450  OUTPUT_Line("Allocating buffer");
452  if (0 != hMem)
453  {
454  OUTPUT_Line("Testing to see if a fixed pointer is reallocated in place.");
455  hReAlloced = GlobalReAlloc(hMem, MEM_BLOCK_SIZE - 100, 0);
456  if (0 == hReAlloced)
457  {
458  OUTPUT_Line("GlobalReAlloc failed-- returned NULL");
461  }
462  else
463  {
464  OUTPUT_Line("Alloced Handle: ");
465  OUTPUT_Handle(hMem);
466  OUTPUT_Line("ReAlloced Handle: ");
467  OUTPUT_Handle(hReAlloced);
468  if (hMem != hReAlloced)
469  {
470  OUTPUT_Line("GlobalReAlloc returned a different.");
473  }
474  else
475  {
479  }
480  }
481 
482  GlobalFree(hMem);
483  }
484  else
485  {
487  }
488  OUTPUT_Line("Subtest result:");
490  OUTPUT_Line("");
491 
493 
494  OUTPUT_Line("");
495  return result;
496 }
497 /*---------------------------------------------------------------------------
498 **
499 */
501 {
502  HGLOBAL hMem = 0;
503  HGLOBAL hReAlloced = 0;
504  LPVOID pMem = 0;
507 
508  OUTPUT_Line("Testing GlobalReAlloc() on memory allocated as GMGM_MOVEABLE");
509 
510  /* case 1 test reallocing a movable block that is unlocked. */
511  OUTPUT_Line("Allocating buffer");
513  if (0 != hMem)
514  {
515  OUTPUT_Line("Testing GlobalReAlloc on a unlocked block.");
516  hReAlloced = GlobalReAlloc(hMem, MEM_BLOCK_SIZE - 100, 0);
517  if (0 == hReAlloced)
518  {
519  OUTPUT_Line("GlobalReAlloc failed-- returned NULL");
522  }
523  else
524  {
525  OUTPUT_Line("Alloced Handle: ");
526  OUTPUT_Handle(hMem);
527  OUTPUT_Line("ReAlloced Handle: ");
528  OUTPUT_Handle(hReAlloced);
529 
530  pMem = GlobalLock(hReAlloced);
531  hMem = hReAlloced;
535  GlobalUnlock(hReAlloced);
536  }
537 
538  GlobalFree(hMem);
539  }
540  else
541  {
543  }
544  OUTPUT_Line("Subtest result:");
546  OUTPUT_Line("");
547 
549  subtest = SKIPPED;
550 
551  /* Case 2: re-allocate a moveable block that is locked */
552  OUTPUT_Line("Allocating buffer");
554  if (0 != hMem)
555  {
556 
557  OUTPUT_Line("Testing GlobalReAlloc on a locked block.");
558  pMem = GlobalLock(hMem);
559  hReAlloced = GlobalReAlloc(hMem, MEM_BLOCK_SIZE - 100, 0);
560  if (0 == hReAlloced)
561  {
562  OUTPUT_Line("GlobalReAlloc failed-- returned NULL");
565  }
566  else
567  {
568  OUTPUT_Line("Alloced Handle: ");
569  OUTPUT_Handle(hMem);
570  OUTPUT_Line("ReAlloced Handle: ");
571  OUTPUT_Handle(hReAlloced);
572  if (hMem != hReAlloced)
573  {
574  OUTPUT_Line("GlobalReAlloc returned a different block.");
575  }
576  pMem = GlobalLock(hReAlloced);
580  GlobalUnlock(hReAlloced);
581 
582  }
583 
584  GlobalUnlock(hMem);
585 
586  GlobalFree(hMem);
587  }
588  else
589  {
591  }
592  OUTPUT_Line("Subtest result:");
594  OUTPUT_Line("");
595 
597 
598  OUTPUT_Line("");
599  return result;
600 }
601 
602 /*---------------------------------------------------------------------------
603 **
604 */
606 {
608  OUTPUT_Banner("Testing GlobalReAlloc()");
609 
612 
613  OUTPUT_Line("GlobalReAlloc test result:");
615  return result;
616 }
617 
618 /*---------------------------------------------------------------------------
619 **
620 */
622 {
623  HGLOBAL hMem = 0;
624  UINT uFlags = 0;
626 
627  OUTPUT_Line("Test for the proper lock count");
628 
630  if (0 != hMem)
631  {
632 
633  OUTPUT_Line("Testing initial allocation");
634 
635  OUTPUT_Line("Testing for a lock of 0");
636  uFlags = GlobalFlags(hMem);
637  if (((GMEM_LOCKCOUNT & uFlags) == 0)) /*no locks*/
638  {
640  }
641  else
642  {
644  }
646 
647  OUTPUT_Line("Pointer from handle: ");
648  OUTPUT_Handle(GlobalLock(hMem));
649 
650  OUTPUT_Line("Testing after a lock");
651  OUTPUT_Line("Testing for a lock of 1");
652  uFlags = GlobalFlags(hMem);
653  if (((GMEM_LOCKCOUNT & uFlags) == 1)) /*no locks*/
654  {
656  }
657  else
658  {
660  }
662 
663  GlobalUnlock(hMem);
664  OUTPUT_Line("Testing after an unlock");
665  OUTPUT_Line("Testing for a lock of 0");
666  uFlags = GlobalFlags(hMem);
667  if (((GMEM_LOCKCOUNT & uFlags) == 0)) /*no locks*/
668  {
670  }
671  else
672  {
674  }
676  }
677  else
678  {
679  OUTPUT_Line("GlobalAlloc failed!");
681  }
682 
683  OUTPUT_Line("Test for discarded memory");
684  OUTPUT_Line("Allocating an empty moveable block---automatically marked as discarded");
685  hMem = GlobalAlloc(GMEM_MOVEABLE, 0); /*allocate a discarded block*/
686  if (0 != hMem)
687  {
688  OUTPUT_Line("Allocation handle: ");
689  OUTPUT_Handle(hMem);
690  OUTPUT_Line("Testing for a discarded flag");
691  uFlags = GlobalFlags(hMem);
692  if (0 != (uFlags & GMEM_DISCARDED)) /*discarded*/
693  {
695  }
696  else
697  {
699  }
700  OUTPUT_Line("Flags:");
703 
704  GlobalFree(hMem);
705  }
706  else
707  {
708  OUTPUT_Line("GlobalAlloc failed!");
710  }
711  return result;
712 }
713 
714 
715 /*---------------------------------------------------------------------------
716 **
717 */
719 {
720  HGLOBAL hMem = 0;
721  UINT uFlags = 0;
723 
724  OUTPUT_Line("Testing for correct handling of GMEM_FIXED memory");
726  if (0 != hMem)
727  {
728 
729  OUTPUT_Line("Allocation handle: ");
730  OUTPUT_Handle(hMem);
731 
732  OUTPUT_Line("Testing initial allocation");
733  OUTPUT_Line("Testing for non-discarded and lock of 0");
734  uFlags = GlobalFlags(hMem);
735  if (((GMEM_LOCKCOUNT & uFlags) == 0) && /*no locks*/
736  (((uFlags >> 8) & 0xff) == 0 )) /*not discarded*/
737  {
739  }
740  else
741  {
743  }
745 
746  OUTPUT_Line("Pointer from handle: ");
747  OUTPUT_Handle(GlobalLock(hMem));
748  OUTPUT_Line("Testing after a lock");
749  OUTPUT_Line("Testing for non-discarded and lock of 0");
750  uFlags = GlobalFlags(hMem);
751  if (((GMEM_LOCKCOUNT & uFlags) == 0) && /*no locks*/
752  (((uFlags >> 8) & 0xff) == 0 )) /*not discarded*/
753  {
755  }
756  else
757  {
759  }
761 
762  GlobalFree(hMem);
763  }
764  else
765  {
766  OUTPUT_Line("GlobalAlloc failed!");
768  }
769 
770  return result;
771 }
772 /*---------------------------------------------------------------------------
773 **
774 */
776 {
778  OUTPUT_Banner("Testing GlobalFlags()");
779 
782 
783  OUTPUT_Line("GlobalFlags result:");
785  return result;
786 }
787 /*---------------------------------------------------------------------------
788 **
789 */
791 {
792  HGLOBAL hMem = 0;
793  HGLOBAL hTest = 0;
794  PVOID pMem = 0;
797 
798  OUTPUT_Banner("Testing GlobalHandle()");
799 
800  OUTPUT_Line("Testing GlobalHandle with a block of GMEM_FIXED memory");
802  if (0 != hMem)
803  {
804 
805  OUTPUT_Line("Allocation handle: ");
806  OUTPUT_Handle(hMem);
807 
808  hTest = GlobalHandle(hMem);
809  if (hMem == hTest)
810  {
812  }
813  else
814  {
815  OUTPUT_Line("GlobalHandle returned:");
816  OUTPUT_Handle(hTest);
818  }
819 
820  GlobalFree(hMem);
821  }
822  else
823  {
824  OUTPUT_Line("GlobalAlloc failed!");
826  }
827 
828  OUTPUT_Line("Result from subtest:");
831 
832 
833  subtest = SKIPPED;
834  OUTPUT_Line("Testing GlobalHandle with a block of GMEM_MOVEABLE memory");
836  if (0 != hMem)
837  {
838 
839  OUTPUT_Line("Allocation handle: ");
840  OUTPUT_Handle(hMem);
841  pMem = GlobalLock(hMem);
842  hTest = GlobalHandle(pMem);
843  if (hMem == hTest)
844  {
846  }
847  else
848  {
849  OUTPUT_Line("GlobalHandle returned:");
850  OUTPUT_Handle(hTest);
852  }
853 
854  GlobalUnlock(hMem);
855  GlobalFree(hMem);
856  }
857  else
858  {
859  OUTPUT_Line("GlobalAlloc failed!");
861  }
862 
863  OUTPUT_Line("Result from subtest:");
866 
867 
868  OUTPUT_Line("Global Handle test results:");
870  return result;
871 }
872 
873 /*---------------------------------------------------------------------------
874 **
875 */
877 {
878  HGLOBAL hMem = 0;
879  SIZE_T size = 0;
882  OUTPUT_Banner("Testing GlobalSize()");
883 
884  OUTPUT_Line("Testing GlobalSize with a block of GMEM_FIXED memory");
886  if (0 != hMem)
887  {
888  size = GlobalSize(hMem);
889  if (MEM_BLOCK_SIZE <= size)
890  {
892  }
893  else
894  {
895  OUTPUT_Line("GlobalSize returned:");
898  }
899 
900  GlobalFree(hMem);
901  }
902  else
903  {
904  OUTPUT_Line("GlobalAlloc failed!");
906  }
907 
908  OUTPUT_Line("Result from subtest:");
911 
912  OUTPUT_Line("Testing GlobalSize with a block of GMEM_MOVEABLE memory");
914  if (0 != hMem)
915  {
916  size = GlobalSize(hMem);
917  if (MEM_BLOCK_SIZE <= size)
918  {
920  }
921  else
922  {
923  OUTPUT_Line("GlobalSize returned:");
926  }
927 
928  GlobalFree(hMem);
929  }
930  else
931  {
932  OUTPUT_Line("GlobalAlloc failed!");
934  }
935 
936  OUTPUT_Line("Result from subtest:");
939 
940  OUTPUT_Line("Testing GlobalSize with discarded memory");
941  hMem = GlobalAlloc(GMEM_MOVEABLE, 0);
942  if (0 != hMem)
943  {
944  size = GlobalSize(hMem);
945  if (0 == size)
946  {
948  }
949  else
950  {
951  OUTPUT_Line("GlobalSize returned:");
954  }
955 
956  GlobalFree(hMem);
957  }
958  else
959  {
960  OUTPUT_Line("GlobalAlloc failed!");
962  }
963 
964  OUTPUT_Line("Result from subtest:");
967 
968  OUTPUT_Line("Test result:");
970  return result;
971 }
972 
973 /*---------------------------------------------------------------------------
974 **
975 */
977 {
978  HGLOBAL hMem = 0;
979  HGLOBAL hTest = 0;
980  DWORD uFlags = 0;
983 
984  OUTPUT_Banner("Testing GlobalDiscard()");
986  if (0 != hMem)
987  {
988  OUTPUT_Line("Allocation handle: ");
989  OUTPUT_Handle(hMem);
990 
991  hTest = GlobalDiscard(hMem);
992  if (0 == hTest)
993  {
994  OUTPUT_Line("GlobalDiscard returned NULL");
996  }
997  else
998  {
999  uFlags = GlobalFlags(hTest);
1000  OUTPUT_Line("Flags from the new memory block.");
1002  if (0 != (uFlags & GMEM_DISCARDED))
1003  {
1005  }
1006  else
1007  {
1008  OUTPUT_Line("Block is not marked as discardable.");
1010  }
1011  }
1012 
1013  GlobalFree(hTest);
1014  }
1015  else
1016  {
1017  OUTPUT_Line("GlobalAlloc failed!");
1019  }
1020 
1021  OUTPUT_Line("Result from subtest:");
1023 
1025 
1027  return result;
1028 }
1029 
1030 /*---------------------------------------------------------------------------
1031 **
1032 */
1033 int main(int argc, char ** argv)
1034 {
1036  OUTPUT_Banner("Testing GlobalXXX memory management functions.");
1037 
1042 
1043  if (FAILED == test_set)
1044  {
1045  OUTPUT_Line("Skipping any further tests. GlobalAlloc/Free fails.");
1047  return test_set;
1048  }
1049 
1054 
1056 
1058 
1060 
1062 
1064 
1065  /* output the result for the entire set of tests*/
1066  OUTPUT_Banner("Test suite result");
1068  return test_set;
1069 }
static int argc
Definition: ServiceArgs.c:12
HGLOBAL NTAPI GlobalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:368
static UCHAR ULONG UCHAR ULONG UCHAR * output
Definition: bcrypt.c:29
TEST_STATUS TEST_CombineStatus(TEST_STATUS a, TEST_STATUS b)
Definition: global_mem.c:46
BOOL NTAPI IsBadWritePtr(IN LPVOID lp, IN UINT_PTR ucb)
Definition: except.c:885
void OUTPUT_Result(TEST_STATUS status)
Definition: global_mem.c:128
HGLOBAL NTAPI GlobalReAlloc(HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags)
Definition: heapmem.c:825
#define GPTR
Definition: winbase.h:293
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
void OUTPUT_HexDword(DWORD dw)
Definition: global_mem.c:142
UINT NTAPI GlobalFlags(HGLOBAL hMem)
Definition: heapmem.c:520
int IsMovable(HGLOBAL hMem)
Definition: global_mem.c:220
enum TestStatus TEST_STATUS
#define GMEM_DISCARDED
Definition: winbase.h:304
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
GLuint buffer
Definition: glext.h:5915
TEST_STATUS TestGlobalLockNUnlock(UINT allocFlags)
Definition: global_mem.c:267
HGLOBAL NTAPI GlobalHandle(LPCVOID pMem)
Definition: heapmem.c:705
TEST_STATUS TestGlobalFlagsFixed()
Definition: global_mem.c:718
UINT uFlags
Definition: api.c:60
#define argv
Definition: mplay32.c:18
#define NO_ERROR
Definition: dderror.h:5
void OUTPUT_Line(const char *szLine)
Definition: global_mem.c:79
TEST_STATUS TestGlobalFlags()
Definition: global_mem.c:775
#define MEM_BLOCK_SIZE
Definition: global_mem.c:25
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
void OUTPUT_Banner(const char *szBanner)
Definition: global_mem.c:118
void OutputErrorCode()
Definition: global_mem.c:179
#define sprintf(buf, format,...)
Definition: sprintf.c:55
SIZE_T NTAPI GlobalSize(HGLOBAL hMem)
Definition: heapmem.c:1090
void OUTPUT_Handle(HANDLE h)
Definition: global_mem.c:149
#define GHND
Definition: winbase.h:294
#define a
Definition: ke_i.h:78
#define DISPLAY_COLUMNS
Definition: global_mem.c:17
TEST_STATUS TestGlobalDiscard()
Definition: global_mem.c:976
static const WCHAR szLine[]
Definition: dialog.c:141
#define b
Definition: ke_i.h:79
TestStatus
Definition: global_mem.c:32
void OutputAllocFlags(UINT pFlags)
Definition: global_mem.c:159
TEST_STATUS TestGlobalReAlloc()
Definition: global_mem.c:605
TEST_STATUS TestGlobalFlagsMoveable()
Definition: global_mem.c:621
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
TEST_STATUS TestGlobalAllocNFree(UINT allocFlags)
Definition: global_mem.c:238
GLsizeiptr size
Definition: glext.h:5919
int main(int argc, char **argv)
Definition: global_mem.c:1033
#define GlobalDiscard(m)
Definition: winbase.h:2518
const GLubyte * c
Definition: glext.h:8905
#define LINE_BUFFER_SIZE
Definition: global_mem.c:18
unsigned long DWORD
Definition: ntddk_ex.h:95
TEST_STATUS TestGlobalReAllocFixed()
Definition: global_mem.c:342
HGLOBAL NTAPI GlobalFree(HGLOBAL hMem)
Definition: heapmem.c:611
REFIID LPVOID DWORD dw
Definition: atlbase.h:40
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
TEST_STATUS TestGlobalReAllocMovable()
Definition: global_mem.c:500
#define GMEM_FIXED
Definition: winbase.h:290
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
void test_set()
Definition: test_set.cpp:75
void OUTPUT_BannerLine()
Definition: global_mem.c:63
ULONG_PTR SIZE_T
Definition: typedefs.h:78
TEST_STATUS TestGlobalHandle()
Definition: global_mem.c:790
#define GMEM_MODIFY
Definition: winbase.h:292
BOOL WINAPI IsBadReadPtr(IN LPCVOID lp, IN UINT_PTR ucb)
Definition: except.c:807
unsigned int UINT
Definition: ndis.h:50
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
Definition: mem.c:156
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
GLuint64EXT * result
Definition: glext.h:11304
#define memset(x, y, z)
Definition: compat.h:39
static SERVICE_STATUS status
Definition: service.c:31
#define GMEM_LOCKCOUNT
Definition: winbase.h:306
#define GMEM_MOVEABLE
Definition: winbase.h:291
TEST_STATUS TEST_MemoryWrite(LPVOID mem, DWORD cbSize)
Definition: global_mem.c:190
#define GMEM_ZEROINIT
Definition: winbase.h:303
TEST_STATUS TestGlobalSize()
Definition: global_mem.c:876
TEST_STATUS TEST_MemoryRead(LPVOID mem, DWORD cbSize)
Definition: global_mem.c:204
#define printf
Definition: config.h:203
Definition: ps.c:97