Merge build trunk
[awesomized/libmemcached] / libtest / unittest.cc
1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
2 *
3 * libtest
4 *
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 3 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22
23 #include <config.h>
24
25 #include <libtest/test.hpp>
26
27 #if defined(LIBTEST_WITH_LIBMEMCACHED_SUPPORT) && LIBTEST_WITH_LIBMEMCACHED_SUPPORT
28 #include <libmemcached/memcached.h>
29 #endif
30
31 #if defined(LIBTEST_WITH_LIBGEARMAN_SUPPORT) && LIBTEST_WITH_LIBGEARMAN_SUPPORT
32 #include <libgearman/gearman.h>
33 #endif
34
35 #include <cstdlib>
36 #include <unistd.h>
37
38 using namespace libtest;
39
40 static test_return_t LIBTOOL_COMMAND_test(void *)
41 {
42 test_true(getenv("LIBTOOL_COMMAND"));
43 return TEST_SUCCESS;
44 }
45
46 static test_return_t VALGRIND_COMMAND_test(void *)
47 {
48 test_true(getenv("VALGRIND_COMMAND"));
49 return TEST_SUCCESS;
50 }
51
52 static test_return_t HELGRIND_COMMAND_test(void *)
53 {
54 test_true(getenv("HELGRIND_COMMAND"));
55 return TEST_SUCCESS;
56 }
57
58 static test_return_t GDB_COMMAND_test(void *)
59 {
60 test_true(getenv("GDB_COMMAND"));
61 return TEST_SUCCESS;
62 }
63
64 static test_return_t test_success_equals_one_test(void *)
65 {
66 test_skip(HAVE_LIBMEMCACHED, true);
67 #if defined(HAVE_LIBMEMCACHED) && HAVE_LIBMEMCACHED
68 test_zero(MEMCACHED_SUCCESS);
69 #endif
70 return TEST_SUCCESS;
71 }
72
73 static test_return_t test_success_test(void *)
74 {
75 return TEST_SUCCESS;
76 }
77
78 static test_return_t test_failure_test(void *)
79 {
80 return TEST_SKIPPED; // Only run this when debugging
81
82 test_compare(1, 2);
83 return TEST_SUCCESS;
84 }
85
86 static test_return_t local_test(void *)
87 {
88 if (getenv("LIBTEST_LOCAL"))
89 {
90 test_true(test_is_local());
91 }
92 else
93 {
94 test_false(test_is_local());
95 }
96
97 return TEST_SUCCESS;
98 }
99
100 static test_return_t local_not_test(void *)
101 {
102 return TEST_SKIPPED;
103
104 std::string temp;
105
106 const char *ptr;
107 if ((ptr= getenv("LIBTEST_LOCAL")) == NULL)
108 {
109 temp.append(ptr);
110 }
111
112 // unsetenv() will cause issues with valgrind
113 _compare(__FILE__, __LINE__, __func__, 0, unsetenv("LIBTEST_LOCAL"));
114 test_compare(0, unsetenv("LIBTEST_LOCAL"));
115 test_false(test_is_local());
116
117 test_compare(0, setenv("LIBTEST_LOCAL", "1", 1));
118 test_true(test_is_local());
119
120 if (temp.empty())
121 {
122 test_compare(0, unsetenv("LIBTEST_LOCAL"));
123 }
124 else
125 {
126 char *old_string= strdup(temp.c_str());
127 test_compare(0, setenv("LIBTEST_LOCAL", old_string, 1));
128 }
129
130 return TEST_SUCCESS;
131 }
132
133 static test_return_t var_exists_test(void *)
134 {
135 test_compare(0, access("var", R_OK | W_OK | X_OK));
136 return TEST_SUCCESS;
137 }
138
139 static test_return_t var_tmp_exists_test(void *)
140 {
141 test_compare(0, access("var/tmp", R_OK | W_OK | X_OK));
142 return TEST_SUCCESS;
143 }
144
145 static test_return_t var_run_exists_test(void *)
146 {
147 test_compare(0, access("var/run", R_OK | W_OK | X_OK));
148 return TEST_SUCCESS;
149 }
150
151 static test_return_t var_log_exists_test(void *)
152 {
153 test_compare(0, access("var/log", R_OK | W_OK | X_OK));
154 return TEST_SUCCESS;
155 }
156
157 static test_return_t var_tmp_test(void *)
158 {
159 FILE *file= fopen("var/tmp/junk", "w+");
160 char buffer[1024];
161 const char *dir= getcwd(buffer, sizeof(buffer));
162 test_true_got(file, dir);
163 fclose(file);
164 return TEST_SUCCESS;
165 }
166
167 static test_return_t var_run_test(void *)
168 {
169 FILE *file= fopen("var/run/junk", "w+");
170 test_true(file);
171 fclose(file);
172 return TEST_SUCCESS;
173 }
174
175 static test_return_t var_log_test(void *)
176 {
177 FILE *file= fopen("var/log/junk", "w+");
178 test_true(file);
179 fclose(file);
180 return TEST_SUCCESS;
181 }
182
183 static test_return_t var_tmp_rm_test(void *)
184 {
185 test_true(unlink("var/tmp/junk") == 0);
186 return TEST_SUCCESS;
187 }
188
189 static test_return_t var_run_rm_test(void *)
190 {
191 test_true(unlink("var/run/junk") == 0);
192 return TEST_SUCCESS;
193 }
194
195 static test_return_t var_log_rm_test(void *)
196 {
197 test_true(unlink("var/log/junk") == 0);
198 return TEST_SUCCESS;
199 }
200
201 static test_return_t _compare_test_return_t_test(void *)
202 {
203 test_compare(TEST_SUCCESS, TEST_SUCCESS);
204
205 return TEST_SUCCESS;
206 }
207
208 static test_return_t _compare_memcached_return_t_test(void *)
209 {
210 test_skip(HAVE_LIBMEMCACHED, true);
211 #if defined(HAVE_LIBMEMCACHED) && HAVE_LIBMEMCACHED
212 test_compare(MEMCACHED_SUCCESS, MEMCACHED_SUCCESS);
213 #endif
214
215 return TEST_SUCCESS;
216 }
217
218 static test_return_t _compare_gearman_return_t_test(void *)
219 {
220 test_skip(HAVE_LIBGEARMAN, true);
221 #if defined(HAVE_LIBGEARMAN) && HAVE_LIBGEARMAN
222 test_compare(GEARMAN_SUCCESS, GEARMAN_SUCCESS);
223 #endif
224
225 return TEST_SUCCESS;
226 }
227
228 static test_return_t gearmand_cycle_test(void *object)
229 {
230 server_startup_st *servers= (server_startup_st*)object;
231 test_true(servers);
232
233 if (GEARMAND_BINARY)
234 {
235 if (HAVE_LIBGEARMAN)
236 {
237 test_true(has_gearmand_binary());
238 const char *argv[1]= { "cycle_gearmand" };
239 test_true(server_startup(*servers, "gearmand", 9999, 1, argv));
240
241 return TEST_SUCCESS;
242 }
243 }
244
245 return TEST_SKIPPED;
246 }
247
248 static test_return_t memcached_cycle_test(void *object)
249 {
250 server_startup_st *servers= (server_startup_st*)object;
251 test_true(servers);
252
253 if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED)
254 {
255 test_true(has_memcached_binary());
256 const char *argv[1]= { "cycle_memcached" };
257 test_true(server_startup(*servers, "memcached", 9998, 1, argv));
258
259 return TEST_SUCCESS;
260 }
261
262 return TEST_SKIPPED;
263 }
264
265 static test_return_t memcached_socket_cycle_test(void *object)
266 {
267 server_startup_st *servers= (server_startup_st*)object;
268 test_true(servers);
269
270 if (MEMCACHED_BINARY)
271 {
272 if (HAVE_LIBMEMCACHED)
273 {
274 test_true(has_memcached_binary());
275 const char *argv[1]= { "cycle_memcached" };
276 test_true(servers->start_socket_server("memcached", 9997, 1, argv));
277
278 return TEST_SUCCESS;
279 }
280 }
281
282 return TEST_SKIPPED;
283 }
284
285 static test_return_t memcached_sasl_test(void *object)
286 {
287 server_startup_st *servers= (server_startup_st*)object;
288 test_true(servers);
289
290 if (getenv("TESTS_ENVIRONMENT"))
291 {
292 return TEST_SKIPPED;
293 }
294
295 if (MEMCACHED_SASL_BINARY)
296 {
297 if (HAVE_LIBMEMCACHED)
298 {
299 test_true(has_memcached_sasl_binary());
300 const char *argv[1]= { "cycle_memcached_sasl" };
301 test_true(server_startup(*servers, "memcached-sasl", 9996, 1, argv));
302
303 return TEST_SUCCESS;
304 }
305 }
306
307 return TEST_SKIPPED;
308 }
309
310 static test_return_t wait_BINARY(void *)
311 {
312 const char *args[]= { "--quiet", 0 };
313
314 test_true(exec_cmdline("libtest/wait", args));
315
316 return TEST_SUCCESS;
317 }
318
319 static test_return_t wait_help_BINARY(void *)
320 {
321 const char *args[]= { "--quiet", "--help", 0 };
322
323 test_true(exec_cmdline("libtest/wait", args));
324
325 return TEST_SUCCESS;
326 }
327
328 static test_return_t wait_version_BINARY(void *)
329 {
330 const char *args[]= { "--quiet", "--version", 0 };
331
332 test_true(exec_cmdline("libtest/wait", args));
333
334 return TEST_SUCCESS;
335 }
336
337 test_st gearmand_tests[] ={
338 #if 0
339 {"pause", 0, pause_test },
340 #endif
341 {"gearmand startup-shutdown", 0, gearmand_cycle_test },
342 {0, 0, 0}
343 };
344
345 test_st memcached_tests[] ={
346 {"memcached startup-shutdown", 0, memcached_cycle_test },
347 {"memcached(socket file) startup-shutdown", 0, memcached_socket_cycle_test },
348 {"memcached_sasl() startup-shutdown", 0, memcached_sasl_test },
349 {0, 0, 0}
350 };
351
352 test_st environment_tests[] ={
353 {"LIBTOOL_COMMAND", 0, LIBTOOL_COMMAND_test },
354 {"VALGRIND_COMMAND", 0, VALGRIND_COMMAND_test },
355 {"HELGRIND_COMMAND", 0, HELGRIND_COMMAND_test },
356 {"GDB_COMMAND", 0, GDB_COMMAND_test },
357 {0, 0, 0}
358 };
359
360 test_st tests_log[] ={
361 {"TEST_SUCCESS", false, test_success_test },
362 {"TEST_FAILURE", false, test_failure_test },
363 {"TEST_SUCCESS == 0", false, test_success_equals_one_test },
364 {0, 0, 0}
365 };
366
367 test_st local_log[] ={
368 {"test_is_local()", 0, local_test },
369 {"test_is_local(NOT)", 0, local_not_test },
370 {0, 0, 0}
371 };
372
373 test_st directories_tests[] ={
374 {"var exists", 0, var_exists_test },
375 {"var/tmp exists", 0, var_tmp_exists_test },
376 {"var/run exists", 0, var_run_exists_test },
377 {"var/log exists", 0, var_log_exists_test },
378 {"var/tmp", 0, var_tmp_test },
379 {"var/run", 0, var_run_test },
380 {"var/log", 0, var_log_test },
381 {"var/tmp rm", 0, var_tmp_rm_test },
382 {"var/run rm", 0, var_run_rm_test },
383 {"var/log rm", 0, var_log_rm_test },
384 {0, 0, 0}
385 };
386
387 test_st comparison_tests[] ={
388 {"_compare(test_return_t)", 0, _compare_test_return_t_test },
389 {"_compare(memcached_return_t)", 0, _compare_memcached_return_t_test },
390 {"_compare(gearman_return_t)", 0, _compare_gearman_return_t_test },
391 {0, 0, 0}
392 };
393
394 test_st cmdline_tests[] ={
395 {"wait --quiet", 0, wait_BINARY },
396 {"wait --quiet --help", 0, wait_help_BINARY },
397 {"wait --quiet --version", 0, wait_version_BINARY },
398 {0, 0, 0}
399 };
400
401 collection_st collection[] ={
402 {"environment", 0, 0, environment_tests},
403 {"return values", 0, 0, tests_log},
404 {"local", 0, 0, local_log},
405 {"directories", 0, 0, directories_tests},
406 {"comparison", 0, 0, comparison_tests},
407 {"gearmand", 0, 0, gearmand_tests},
408 {"memcached", 0, 0, memcached_tests},
409 {"cmdline", 0, 0, cmdline_tests},
410 {0, 0, 0, 0}
411 };
412
413 static void *world_create(server_startup_st& servers, test_return_t&)
414 {
415 return &servers;
416 }
417
418 void get_world(Framework *world)
419 {
420 world->collections= collection;
421 world->_create= world_create;
422 }