Mercurial > pub > dyncall > dyncall
annotate test/callback_suite/main.c @ 507:5a3c07a0f376
cleanups
| author | Tassilo Philipp |
|---|---|
| date | Sat, 09 Apr 2022 14:00:59 +0200 |
| parents | 049e04af13c8 |
| children | f3d44195dbdf |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 | |
| 3 Package: dyncall | |
| 4 Library: test | |
| 5 File: test/callback_suite/main.c | |
| 6 Description: | |
| 7 License: | |
| 8 | |
| 505 | 9 Copyright (c) 2011-2022 Daniel Adler <dadler@uni-goettingen.de>, |
| 0 | 10 Tassilo Philipp <tphilipp@potion-studios.com> |
| 11 | |
| 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 | |
| 14 copyright notice and this permission notice appear in all copies. | |
| 15 | |
| 16 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
| 17 WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
| 18 MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |
| 19 ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
| 20 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
| 21 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |
| 22 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
| 23 | |
| 24 */ | |
| 25 | |
| 487 | 26 #include <stdio.h> |
| 0 | 27 #include <stdlib.h> |
| 505 | 28 #include <assert.h> |
| 29 #include "dyncall_callback.h" | |
| 30 #include "globals.h" | |
| 0 | 31 #include "../common/platformInit.h" |
| 32 #include "../common/platformInit.c" /* Impl. for functions only used in this translation unit */ | |
| 33 | |
| 34 | |
| 505 | 35 |
| 36 | |
| 37 static void print_usage(const char* appName) | |
|
410
7608e34098b0
- cleanups, simplifications, some api clarification, ...
Tassilo Philipp
parents:
281
diff
changeset
|
38 { |
|
7608e34098b0
- cleanups, simplifications, some api clarification, ...
Tassilo Philipp
parents:
281
diff
changeset
|
39 printf("usage:\n\ |
| 505 | 40 %s [ from [to] ]\n\ |
|
410
7608e34098b0
- cleanups, simplifications, some api clarification, ...
Tassilo Philipp
parents:
281
diff
changeset
|
41 where\n\ |
| 505 | 42 from, to: test range (0-based, runs single test if \"to\" is omitted)\n\ |
|
410
7608e34098b0
- cleanups, simplifications, some api clarification, ...
Tassilo Philipp
parents:
281
diff
changeset
|
43 options\n\ |
|
7608e34098b0
- cleanups, simplifications, some api clarification, ...
Tassilo Philipp
parents:
281
diff
changeset
|
44 -h help on usage\n\ |
|
7608e34098b0
- cleanups, simplifications, some api clarification, ...
Tassilo Philipp
parents:
281
diff
changeset
|
45 \n\ |
|
7608e34098b0
- cleanups, simplifications, some api clarification, ...
Tassilo Philipp
parents:
281
diff
changeset
|
46 ", appName); |
|
7608e34098b0
- cleanups, simplifications, some api clarification, ...
Tassilo Philipp
parents:
281
diff
changeset
|
47 } |
|
7608e34098b0
- cleanups, simplifications, some api clarification, ...
Tassilo Philipp
parents:
281
diff
changeset
|
48 |
|
7608e34098b0
- cleanups, simplifications, some api clarification, ...
Tassilo Philipp
parents:
281
diff
changeset
|
49 |
| 505 | 50 /* -------------- this was do_test.c -------------------------- this was do_test.c ------------> */ |
| 51 | |
| 52 static int cmp_values(char type, DCValue* a, DCValue* b) | |
| 53 { | |
| 54 switch(type) | |
| 55 { | |
| 56 case DC_SIGCHAR_BOOL: return (a->B == b->B); | |
| 57 case DC_SIGCHAR_CHAR: return (a->c == b->c); | |
| 58 case DC_SIGCHAR_UCHAR: return (a->C == b->C); | |
| 59 case DC_SIGCHAR_SHORT: return (a->s == b->s); | |
| 60 case DC_SIGCHAR_USHORT: return (a->S == b->S); | |
| 61 case DC_SIGCHAR_INT: return (a->i == b->i); | |
| 62 case DC_SIGCHAR_UINT: return (a->I == b->I); | |
| 63 case DC_SIGCHAR_LONG: return (a->j == b->j); | |
| 64 case DC_SIGCHAR_ULONG: return (a->J == b->J); | |
| 65 case DC_SIGCHAR_LONGLONG: return (a->l == b->l); | |
| 66 case DC_SIGCHAR_ULONGLONG: return (a->L == b->L); | |
| 67 case DC_SIGCHAR_FLOAT: return (a->f == b->f); | |
| 68 case DC_SIGCHAR_DOUBLE: return (a->d == b->d); | |
| 69 case DC_SIGCHAR_POINTER: return (a->p == b->p); | |
| 70 default: assert(0); | |
| 71 } | |
| 72 return 0; | |
| 73 } | |
| 74 | |
| 75 | |
| 76 static int cmp(const char* signature) | |
| 77 { | |
| 78 DCValue ref; | |
| 79 int r = 1; | |
| 80 int pos; | |
| 81 char ch; | |
| 82 | |
| 83 /* check arguments */ | |
| 84 pos = 0; | |
| 85 for(;;) | |
| 86 { | |
| 87 ch = *signature++; | |
| 88 | |
| 89 if(ch == DC_SIGCHAR_CC_PREFIX) { | |
| 507 | 90 ++signature; /* skip cconv prefix */ |
| 505 | 91 continue; |
| 92 } | |
| 93 | |
| 94 if (!ch || ch == DC_SIGCHAR_ENDARG) | |
| 95 break; | |
| 96 | |
| 97 get_reference_arg(&ref, ch, pos); | |
| 98 | |
| 99 if ( !cmp_values( ch, &ref, &Args[pos] ) ) { | |
| 100 r = 0; | |
| 101 printf(" @%d[%c] ", pos, ch); | |
| 102 } | |
| 103 ++pos; | |
| 104 } | |
| 105 | |
| 106 if(ch == DC_SIGCHAR_ENDARG) | |
| 107 ch = *signature; | |
| 108 | |
| 109 /* check result */ | |
| 110 get_reference_result(&ref, ch); | |
| 111 | |
| 112 if (!cmp_values(ch, &ref, &Result)) { | |
| 113 r = 0; | |
| 114 printf(" @-1 "); | |
| 115 } | |
| 116 | |
| 117 return r; | |
| 118 } | |
| 119 | |
| 120 | |
| 121 static char handler(DCCallback* that, DCArgs* input, DCValue* output, void* userdata) | |
| 122 { | |
| 123 const char* signature = (const char*) userdata; | |
| 124 int pos = 0; | |
| 125 char ch; | |
| 0 | 126 |
| 505 | 127 for(;;) { |
| 128 ch = *signature++; | |
| 129 if (!ch || ch == DC_SIGCHAR_ENDARG) break; | |
| 130 Args[pos].L = 0xDEADC0DECAFEBABELL; | |
| 131 switch(ch) { | |
| 132 case DC_SIGCHAR_BOOL: Args[pos].B = dcbArgBool (input); break; | |
| 133 case DC_SIGCHAR_CHAR: Args[pos].c = dcbArgChar (input); break; | |
| 134 case DC_SIGCHAR_UCHAR: Args[pos].C = dcbArgUChar (input); break; | |
| 135 case DC_SIGCHAR_SHORT: Args[pos].s = dcbArgShort (input); break; | |
| 136 case DC_SIGCHAR_USHORT: Args[pos].S = dcbArgUShort (input); break; | |
| 137 case DC_SIGCHAR_INT: Args[pos].i = dcbArgInt (input); break; | |
| 138 case DC_SIGCHAR_UINT: Args[pos].I = dcbArgUInt (input); break; | |
| 139 case DC_SIGCHAR_LONG: Args[pos].j = dcbArgLong (input); break; | |
| 140 case DC_SIGCHAR_ULONG: Args[pos].J = dcbArgULong (input); break; | |
| 141 case DC_SIGCHAR_LONGLONG: Args[pos].l = dcbArgLongLong (input); break; | |
| 142 case DC_SIGCHAR_ULONGLONG:Args[pos].L = dcbArgULongLong(input); break; | |
| 143 case DC_SIGCHAR_FLOAT: Args[pos].f = dcbArgFloat (input); break; | |
| 144 case DC_SIGCHAR_DOUBLE: Args[pos].d = dcbArgDouble (input); break; | |
| 145 case DC_SIGCHAR_STRING: | |
| 146 case DC_SIGCHAR_POINTER: Args[pos].p = dcbArgPointer (input); break; | |
| 147 case DC_SIGCHAR_CC_PREFIX: ++signature; /* skip cconv prefix */ continue; | |
| 148 } | |
| 149 ++pos; | |
| 150 } | |
| 151 | |
| 152 if(ch == DC_SIGCHAR_ENDARG) | |
| 153 ch = *signature; | |
| 154 | |
| 155 /* @@@ unsupported result types or missing retval sig char */ | |
| 156 switch(ch) { | |
| 157 case DC_SIGCHAR_BOOL: | |
| 158 case DC_SIGCHAR_CHAR: | |
| 159 case DC_SIGCHAR_UCHAR: | |
| 160 case DC_SIGCHAR_SHORT: | |
| 161 case DC_SIGCHAR_USHORT: | |
| 162 case DC_SIGCHAR_INT: | |
| 163 case DC_SIGCHAR_UINT: | |
| 164 case DC_SIGCHAR_LONG: | |
| 165 case DC_SIGCHAR_ULONG: | |
| 166 case DC_SIGCHAR_LONGLONG: | |
| 167 case DC_SIGCHAR_ULONGLONG: | |
| 168 case DC_SIGCHAR_FLOAT: | |
| 169 case DC_SIGCHAR_DOUBLE: | |
| 170 case DC_SIGCHAR_STRING: | |
| 171 case DC_SIGCHAR_POINTER: | |
| 172 break; | |
| 173 case DC_SIGCHAR_VOID: | |
| 174 case DC_SIGCHAR_AGGREGATE: | |
| 175 default: | |
| 176 assert(0); return DC_SIGCHAR_VOID; | |
| 177 } | |
| 178 | |
| 179 get_reference_result(output, ch); | |
| 180 | |
| 181 return ch; | |
| 182 } | |
| 183 | |
| 184 | |
| 185 | |
| 186 | |
| 187 static int run_test(int id) | |
| 188 { | |
| 189 const char* signature; | |
| 190 DCCallback* pcb; | |
| 191 int result; | |
| 192 | |
| 193 /* index range: [0,nsigs[ */ | |
| 194 signature = G_sigtab[id]; | |
| 195 printf("%d:%s", id, signature); | |
| 196 | |
| 197 pcb = dcbNewCallback(signature, handler, (void*)signature, NULL); | |
| 198 assert(pcb != NULL); | |
| 199 | |
| 200 /* invoke call */ | |
| 201 G_funtab[id]((void*)pcb); | |
| 202 | |
| 203 result = cmp(signature); | |
| 204 printf(":%d\n", result); | |
| 205 dcbFreeCallback(pcb); | |
| 206 | |
| 207 return result; | |
| 208 } | |
| 209 | |
| 210 | |
| 211 static int run_all(int from, int to) | |
| 212 { | |
| 213 int i; | |
| 214 int failure = 0; | |
| 215 for(i=from; i<=to ;++i) | |
| 216 failure |= !( run_test(i) ); | |
| 217 | |
| 218 return !failure; | |
| 219 } | |
| 0 | 220 |
| 221 | |
| 505 | 222 #define Error(X, Y, N) { fprintf(stderr, X, Y); print_usage(N); exit(1); } |
| 0 | 223 |
| 487 | 224 int main(int argc, char* argv[]) |
| 0 | 225 { |
| 505 | 226 int from = 0, to = G_ncases-1; |
| 227 int i, pos = 0, total; | |
| 487 | 228 |
| 0 | 229 dcTest_initPlatform(); |
| 230 | |
| 231 | |
| 505 | 232 /* parse args */ |
| 233 for(i=1; i<argc; ++i) | |
| 487 | 234 { |
| 235 if(argv[i][0] == '-') | |
|
495
45ac093ca822
- test/callback_suite: make it use shared random sig generator from call_suite and call_suite_aggrs
Tassilo Philipp
parents:
487
diff
changeset
|
236 { |
| 0 | 237 switch(argv[i][1]) { |
| 487 | 238 case 'h': |
| 239 case '?': | |
| 505 | 240 print_usage(argv[0]); |
|
495
45ac093ca822
- test/callback_suite: make it use shared random sig generator from call_suite and call_suite_aggrs
Tassilo Philipp
parents:
487
diff
changeset
|
241 return 0; |
| 505 | 242 default: |
| 243 Error("invalid option: %s\n\n", argv[i], argv[0]); | |
| 0 | 244 } |
| 245 } | |
| 487 | 246 switch(pos++) { |
| 505 | 247 case 0: from = to = atoi(argv[i]); break; |
| 248 case 1: to = atoi(argv[i]); break; | |
| 487 | 249 default: Error("too many arguments (%d given, 2 allowed)\n\n", pos, argv[0]); |
| 0 | 250 } |
| 251 } | |
| 505 | 252 if(from < 0 || to >= G_ncases || from > to) |
| 253 Error("invalid arguments (provided from or to not in order or outside of range [0,%d])\n\n", G_ncases-1, argv[0]); | |
| 0 | 254 |
| 255 | |
| 505 | 256 init_test_data(); |
| 257 total = run_all(from, to); | |
| 258 deinit_test_data(); | |
| 487 | 259 |
| 505 | 260 printf("result: callback_suite: %d\n", total); |
| 0 | 261 |
| 262 dcTest_deInitPlatform(); | |
| 263 | |
| 505 | 264 return !total; |
| 0 | 265 } |
| 266 |