Updating for 1.0.2 release
[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 (HAVE_LIBGEARMAN and GEARMAND_BINARY)
234 {
235 test_true(has_gearmand_binary());
236 const char *argv[1]= { "cycle_gearmand" };
237 test_true(server_startup(*servers, "gearmand", 9999, 1, argv));
238
239 return TEST_SUCCESS;
240 }
241
242 return TEST_SKIPPED;
243 }
244
245 static test_return_t memcached_cycle_test(void *object)
246 {
247 server_startup_st *servers= (server_startup_st*)object;
248 test_true(servers);
249
250 if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED)
251 {
252 test_true(has_memcached_binary());
253 const char *argv[1]= { "cycle_memcached" };
254 test_true(server_startup(*servers, "memcached", 9998, 1, argv));
255
256 return TEST_SUCCESS;
257 }
258
259 return TEST_SKIPPED;
260 }
261
262 static test_return_t memcached_socket_cycle_test(void *object)
263 {
264 server_startup_st *servers= (server_startup_st*)object;
265 test_true(servers);
266
267 if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED)
268 {
269 test_true(has_memcached_binary());
270 const char *argv[1]= { "cycle_memcached" };
271 test_true(servers->start_socket_server("memcached", 9997, 1, argv));
272
273 return TEST_SUCCESS;
274 }
275
276 return TEST_SKIPPED;
277 }
278
279 static test_return_t memcached_sasl_test(void *object)
280 {
281 server_startup_st *servers= (server_startup_st*)object;
282 test_true(servers);
283
284 if (getenv("TESTS_ENVIRONMENT"))
285 {
286 return TEST_SKIPPED;
287 }
288
289 if (MEMCACHED_SASL_BINARY and HAVE_LIBMEMCACHED)
290 {
291 test_true(has_memcached_sasl_binary());
292 const char *argv[1]= { "cycle_memcached_sasl" };
293 test_true(server_startup(*servers, "memcached-sasl", 9996, 1, argv));
294
295 return TEST_SUCCESS;
296 }
297
298 return TEST_SKIPPED;
299 }
300
301 static test_return_t wait_BINARY(void *)
302 {
303 const char *args[]= { "--quiet", 0 };
304
305 test_true(exec_cmdline("libtest/wait", args));
306
307 return TEST_SUCCESS;
308 }
309
310 static test_return_t wait_help_BINARY(void *)
311 {
312 const char *args[]= { "--quiet", "--help", 0 };
313
314 test_true(exec_cmdline("libtest/wait", args));
315
316 return TEST_SUCCESS;
317 }
318
319 static test_return_t wait_version_BINARY(void *)
320 {
321 const char *args[]= { "--quiet", "--version", 0 };
322
323 test_true(exec_cmdline("libtest/wait", args));
324
325 return TEST_SUCCESS;
326 }
327
328 test_st gearmand_tests[] ={
329 #if 0
330 {"pause", 0, pause_test },
331 #endif
332 {"gearmand startup-shutdown", 0, gearmand_cycle_test },
333 {0, 0, 0}
334 };
335
336 test_st memcached_tests[] ={
337 {"memcached startup-shutdown", 0, memcached_cycle_test },
338 {"memcached(socket file) startup-shutdown", 0, memcached_socket_cycle_test },
339 {"memcached_sasl() startup-shutdown", 0, memcached_sasl_test },
340 {0, 0, 0}
341 };
342
343 test_st environment_tests[] ={
344 {"LIBTOOL_COMMAND", 0, LIBTOOL_COMMAND_test },
345 {"VALGRIND_COMMAND", 0, VALGRIND_COMMAND_test },
346 {"HELGRIND_COMMAND", 0, HELGRIND_COMMAND_test },
347 {"GDB_COMMAND", 0, GDB_COMMAND_test },
348 {0, 0, 0}
349 };
350
351 test_st tests_log[] ={
352 {"TEST_SUCCESS", false, test_success_test },
353 {"TEST_FAILURE", false, test_failure_test },
354 {"TEST_SUCCESS == 0", false, test_success_equals_one_test },
355 {0, 0, 0}
356 };
357
358 test_st local_log[] ={
359 {"test_is_local()", 0, local_test },
360 {"test_is_local(NOT)", 0, local_not_test },
361 {0, 0, 0}
362 };
363
364 test_st directories_tests[] ={
365 {"var exists", 0, var_exists_test },
366 {"var/tmp exists", 0, var_tmp_exists_test },
367 {"var/run exists", 0, var_run_exists_test },
368 {"var/log exists", 0, var_log_exists_test },
369 {"var/tmp", 0, var_tmp_test },
370 {"var/run", 0, var_run_test },
371 {"var/log", 0, var_log_test },
372 {"var/tmp rm", 0, var_tmp_rm_test },
373 {"var/run rm", 0, var_run_rm_test },
374 {"var/log rm", 0, var_log_rm_test },
375 {0, 0, 0}
376 };
377
378 test_st comparison_tests[] ={
379 {"_compare(test_return_t)", 0, _compare_test_return_t_test },
380 {"_compare(memcached_return_t)", 0, _compare_memcached_return_t_test },
381 {"_compare(gearman_return_t)", 0, _compare_gearman_return_t_test },
382 {0, 0, 0}
383 };
384
385 test_st cmdline_tests[] ={
386 {"wait --quiet", 0, wait_BINARY },
387 {"wait --quiet --help", 0, wait_help_BINARY },
388 {"wait --quiet --version", 0, wait_version_BINARY },
389 {0, 0, 0}
390 };
391
392 collection_st collection[] ={
393 {"environment", 0, 0, environment_tests},
394 {"return values", 0, 0, tests_log},
395 {"local", 0, 0, local_log},
396 {"directories", 0, 0, directories_tests},
397 {"comparison", 0, 0, comparison_tests},
398 {"gearmand", 0, 0, gearmand_tests},
399 {"memcached", 0, 0, memcached_tests},
400 {"cmdline", 0, 0, cmdline_tests},
401 {0, 0, 0, 0}
402 };
403
404 static void *world_create(server_startup_st& servers, test_return_t&)
405 {
406 return &servers;
407 }
408
409 void get_world(Framework *world)
410 {
411 world->collections= collection;
412 world->_create= world_create;
413 }