Add missing processor architecture cases
[reactos.git] / reactos / regtests / shared / regtests.h
1 /*
2 * PROJECT: ReactOS kernel
3 * FILE: regtests/shared/regtests.h
4 * PURPOSE: Regression testing
5 * PROGRAMMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
6 * UPDATE HISTORY:
7 * 06-07-2003 CSH Created
8 */
9 #ifndef __REGTESTS_H
10 #define __REGTESTS_H
11 #include <stdio.h>
12 #include <string.h>
13
14 typedef DWORD (STDCALL _LPTHREAD_START_ROUTINE)(LPVOID lpParameter);
15
16 typedef struct __FILETIME
17 {
18 DWORD dwLowDateTime;
19 DWORD dwHighDateTime;
20 } _FILETIME, *_PFILETIME, *_LPFILETIME;
21
22 extern void SetupOnce();
23
24 #define _SetupOnce() \
25 void SetupOnce()
26
27 /* Valid values for Command parameter of TestRoutine */
28 #define TESTCMD_RUN 0 /* Buffer contains information about what failed */
29 #define TESTCMD_TESTTYPE 1 /* Buffer contains type of test */
30 #define TESTCMD_TESTNAME 2 /* Buffer contains description of test */
31 #define TESTCMD_TIMEOUT 3 /* Buffer contains timeout for test (DWORD, default is 5000 ms) */
32
33 /* Test types */
34 #define TT_NORMAL 0
35
36 /* Valid values for return values of TestRoutine */
37 #define TS_TIMEDOUT ((DWORD)-2)
38 #define TS_EXCEPTION ((DWORD)-1)
39 #define TS_OK 0
40 #define TS_FAILED 1
41
42 extern int _Result;
43 extern char *_Buffer;
44
45 /* Macros to simplify tests */
46 #define _DispatcherTypeTimeout(FunctionName, TestName, TestType, TimeOut) \
47 void \
48 FunctionName(int Command) \
49 { \
50 switch (Command) \
51 { \
52 case TESTCMD_RUN: \
53 RunTest(); \
54 break; \
55 case TESTCMD_TESTTYPE: \
56 *(PDWORD)_Buffer = (DWORD)TestType; \
57 break; \
58 case TESTCMD_TESTNAME: \
59 strcpy(_Buffer, TestName); \
60 break; \
61 case TESTCMD_TIMEOUT: \
62 *(PDWORD)_Buffer = (DWORD)TimeOut; \
63 break; \
64 default: \
65 _Result = TS_FAILED; \
66 break; \
67 } \
68 }
69
70 #define _DispatcherTimeout(FunctionName, TestName, TimeOut) \
71 _DispatcherTypeTimeout(FunctionName, TestName, TT_NORMAL, TimeOut)
72
73 #define _DispatcherType(FunctionName, TestName, TestType) \
74 _DispatcherTypeTimeout(FunctionName, TestName, TestType, 5000)
75
76 #define _Dispatcher(FunctionName, TestName) \
77 _DispatcherTimeout(FunctionName, TestName, 5000)
78
79 static __inline void
80 AppendAssertion(char *message)
81 {
82 if (strlen(_Buffer) != 0)
83 strcat(_Buffer, "\n");
84 strcat(_Buffer, message);
85 _Result = TS_FAILED;
86 }
87
88 #define _AssertTrue(_Condition) \
89 { \
90 if (!(_Condition)) \
91 { \
92 char _message[100]; \
93 sprintf(_message, "Condition was not true at %s:%d", \
94 __FILE__, __LINE__); \
95 AppendAssertion(_message); \
96 } \
97 }
98
99 #define _AssertFalse(_Condition) \
100 { \
101 if (_Condition) \
102 { \
103 char _message[100]; \
104 sprintf(_message, "Condition was not false at %s:%d", \
105 __FILE__, __LINE__); \
106 AppendAssertion(_message); \
107 } \
108 }
109
110 #define _AssertEqualValue(_Expected, _Actual) \
111 { \
112 ULONG __Expected = (ULONG) (_Expected); \
113 ULONG __Actual = (ULONG) (_Actual); \
114 if ((__Expected) != (__Actual)) \
115 { \
116 char _message[100]; \
117 sprintf(_message, "Expected %ld/0x%.08lx was %ld/0x%.08lx at %s:%d", \
118 (__Expected), (__Expected), (__Actual), (__Actual), __FILE__, __LINE__); \
119 AppendAssertion(_message); \
120 } \
121 }
122
123 #define _AssertEqualWideString(_Expected, _Actual) \
124 { \
125 LPWSTR __Expected = (LPWSTR) (_Expected); \
126 LPWSTR __Actual = (LPWSTR) (_Actual); \
127 if (wcscmp((__Expected), (__Actual)) != 0) \
128 { \
129 char _message[100]; \
130 sprintf(_message, "Expected %S was %S at %s:%d", \
131 (__Expected), (__Actual), __FILE__, __LINE__); \
132 AppendAssertion(_message); \
133 } \
134 }
135
136 #define _AssertNotEqualValue(_Expected, _Actual) \
137 { \
138 ULONG __Expected = (ULONG) (_Expected); \
139 ULONG __Actual = (ULONG) (_Actual); \
140 if ((__Expected) == (__Actual)) \
141 { \
142 char _message[100]; \
143 sprintf(_message, "Actual value expected to be different from %ld/0x%.08lx at %s:%d", \
144 (__Expected), (__Expected), __FILE__, __LINE__); \
145 AppendAssertion(_message); \
146 } \
147 }
148
149
150 /*
151 * Test routine prototype
152 * Command - The command to process
153 */
154 typedef void (*TestRoutine)(int Command);
155
156 /*
157 * Test output routine prototype
158 * Buffer - Address of buffer with text to output
159 */
160 typedef void (*TestOutputRoutine)(char *Buffer);
161
162 /*
163 * Test driver entry routine.
164 * OutputRoutine - Output routine.
165 * TestName - If NULL all tests are run. If non-NULL specifies the test to be run
166 */
167 typedef void STDCALL (*TestDriverMain)(TestOutputRoutine OutputRoutine, char *TestName);
168
169 typedef struct __TEST
170 {
171 LIST_ENTRY ListEntry;
172 TestRoutine Routine;
173 } _TEST, *_PTEST;
174
175 extern VOID InitializeTests();
176 extern VOID RegisterTests();
177 extern VOID PerformTests(TestOutputRoutine OutputRoutine, LPSTR TestName);
178
179
180 typedef struct __API_DESCRIPTION
181 {
182 PCHAR FileName;
183 PCHAR FunctionName;
184 PCHAR ForwardedFunctionName;
185 PVOID FunctionAddress;
186 PVOID MockFunctionAddress;
187 } _API_DESCRIPTION, *_PAPI_DESCRIPTION;
188
189 extern _API_DESCRIPTION ExternalDependencies[];
190 extern ULONG MaxExternalDependency;
191
192 HANDLE STDCALL
193 _GetModuleHandleA(LPCSTR lpModuleName);
194
195 PVOID STDCALL
196 _GetProcAddress(HANDLE hModule,
197 LPCSTR lpProcName);
198
199 HANDLE STDCALL
200 _LoadLibraryA(LPCSTR lpLibFileName);
201
202 VOID STDCALL
203 _ExitProcess(UINT uExitCode);
204
205 HANDLE STDCALL
206 _CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize,
207 _LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter,
208 DWORD dwCreationFlags, LPDWORD lpThreadId);
209
210 WINBOOL STDCALL
211 _TerminateThread(HANDLE hThread, DWORD dwExitCode);
212
213 DWORD STDCALL
214 _WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);
215
216 DWORD STDCALL
217 _GetLastError();
218
219 VOID STDCALL
220 _CloseHandle(HANDLE handle);
221
222 BOOL STDCALL
223 _GetThreadTimes(HANDLE hThread,
224 _LPFILETIME lpCreationTime,
225 _LPFILETIME lpExitTime,
226 _LPFILETIME lpKernelTime,
227 _LPFILETIME lpUserTime);
228
229 BOOL STDCALL
230 _SetPriorityClass(HANDLE hProcess, DWORD dwPriorityClass);
231
232 BOOL STDCALL
233 _SetThreadPriority(HANDLE hThread, int nPriority);
234
235 HANDLE STDCALL
236 _GetCurrentProcess();
237
238 HANDLE STDCALL
239 _GetCurrentThread();
240
241 VOID STDCALL
242 _Sleep(DWORD dwMilliseconds);
243
244
245 static __inline PCHAR
246 FrameworkGetExportedFunctionNameInternal(_PAPI_DESCRIPTION ApiDescription)
247 {
248 if (ApiDescription->ForwardedFunctionName != NULL)
249 {
250 return ApiDescription->ForwardedFunctionName;
251 }
252 else
253 {
254 return ApiDescription->FunctionName;
255 }
256 }
257
258 static __inline PVOID
259 FrameworkGetFunction(_PAPI_DESCRIPTION ApiDescription)
260 {
261 HANDLE hModule;
262 PVOID function = NULL;
263 PCHAR exportedFunctionName;
264
265 exportedFunctionName = FrameworkGetExportedFunctionNameInternal(ApiDescription);
266
267 hModule = _GetModuleHandleA(ApiDescription->FileName);
268 if (hModule != NULL)
269 {
270 function = _GetProcAddress(hModule, exportedFunctionName);
271 }
272 else
273 {
274 hModule = _LoadLibraryA(ApiDescription->FileName);
275 if (hModule != NULL)
276 {
277 function = _GetProcAddress(hModule, exportedFunctionName);
278 //FreeLibrary(hModule);
279 }
280 }
281 return function;
282 }
283
284 static __inline PVOID
285 FrameworkGetHookInternal(ULONG index)
286 {
287 PVOID address;
288 PCHAR exportedFunctionName;
289
290 if (index > MaxExternalDependency)
291 return NULL;
292
293 if (ExternalDependencies[index].MockFunctionAddress != NULL)
294 return ExternalDependencies[index].MockFunctionAddress;
295
296 if (ExternalDependencies[index].FunctionAddress != NULL)
297 return ExternalDependencies[index].FunctionAddress;
298
299 exportedFunctionName = FrameworkGetExportedFunctionNameInternal(&ExternalDependencies[index]);
300
301 printf("Calling function '%s' in DLL '%s'.\n",
302 exportedFunctionName,
303 ExternalDependencies[index].FileName);
304
305 address = FrameworkGetFunction(&ExternalDependencies[index]);
306
307 if (address == NULL)
308 {
309 printf("Function '%s' not found in DLL '%s'.\n",
310 exportedFunctionName,
311 ExternalDependencies[index].FileName);
312 }
313 ExternalDependencies[index].FunctionAddress = address;
314
315 return address;
316 }
317
318
319 static __inline VOID
320 _SetHook(PCHAR name,
321 PVOID address)
322 {
323 _PAPI_DESCRIPTION api;
324 ULONG index;
325
326 for (index = 0; index <= MaxExternalDependency; index++)
327 {
328 api = &ExternalDependencies[index];
329 if (strcmp(api->FunctionName, name) == 0)
330 {
331 api->MockFunctionAddress = address;
332 return;
333 }
334 }
335 }
336
337 typedef struct __HOOK
338 {
339 PCHAR FunctionName;
340 PVOID FunctionAddress;
341 } _HOOK, *_PHOOK;
342
343 static __inline VOID
344 _SetHooks(_PHOOK hookTable)
345 {
346 _PHOOK hook;
347
348 hook = &hookTable[0];
349 while (hook->FunctionName != NULL)
350 {
351 _SetHook(hook->FunctionName,
352 hook->FunctionAddress);
353 hook++;
354 }
355 }
356
357 static __inline VOID
358 _UnsetHooks(_PHOOK hookTable)
359 {
360 _PHOOK hook;
361
362 hook = &hookTable[0];
363 while (hook->FunctionName != NULL)
364 {
365 _SetHook(hook->FunctionName,
366 NULL);
367 hook++;
368 }
369 }
370
371 static __inline VOID
372 _UnsetAllHooks()
373 {
374 _PAPI_DESCRIPTION api;
375 ULONG index;
376
377 for (index = 0; index <= MaxExternalDependency; index++)
378 {
379 api = &ExternalDependencies[index];
380 api->MockFunctionAddress = NULL;
381 }
382 }
383
384 #endif /* __REGTESTS_H */