begriffs open source - libtap/blob

1 /*

2 libtap - Write tests in C

4 This file is licensed under the LGPL

5 */

7 #define _DEFAULT_SOURCE 1

9 #include <stdio.h>

10 #include <stdlib.h>

11 #include <stdarg.h>

12 #include <string.h>

13 #include "tap.h"

15 static int expected_tests = NO_PLAN;

16 static int failed_tests;

17 static int current_test;

18 static char *todo_mesg;

20 static char *

21 vstrdupf (const char *fmt, va_list args) {

22 char *str;

23 int size;

24 va_list args2;

25 va_copy(args2, args);

26 if (!fmt)

27 fmt = "";

28 size = vsnprintf(NULL, 0, fmt, args2) + 2;

29 str = malloc(size);

30 if (!str) {

31 perror("malloc error");

32 exit(1);

33 }

34 vsprintf(str, fmt, args);

35 va_end(args2);

36 return str;

37 }

39 void

40 tap_plan (int tests, const char *fmt, ...) {

41 expected_tests = tests;

42 if (tests == SKIP_ALL) {

43 char *why;

44 va_list args;

45 va_start(args, fmt);

46 why = vstrdupf(fmt, args);

47 va_end(args);

48 printf("1..0 ");

49 note("SKIP %s\n", why);

50 exit(0);

51 }

52 if (tests != NO_PLAN) {

53 printf("1..%d\n", tests);

54 }

55 }

57 int

58 vok_at_loc (const char *file, int line, int test, const char *fmt,

59 va_list args)

60 {

61 char *name = vstrdupf(fmt, args);

62 if (!test) {

63 printf(AC_BAD("not ok") " %d", ++current_test);

64 }

65 else {

66 printf(AC_OK("ok") " %d", ++current_test);

67 }

68 if (*name)

69 printf(" - %s", name);

70 if (todo_mesg) {

71 printf(" # TODO");

72 if (*todo_mesg)

73 printf(" %s", todo_mesg);

74 }

75 printf("\n");

76 if (!test) {

77 fprintf(stderr, "# Failed ");

78 if (todo_mesg)

79 fprintf(stderr, "(TODO) ");

80 fprintf(stderr, "test ");

81 if (*name)

82 fprintf(stderr, "'%s'\n# ", name);

83 fprintf(stderr, "at %s line %d.\n", file, line);

84 if (!todo_mesg)

85 failed_tests++;

86 }

87 free(name);

88 return test;

89 }

91 int

92 ok_at_loc (const char *file, int line, int test, const char *fmt, ...) {

93 va_list args;

94 va_start(args, fmt);

95 vok_at_loc(file, line, test, fmt, args);

96 va_end(args);

97 return test;

98 }

100 static int

101 mystrcmp (const char *a, const char *b) {

102 return a == b ? 0 : !a ? -1 : !b ? 1 : strcmp(a, b);

103 }

104

105 #define eq(a, b) (!mystrcmp(a, b))

106 #define ne(a, b) (mystrcmp(a, b))

107

108 int

109 is_at_loc (const char *file, int line, const char *got, const char *expected,

110 const char *fmt, ...)

111 {

112 int test = eq(got, expected);

113 va_list args;

114 va_start(args, fmt);

115 vok_at_loc(file, line, test, fmt, args);

116 va_end(args);

117 if (!test) {

118 diag(" got: '%s'", got);

119 diag(" expected: '%s'", expected);

120 }

121 return test;

122 }

123

124 int

125 isnt_at_loc (const char *file, int line, const char *got, const char *expected,

126 const char *fmt, ...)

127 {

128 int test = ne(got, expected);

129 va_list args;

130 va_start(args, fmt);

131 vok_at_loc(file, line, test, fmt, args);

132 va_end(args);

133 if (!test) {

134 diag(" got: '%s'", got);

135 diag(" expected: anything else");

136 }

137 return test;

138 }

139

140 int

141 cmp_ok_at_loc (const char *file, int line, int a, const char *op, int b,

142 const char *fmt, ...)

143 {

144 int test = eq(op, "||") ? a || b

145 : eq(op, "&&") ? a && b

146 : eq(op, "|") ? a | b

147 : eq(op, "^") ? a ^ b

148 : eq(op, "&") ? a & b

149 : eq(op, "==") ? a == b

150 : eq(op, "!=") ? a != b

151 : eq(op, "<") ? a < b

152 : eq(op, ">") ? a > b

153 : eq(op, "<=") ? a <= b

154 : eq(op, ">=") ? a >= b

155 : eq(op, "<<") ? a << b

156 : eq(op, ">>") ? a >> b

157 : eq(op, "+") ? a + b

158 : eq(op, "-") ? a - b

159 : eq(op, "*") ? a * b

160 : eq(op, "/") ? a / b

161 : eq(op, "%") ? a % b

162 : diag("unrecognized operator '%s'", op);

163 va_list args;

164 va_start(args, fmt);

165 vok_at_loc(file, line, test, fmt, args);

166 va_end(args);

167 if (!test) {

168 diag(" %d", a);

169 diag(" %s", op);

170 diag(" %d", b);

171 }

172 return test;

173 }

174

175 static int

176 find_mem_diff (const char *a, const char *b, size_t n, size_t *offset) {

177 size_t i;

178 if (a == b)

179 return 0;

180 if (!a || !b)

181 return 2;

182 for (i = 0; i < n; i++) {

183 if (a[i] != b[i]) {

184 *offset = i;

185 return 1;

186 }

187 }

188 return 0;

189 }

