ee743983fffa7f73e3422c698212efa495afc816
[awesomized/libmemcached] / libtest / test.cc
1 /* uTest
2 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
3 * Copyright (C) 2006-2009 Brian Aker
4 * All rights reserved.
5 *
6 * Use and distribution licensed under the BSD license. See
7 * the COPYING file in the parent directory for full text.
8 */
9
10
11 #include <libtest/common.h>
12
13 #include <cassert>
14 #include <cstdlib>
15 #include <cstring>
16 #include <sys/time.h>
17 #include <sys/types.h>
18 #include <sys/stat.h>
19 #include <sys/wait.h>
20 #include <unistd.h>
21 #include <ctime>
22 #include <fnmatch.h>
23 #include <iostream>
24
25 #include <libtest/stats.h>
26
27 #ifndef __INTEL_COMPILER
28 #pragma GCC diagnostic ignored "-Wold-style-cast"
29 #endif
30
31 static in_port_t global_port= 0;
32
33 in_port_t default_port()
34 {
35 assert(global_port);
36 return global_port;
37 }
38
39 void set_default_port(in_port_t port)
40 {
41 global_port= port;
42 }
43
44 static void stats_print(Stats *stats)
45 {
46 std::cout << "\tTotal Collections\t\t\t\t" << stats->collection_total << std::endl;
47 std::cout << "\tFailed Collections\t\t\t\t" << stats->collection_failed << std::endl;
48 std::cout << "\tSkipped Collections\t\t\t\t" << stats->collection_skipped << std::endl;
49 std::cout << "\tSucceeded Collections\t\t\t\t" << stats->collection_success << std::endl;
50 std::cout << std::endl;
51 std::cout << "Total\t\t\t\t" << stats->total << std::endl;
52 std::cout << "\tFailed\t\t\t" << stats->failed << std::endl;
53 std::cout << "\tSkipped\t\t\t" << stats->skipped << std::endl;
54 std::cout << "\tSucceeded\t\t" << stats->success << std::endl;
55 }
56
57 static long int timedif(struct timeval a, struct timeval b)
58 {
59 long us, s;
60
61 us = (long)(a.tv_usec - b.tv_usec);
62 us /= 1000;
63 s = (long)(a.tv_sec - b.tv_sec);
64 s *= 1000;
65 return s + us;
66 }
67
68 const char *test_strerror(test_return_t code)
69 {
70 switch (code) {
71 case TEST_SUCCESS:
72 return "ok";
73
74 case TEST_FAILURE:
75 return "failed";
76
77 case TEST_MEMORY_ALLOCATION_FAILURE:
78 return "memory allocation";
79
80 case TEST_SKIPPED:
81 return "skipped";
82
83 case TEST_FATAL:
84 break;
85 }
86
87 return "failed";
88 }
89
90 void create_core(void)
91 {
92 if (getenv("LIBMEMCACHED_NO_COREDUMP") == NULL)
93 {
94 pid_t pid= fork();
95
96 if (pid == 0)
97 {
98 abort();
99 }
100 else
101 {
102 while (waitpid(pid, NULL, 0) != pid) {};
103 }
104 }
105 }
106
107
108 static test_return_t _runner_default(test_callback_fn func, void *p)
109 {
110 if (func)
111 {
112 return func(p);
113 }
114
115 return TEST_SUCCESS;
116 }
117
118 static Runner defualt_runners= {
119 _runner_default,
120 _runner_default,
121 _runner_default
122 };
123
124 static test_return_t _default_callback(void *p)
125 {
126 (void)p;
127
128 return TEST_SUCCESS;
129 }
130
131 Framework::Framework() :
132 collections(NULL),
133 _create(NULL),
134 _destroy(NULL),
135 collection_startup(_default_callback),
136 collection_shutdown(_default_callback),
137 _on_error(NULL),
138 runner(&defualt_runners)
139 {
140 }
141
142
143 int main(int argc, char *argv[])
144 {
145 Framework world;
146
147 Stats stats;
148
149 get_world(&world);
150
151 if (not world.runner)
152 {
153 world.runner= &defualt_runners;
154 }
155
156 test_return_t error;
157 void *world_ptr= world.create(&error);
158 if (test_failed(error))
159 {
160 return EXIT_FAILURE;
161 }
162
163 char *collection_to_run= NULL;
164 if (argc > 1)
165 {
166 collection_to_run= argv[1];
167 }
168 else if (getenv("TEST_COLLECTION"))
169 {
170 collection_to_run= getenv("TEST_COLLECTION");
171 }
172
173 if (collection_to_run)
174 {
175 std::cout << "Only testing " << collection_to_run << std::endl;
176 }
177
178 char *wildcard= NULL;
179 if (argc == 3)
180 {
181 wildcard= argv[2];
182 }
183
184 for (collection_st *next= world.collections; next->name; next++)
185 {
186 test_return_t collection_rc= TEST_SUCCESS;
187 bool failed= false;
188 bool skipped= false;
189
190 if (collection_to_run && fnmatch(collection_to_run, next->name, 0))
191 continue;
192
193 stats.collection_total++;
194
195 collection_rc= world.startup(world_ptr);
196
197 if (collection_rc == TEST_SUCCESS and next->pre)
198 {
199 collection_rc= world.runner->pre(next->pre, world_ptr);
200 }
201
202 switch (collection_rc)
203 {
204 case TEST_SUCCESS:
205 std::cerr << std::endl << next->name << std::endl << std::endl;
206 break;
207
208 case TEST_FATAL:
209 case TEST_FAILURE:
210 std::cerr << std::endl << next->name << " [ failed ]" << std::endl << std::endl;
211 stats.collection_failed++;
212 goto cleanup;
213
214 case TEST_SKIPPED:
215 std::cerr << std::endl << next->name << " [ skipping ]" << std::endl << std::endl;
216 stats.collection_skipped++;
217 goto cleanup;
218
219 case TEST_MEMORY_ALLOCATION_FAILURE:
220 test_assert(0, "Allocation failure, or unknown return");
221 }
222
223 for (test_st *run= next->tests; run->name; run++)
224 {
225 struct timeval start_time, end_time;
226 long int load_time= 0;
227
228 if (wildcard && fnmatch(wildcard, run->name, 0))
229 {
230 continue;
231 }
232
233 std::cerr << "\tTesting " << run->name;
234
235 world.item.startup(world_ptr);
236
237 world.item.flush(world_ptr, run);
238
239 world.item.pre(world_ptr);
240
241 test_return_t return_code;
242 { // Runner Code
243 gettimeofday(&start_time, NULL);
244 return_code= world.runner->run(run->test_fn, world_ptr);
245 gettimeofday(&end_time, NULL);
246 load_time= timedif(end_time, start_time);
247 }
248
249 world.item.post(world_ptr);
250
251 stats.total++;
252
253 std::cerr << "\t\t\t\t\t";
254
255 switch (return_code)
256 {
257 case TEST_SUCCESS:
258 std::cerr << load_time / 1000 << "." << load_time % 1000;
259 stats.success++;
260 break;
261
262 case TEST_FATAL:
263 case TEST_FAILURE:
264 stats.failed++;
265 failed= true;
266 break;
267
268 case TEST_SKIPPED:
269 stats.skipped++;
270 skipped= true;
271 break;
272
273 case TEST_MEMORY_ALLOCATION_FAILURE:
274 test_assert(0, "Memory Allocation Error");
275 }
276
277 std::cerr << "[ " << test_strerror(return_code) << " ]" << std::endl;
278
279 if (test_failed(world.on_error(return_code, world_ptr)))
280 {
281 break;
282 }
283 }
284
285 if (next->post && world.runner->post)
286 {
287 (void) world.runner->post(next->post, world_ptr);
288 }
289
290 if (failed == 0 and skipped == 0)
291 {
292 stats.collection_success++;
293 }
294 cleanup:
295
296 world.shutdown(world_ptr);
297 }
298
299 if (stats.collection_failed || stats.collection_skipped)
300 {
301 std::cerr << std::endl << std::endl << "Some test failures and/or skipped test occurred." << std::endl << std::endl;
302 #if 0
303 print_failed_test();
304 #endif
305 }
306 else
307 {
308 std::cout << std::endl << std::endl << "All tests completed successfully." << std::endl << std::endl;
309 }
310
311 if (test_failed(world.destroy(world_ptr)))
312 {
313 stats.failed++; // We do this to make our exit code return EXIT_FAILURE
314 }
315
316 stats_print(&stats);
317
318 return stats.failed == 0 ? 0 : 1;
319 }