Mercurial > pub > dyncall > dyncall

comparison test/plain/test_main.c @ 324:dd78bd0152af

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
- removal of never-adopted mini-test framework stub - test/plain: better output and cleanup - test/plain_c++: better output and re-enabled this calls for other platforms than windows (was disabled by mistake)
author Tassilo Philipp
date Thu, 21 Nov 2019 12:50:37 +0100
parents f5577f6bf97a
children da4b267c10bf
comparison
equal deleted inserted replaced
323:6ffb6a00cf55 324:dd78bd0152af
1 /* 1 /*
2 2
3 Package: dyncall 3 Package: dyncall
4 Library: test 4 Library: test
5 File: test/plain/test_main.c 5 File: test/plain/test_main.c
6 Description: 6 Description:
7 License: 7 License:
8 8
9 Copyright (c) 2007-2018 Daniel Adler <dadler@uni-goettingen.de>, 9 Copyright (c) 2007-2019 Daniel Adler <dadler@uni-goettingen.de>,
10 Tassilo Philipp <tphilipp@potion-studios.com> 10 Tassilo Philipp <tphilipp@potion-studios.com>
11 11
12 Permission to use, copy, modify, and distribute this software for any 12 Permission to use, copy, modify, and distribute this software for any
13 purpose with or without fee is hereby granted, provided that the above 13 purpose with or without fee is hereby granted, provided that the above
14 copyright notice and this permission notice appear in all copies. 14 copyright notice and this permission notice appear in all copies.
24 */ 24 */
25 25
26 26
27 27
28 28
29 #include "../common/test_framework.h"
30 #include "../../dyncall/dyncall.h" 29 #include "../../dyncall/dyncall.h"
31 #include "../common/platformInit.h" 30 #include "../common/platformInit.h"
32 #include "../common/platformInit.c" /* Impl. for functions only used in this translation unit */ 31 #include "../common/platformInit.c" /* Impl. for functions only used in this translation unit */
33 32
34 33
35 /* ------------------------------------------------------------------------- 34 /* -------------------------------------------------------------------------
36 * test: identity function calls 35 * test: identity function calls
37 * ------------------------------------------------------------------------- */ 36 * ------------------------------------------------------------------------- */
38 37
39 #define DEF_FUNCS(API,NAME) \ 38 #define DEF_FUNCS(API,NAME) \
40 void API fun_##NAME##_v() { } \ 39 void API fun_##NAME##_v() { g_void_testval = 1; } \
41 DCbool API fun_##NAME##_b(DCbool x) { return x; } \ 40 DCbool API fun_##NAME##_b(DCbool x) { return x; } \
42 DCint API fun_##NAME##_i(DCint x) { return x; } \ 41 DCint API fun_##NAME##_i(DCint x) { return x; } \
43 DClong API fun_##NAME##_j(DClong x) { return x; } \ 42 DClong API fun_##NAME##_j(DClong x) { return x; } \
44 DClonglong API fun_##NAME##_l(DClonglong x) { return x; } \ 43 DClonglong API fun_##NAME##_l(DClonglong x) { return x; } \
45 DCfloat API fun_##NAME##_f(DCfloat x) { return x; } \ 44 DCfloat API fun_##NAME##_f(DCfloat x) { return x; } \
47 DCpointer API fun_##NAME##_p(DCpointer x) { return x; } 46 DCpointer API fun_##NAME##_p(DCpointer x) { return x; }
48 47
49 /* __cdecl */ 48 /* __cdecl */
50 49
51 #if !defined(DC__OS_Win32) 50 #if !defined(DC__OS_Win32)
52 # define __declspec(X)
53 # define __cdecl 51 # define __cdecl
54 #endif 52 #endif
55 53
54 int g_void_testval;
56 DEF_FUNCS(__cdecl,c) 55 DEF_FUNCS(__cdecl,c)
57 56
58 DC_DEFINE_TEST_FUNC_BEGIN(testCallC) 57 int testCallC()
58 {
59 int ret = 1;
59 60
60 DCCallVM* pc = dcNewCallVM(4096); 61 DCCallVM* pc = dcNewCallVM(4096);
61 dcMode(pc,DC_CALL_C_DEFAULT); 62 dcMode(pc,DC_CALL_C_DEFAULT);
62 /* void */ 63 /* void */
63 dcReset(pc); 64 dcReset(pc);
65 g_void_testval = 0;
64 dcCallVoid(pc, (DCpointer) &fun_c_v); 66 dcCallVoid(pc, (DCpointer) &fun_c_v);
67 ret = g_void_testval && ret;
65 /* bool */ 68 /* bool */
66 { 69 {
67 DCbool r, val=DC_TRUE; 70 DCbool r, val=DC_TRUE;
68 dcReset(pc); 71 dcReset(pc);
69 dcArgBool(pc, val); 72 dcArgBool(pc, val);
70 r = dcCallBool(pc, (DCpointer) &fun_c_b); 73 r = dcCallBool(pc, (DCpointer) &fun_c_b);
71 DC_TEST(r == val); 74 printf("bt (cdecl): %d\n", (r == val));
75 ret = (r == val) && ret;
72 76
73 val=DC_FALSE; 77 val=DC_FALSE;
74 dcReset(pc); 78 dcReset(pc);
75 dcArgBool(pc, val); 79 dcArgBool(pc, val);
76 r = dcCallBool(pc, (DCpointer) &fun_c_b); 80 r = dcCallBool(pc, (DCpointer) &fun_c_b);
77 DC_TEST(r == val); 81 printf("bf (cdecl): %d\n", (r == val));
82 ret = (r == val) && ret;
78 } 83 }
79 /* int */ 84 /* int */
80 { 85 {
81 DCint r, val=1234; 86 DCint r, val=1234;
82 dcReset(pc); 87 dcReset(pc);
83 dcArgInt(pc, val); 88 dcArgInt(pc, val);
84 r = dcCallInt(pc, (DCpointer) &fun_c_i); 89 r = dcCallInt(pc, (DCpointer) &fun_c_i);
85 DC_TEST(r == val); 90 printf("i (cdecl): %d\n", (r == val));
91 ret = (r == val) && ret;
86 } 92 }
87 /* long */ 93 /* long */
88 { 94 {
89 DClong r, val=(DClong) 0xCAFEBABEL; 95 DClong r, val=(DClong) 0xCAFEBABEL;
90 dcReset(pc); 96 dcReset(pc);
91 dcArgLong(pc, val); 97 dcArgLong(pc, val);
92 r = dcCallLong(pc, (DCpointer) &fun_c_j); 98 r = dcCallLong(pc, (DCpointer) &fun_c_j);
93 DC_TEST(r == val); 99 printf("l (cdecl): %d\n", (r == val));
100 ret = (r == val) && ret;
94 } 101 }
95 /* long long */ 102 /* long long */
96 { 103 {
97 DClonglong r, val=(DClonglong) 0xCAFEBABEDEADC0DELL; 104 DClonglong r, val=(DClonglong) 0xCAFEBABEDEADC0DELL;
98 dcReset(pc); 105 dcReset(pc);
99 dcArgLongLong(pc, val); 106 dcArgLongLong(pc, val);
100 r = dcCallLongLong(pc, (DCpointer) &fun_c_l); 107 r = dcCallLongLong(pc, (DCpointer) &fun_c_l);
101 DC_TEST(r == (DClonglong)val); 108 printf("ll (cdecl): %d\n", (r == (DClonglong)val));
109 ret = (r == (DClonglong)val) && ret;
102 } 110 }
103 /* float */ 111 /* float */
104 { 112 {
105 DCfloat r, val=1.234567f; 113 DCfloat r, val=1.234567f;
106 dcReset(pc); 114 dcReset(pc);
107 dcArgFloat(pc, val); 115 dcArgFloat(pc, val);
108 r = dcCallFloat(pc, (DCpointer) &fun_c_f); 116 r = dcCallFloat(pc, (DCpointer) &fun_c_f);
109 DC_TEST(r == val); 117 printf("f (cdecl): %d\n", (r == val));
118 ret = (r == val) && ret;
110 } 119 }
111 /* double */ 120 /* double */
112 { 121 {
113 DCdouble r, val=1.23456789; 122 DCdouble r, val=1.23456789;
114 dcReset(pc); 123 dcReset(pc);
115 dcArgDouble(pc, val); 124 dcArgDouble(pc, val);
116 r = dcCallDouble(pc, (DCpointer) &fun_c_d); 125 r = dcCallDouble(pc, (DCpointer) &fun_c_d);
117 DC_TEST(r == val); 126 printf("d (cdecl): %d\n", (r == val));
127 ret = (r == val) && ret;
118 } 128 }
119 /* ptr */ 129 /* ptr */
120 { 130 {
121 DCpointer r; 131 DCpointer r;
122 dcReset(pc); 132 dcReset(pc);
123 dcArgPointer(pc, (DCpointer) &fun_c_b); 133 dcArgPointer(pc, (DCpointer) &fun_c_b);
124 r = dcCallPointer(pc, (DCpointer) &fun_c_p); 134 r = dcCallPointer(pc, (DCpointer) &fun_c_p);
125 DC_TEST(r == (DCpointer) &fun_c_b); 135 printf("p (cdecl): %d\n", (r == (DCpointer) &fun_c_b));
136 ret = (r == (DCpointer) &fun_c_b) && ret;
126 } 137 }
127 dcFree(pc); 138 dcFree(pc);
128 139
129 DC_DEFINE_TEST_FUNC_END 140 return ret;
141 }
130 142
131 143
132 #ifdef DC__OS_Win32 144 #ifdef DC__OS_Win32
133 /* win32 __stdcall */ 145 /* win32 __stdcall */
134 146
135 DEF_FUNCS(__stdcall,std) 147 DEF_FUNCS(__stdcall,std)
136 148
137 DC_DEFINE_TEST_FUNC_BEGIN(testCallStd) 149 int testCallStd()
150 {
151 int ret = 1;
138 152
139 DCCallVM* pc = dcNewCallVM(4096); 153 DCCallVM* pc = dcNewCallVM(4096);
140 dcMode(pc,DC_CALL_C_X86_WIN32_STD); 154 dcMode(pc,DC_CALL_C_X86_WIN32_STD);
141 /* void */ 155 /* void */
142 dcReset(pc); 156 dcReset(pc);
157 g_void_testval = 0;
143 dcCallVoid(pc, (DCpointer) &fun_std_v); 158 dcCallVoid(pc, (DCpointer) &fun_std_v);
159 ret = g_void_testval && ret;
144 /* bool */ 160 /* bool */
145 { 161 {
146 DCbool r, val=DC_TRUE; 162 DCbool r, val=DC_TRUE;
147 dcReset(pc); 163 dcReset(pc);
148 dcArgBool(pc, val); 164 dcArgBool(pc, val);
149 r = dcCallBool(pc, (DCpointer) &fun_std_b); 165 r = dcCallBool(pc, (DCpointer) &fun_std_b);
150 DC_TEST(r == val); 166 printf("bt (stdcall): %d\n", (r == val));
167 ret = (r == val) && ret;
151 168
152 val=DC_FALSE; 169 val=DC_FALSE;
153 dcReset(pc); 170 dcReset(pc);
154 dcArgBool(pc, val); 171 dcArgBool(pc, val);
155 r = dcCallBool(pc, (DCpointer) &fun_std_b); 172 r = dcCallBool(pc, (DCpointer) &fun_std_b);
156 DC_TEST(r == val); 173 printf("bf (stdcall): %d\n", (r == val));
174 ret = (r == val) && ret;
157 } 175 }
158 /* int */ 176 /* int */
159 { 177 {
160 DCint r, val=1234; 178 DCint r, val=1234;
161 dcReset(pc); 179 dcReset(pc);
162 dcArgInt(pc, val); 180 dcArgInt(pc, val);
163 r = dcCallInt(pc, (DCpointer) &fun_std_i); 181 r = dcCallInt(pc, (DCpointer) &fun_std_i);
164 DC_TEST(r == val); 182 printf("i (stdcall): %d\n", (r == val));
183 ret = (r == val) && ret;
165 } 184 }
166 /* long */ 185 /* long */
167 { 186 {
168 DClong r, val=0xCAFEBABEUL; 187 DClong r, val=0xCAFEBABEUL;
169 dcReset(pc); 188 dcReset(pc);
170 dcArgLong(pc, val); 189 dcArgLong(pc, val);
171 r = dcCallLong(pc, (DCpointer) &fun_std_j); 190 r = dcCallLong(pc, (DCpointer) &fun_std_j);
172 DC_TEST(r == val); 191 printf("l (stdcall): %d\n", (r == val));
192 ret = (r == val) && ret;
173 } 193 }
174 /* long long */ 194 /* long long */
175 { 195 {
176 DClonglong r, val=0xCAFEBABEDEADC0DEULL; 196 DClonglong r, val=0xCAFEBABEDEADC0DEULL;
177 dcReset(pc); 197 dcReset(pc);
178 dcArgLongLong(pc, val); 198 dcArgLongLong(pc, val);
179 r = dcCallLongLong(pc, (DCpointer) &fun_std_l); 199 r = dcCallLongLong(pc, (DCpointer) &fun_std_l);
180 DC_TEST(r == val); 200 printf("ll (stdcall): %d\n", (r == val));
201 ret = (r == val) && ret;
181 } 202 }
182 /* float */ 203 /* float */
183 { 204 {
184 DCfloat r, val=1.234567f; 205 DCfloat r, val=1.234567f;
185 dcReset(pc); 206 dcReset(pc);
186 dcArgFloat(pc, val); 207 dcArgFloat(pc, val);
187 r = dcCallFloat(pc, (DCpointer) &fun_std_f); 208 r = dcCallFloat(pc, (DCpointer) &fun_std_f);
188 DC_TEST(r == val); 209 printf("f (stdcall): %d\n", (r == val));
210 ret = (r == val) && ret;
189 } 211 }
190 /* double */ 212 /* double */
191 { 213 {
192 DCdouble r, val=1.23456789; 214 DCdouble r, val=1.23456789;
193 dcReset(pc); 215 dcReset(pc);
194 dcArgDouble(pc, val); 216 dcArgDouble(pc, val);
195 r = dcCallDouble(pc, (DCpointer) &fun_std_d); 217 r = dcCallDouble(pc, (DCpointer) &fun_std_d);
196 DC_TEST(r == val); 218 printf("d (stdcall): %d\n", (r == val));
219 ret = (r == val) && ret;
197 } 220 }
198 /* ptr */ 221 /* ptr */
199 { 222 {
200 DCpointer r; 223 DCpointer r;
201 dcReset(pc); 224 dcReset(pc);
202 dcArgPointer(pc, (DCpointer) &fun_c_b); 225 dcArgPointer(pc, (DCpointer) &fun_c_b);
203 r = dcCallPointer(pc, (DCpointer) &fun_std_p); 226 r = dcCallPointer(pc, (DCpointer) &fun_std_p);
204 DC_TEST(r == &fun_c_b); 227 printf("p (stdcall): %d\n", (r == &fun_c_b));
228 ret = (r == &fun_c_b) && ret;
205 } 229 }
206 dcFree(pc); 230 dcFree(pc);
207 231
208 DC_DEFINE_TEST_FUNC_END 232 return ret;
233 }
209 234
210 #endif 235 #endif
211 236
212 237
213 #ifdef DC__OS_Win32 238 #ifdef DC__OS_Win32
214 /* win32 __fastcall */ 239 /* win32 __fastcall */
215 240
216 DEF_FUNCS(__fastcall,fast) 241 DEF_FUNCS(__fastcall,fast)
217 242
218 DC_DEFINE_TEST_FUNC_BEGIN(testCallFast) 243 int testCallFast()
244 {
245 int ret = 1;
219 246
220 DCCallVM* pc = dcNewCallVM(4096); 247 DCCallVM* pc = dcNewCallVM(4096);
221 #ifdef DC__C_GNU 248 #ifdef DC__C_GNU
249 # define FT "GNU"
222 dcMode(pc,DC_CALL_C_X86_WIN32_FAST_GNU); 250 dcMode(pc,DC_CALL_C_X86_WIN32_FAST_GNU);
223 #else 251 #else
252 # define FT "MS"
224 dcMode(pc,DC_CALL_C_X86_WIN32_FAST_MS); 253 dcMode(pc,DC_CALL_C_X86_WIN32_FAST_MS);
225 #endif 254 #endif
226 /* void */ 255 /* void */
227 dcReset(pc); 256 dcReset(pc);
257 g_void_testval = 0;
228 dcCallVoid(pc, (DCpointer) &fun_fast_v); 258 dcCallVoid(pc, (DCpointer) &fun_fast_v);
259 ret = g_void_testval && ret;
229 /* bool */ 260 /* bool */
230 { 261 {
231 DCbool r, val=DC_TRUE; 262 DCbool r, val=DC_TRUE;
232 dcReset(pc); 263 dcReset(pc);
233 dcArgBool(pc, val); 264 dcArgBool(pc, val);
234 r = dcCallBool(pc, (DCpointer) &fun_fast_b); 265 r = dcCallBool(pc, (DCpointer) &fun_fast_b);
235 DC_TEST(r == val); 266 printf("bt ("FT"fastcall): %d\n", (r == val));
267 ret = (r == val) && ret;
236 268
237 val=DC_FALSE; 269 val=DC_FALSE;
238 dcReset(pc); 270 dcReset(pc);
239 dcArgBool(pc, val); 271 dcArgBool(pc, val);
240 r = dcCallBool(pc, (DCpointer) &fun_fast_b); 272 r = dcCallBool(pc, (DCpointer) &fun_fast_b);
241 DC_TEST(r == val); 273 printf("bf ("FT"fastcall): %d\n", (r == val));
274 ret = (r == val) && ret;
242 } 275 }
243 /* int */ 276 /* int */
244 { 277 {
245 DCint r, val=1234; 278 DCint r, val=1234;
246 dcReset(pc); 279 dcReset(pc);
247 dcArgInt(pc, val); 280 dcArgInt(pc, val);
248 r = dcCallInt(pc, (DCpointer) &fun_fast_i); 281 r = dcCallInt(pc, (DCpointer) &fun_fast_i);
249 DC_TEST(r == val); 282 printf("i ("FT"fastcall): %d\n", (r == val));
283 ret = (r == val) && ret;
250 } 284 }
251 /* long */ 285 /* long */
252 { 286 {
253 DClong r, val=0xCAFEBABEUL; 287 DClong r, val=0xCAFEBABEUL;
254 dcReset(pc); 288 dcReset(pc);
255 dcArgLong(pc, val); 289 dcArgLong(pc, val);
256 r = dcCallLong(pc, (DCpointer) &fun_fast_j); 290 r = dcCallLong(pc, (DCpointer) &fun_fast_j);
257 DC_TEST(r == val); 291 printf("l ("FT"fastcall): %d\n", (r == val));
292 ret = (r == val) && ret;
258 } 293 }
259 /* long long */ 294 /* long long */
260 { 295 {
261 DClonglong r, val=0xCAFEBABEDEADC0DEULL; 296 DClonglong r, val=0xCAFEBABEDEADC0DEULL;
262 dcReset(pc); 297 dcReset(pc);
263 dcArgLongLong(pc, val); 298 dcArgLongLong(pc, val);
264 r = dcCallLongLong(pc, (DCpointer) &fun_fast_l); 299 r = dcCallLongLong(pc, (DCpointer) &fun_fast_l);
265 DC_TEST(r == val); 300 printf("ll ("FT"fastcall): %d\n", (r == val));
301 ret = (r == val) && ret;
266 } 302 }
267 /* float */ 303 /* float */
268 { 304 {
269 DCfloat r, val=1.234567f; 305 DCfloat r, val=1.234567f;
270 dcReset(pc); 306 dcReset(pc);
271 dcArgFloat(pc, val); 307 dcArgFloat(pc, val);
272 r = dcCallFloat(pc, (DCpointer) &fun_fast_f); 308 r = dcCallFloat(pc, (DCpointer) &fun_fast_f);
273 DC_TEST(r == val); 309 printf("f ("FT"fastcall): %d\n", (r == val));
310 ret = (r == val) && ret;
274 } 311 }
275 /* double */ 312 /* double */
276 { 313 {
277 DCdouble r, val=1.23456789; 314 DCdouble r, val=1.23456789;
278 dcReset(pc); 315 dcReset(pc);
279 dcArgDouble(pc, val); 316 dcArgDouble(pc, val);
280 r = dcCallDouble(pc, (DCpointer) &fun_fast_d); 317 r = dcCallDouble(pc, (DCpointer) &fun_fast_d);
281 DC_TEST(r == val); 318 printf("d ("FT"fastcall): %d\n", (r == val));
319 ret = (r == val) && ret;
282 } 320 }
283 /* ptr */ 321 /* ptr */
284 { 322 {
285 DCpointer r; 323 DCpointer r;
286 dcReset(pc); 324 dcReset(pc);
287 dcArgPointer(pc, (DCpointer) &fun_c_b); 325 dcArgPointer(pc, (DCpointer) &fun_c_b);
288 r = dcCallPointer(pc, (DCpointer) &fun_fast_p); 326 r = dcCallPointer(pc, (DCpointer) &fun_fast_p);
289 DC_TEST(r == &fun_c_b); 327 printf("p ("FT"fastcall): %d\n", (r == &fun_c_b));
328 ret = (r == &fun_c_b) && ret;
290 } 329 }
291 dcFree(pc); 330 dcFree(pc);
292 331
293 DC_DEFINE_TEST_FUNC_END 332 return ret;
294 #endif 333 }
334
335 #endif
336
295 337
296 int testCallStructs(); 338 int testCallStructs();
297 int testStructSizes(); 339 int testStructSizes();
340
298 int main(int argc, char* argv[]) 341 int main(int argc, char* argv[])
299 { 342 {
300 int b = TRUE; 343 int r = 1;
301 dcTest_initPlatform(); 344 dcTest_initPlatform();
302 345
303 b = b && testCallC(); 346 r = testCallC() && r;
304 printf("C:%d\n",b); 347 r = testStructSizes() && r;
305 348 /*r = testCallStructs() && r;*/
306 b = b && testStructSizes();
307 printf("Struct Sizes:%d\n",b);
308
309 /*b = b && testCallStructs();
310 printf("Call Structs:%d\n",b);*/
311
312 #if defined(DC__OS_Win32) 349 #if defined(DC__OS_Win32)
313 350 r = testCallStd() && r;
314 b = b && testCallStd(); 351 r = testCallFast() && r;
315 printf("Std:%d\n",b); 352 #endif
316 353
317 b = b && testCallFast(); 354 printf("result: plain: %d\n", r);
318 #ifdef DC__C_GNU
319 printf("FastGNU:%d\n",b);
320 #else
321 printf("FastMS:%d\n",b);
322 #endif
323
324 #endif
325
326 printf("result: plain: %d\n", b);
327 355
328 dcTest_deInitPlatform(); 356 dcTest_deInitPlatform();
329 357
330 return !b; 358 return !r;
331 } 359 }
332 360