190

191 int

192 cmp_mem_at_loc (const char *file, int line, const void *got,

193 const void *expected, size_t n, const char *fmt, ...)

194 {

195 size_t offset;

196 int diff = find_mem_diff(got, expected, n, &offset);

197 va_list args;

198 va_start(args, fmt);

199 vok_at_loc(file, line, !diff, fmt, args);

200 va_end(args);

201 if (diff == 1) {

202 diag(" Difference starts at offset %d", offset);

203 diag(" got: 0x%02x", ((unsigned char *)got)[offset]);

204 diag(" expected: 0x%02x", ((unsigned char *)expected)[offset]);

205 }

206 else if (diff == 2) {

207 diag(" got: %s", got ? "not NULL" : "NULL");

208 diag(" expected: %s", expected ? "not NULL" : "NULL");

209 }

210 return !diff;

211 }

212

213 static void

214 vdiag_to_fh (FILE *fh, const char *fmt, va_list args) {

215 char *mesg, *line;

216 int i;

217 if (!fmt)

218 return;

219 mesg = vstrdupf(fmt, args);

220 line = mesg;

221 for (i = 0; *line; i++) {

222 char c = mesg[i];

223 if (!c || c == '\n') {

224 mesg[i] = '\0';

225 fprintf(fh, "# %s\n", line);

226 if (!c)

227 break;

228 mesg[i] = c;

229 line = mesg + i + 1;

230 }

231 }

232 free(mesg);

233 return;

234 }

235

236 int

237 diag (const char *fmt, ...) {

238 va_list args;

239 va_start(args, fmt);

240 vdiag_to_fh(stderr, fmt, args);

241 va_end(args);

242 return 0;

243 }

244

245 int

246 note (const char *fmt, ...) {

247 va_list args;

248 va_start(args, fmt);

249 vdiag_to_fh(stdout, fmt, args);

250 va_end(args);

251 return 0;

252 }

253

254 int

255 exit_status () {

256 int retval = 0;

257 if (expected_tests == NO_PLAN) {

258 printf("1..%d\n", current_test);

259 }

260 else if (current_test != expected_tests) {

261 diag("Looks like you planned %d test%s but ran %d.",

262 expected_tests, expected_tests > 1 ? "s" : "", current_test);

263 retval = 2;

264 }

265 if (failed_tests) {

266 diag("Looks like you failed %d test%s of %d run.",

267 failed_tests, failed_tests > 1 ? "s" : "", current_test);

268 retval = 1;

269 }

270 return retval;

271 }

272

273 int

274 bail_out (int ignore, const char *fmt, ...) {

275 va_list args;

276 va_start(args, fmt);

277 printf("Bail out! ");

278 vprintf(fmt, args);

279 printf("\n");

280 va_end(args);

281 exit(255);

282 return 0;

283 }

284

285 void

286 tap_skip (int n, const char *fmt, ...) {

287 char *why;

288 va_list args;

289 va_start(args, fmt);

290 why = vstrdupf(fmt, args);

291 va_end(args);

292 while (n --> 0) {

293 printf("ok %d ", ++current_test);

294 note("skip %s\n", why);

295 }

296 free(why);

297 }

298

299 void

300 tap_todo (int ignore, const char *fmt, ...) {

301 va_list args;

302 va_start(args, fmt);

303 todo_mesg = vstrdupf(fmt, args);

304 va_end(args);

305 }

306

307 void

308 tap_end_todo () {

309 free(todo_mesg);

310 todo_mesg = NULL;

311 }

312

313 #ifndef _WIN32

314 #include <sys/mman.h>

315 #include <sys/param.h>

316 #include <regex.h>

317

318 #if defined __APPLE__ || defined BSD

319 #define MAP_ANONYMOUS MAP_ANON

320 #endif

321

322 /* Create a shared memory int to keep track of whether a piece of code executed

323 dies. to be used in the dies_ok and lives_ok macros. */

324 int

325 tap_test_died (int status) {

326 static int *test_died = NULL;

327 int prev;

328 if (!test_died) {

329 test_died = mmap(0, sizeof (int), PROT_READ | PROT_WRITE,

330 MAP_SHARED | MAP_ANONYMOUS, -1, 0);

331 *test_died = 0;

332 }

333 prev = *test_died;

334 *test_died = status;

335 return prev;

336 }

337

338 int

339 like_at_loc (int for_match, const char *file, int line, const char *got,

340 const char *expected, const char *fmt, ...)

341 {

342 int test;

343 regex_t re;

344 va_list args;

345 int err = regcomp(&re, expected, REG_EXTENDED);

346 if (err) {

347 char errbuf[256];

348 regerror(err, &re, errbuf, sizeof errbuf);

349 fprintf(stderr, "Unable to compile regex '%s': %s at %s line %d\n",

350 expected, errbuf, file, line);

351 exit(255);

352 }

353 err = regexec(&re, got, 0, NULL, 0);

354 regfree(&re);

355 test = for_match ? !err : err;

356 va_start(args, fmt);

357 vok_at_loc(file, line, test, fmt, args);

358 va_end(args);

359 if (!test) {

360 if (for_match) {

361 diag(" '%s'", got);

362 diag(" doesn't match: '%s'", expected);

363 }

364 else {

365 diag(" '%s'", got);

366 diag(" matches: '%s'", expected);

367 }

368 }

369 return test;

370 }

371 #endif