Merge in util update
[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 test_st gearmand_tests[] ={
302 #if 0
303 {"pause", 0, pause_test },
304 #endif
305 {"gearmand startup-shutdown", 0, gearmand_cycle_test },
306 {0, 0, 0}
307 };
308
309 test_st memcached_tests[] ={
310 {"memcached startup-shutdown", 0, memcached_cycle_test },
311 {"memcached(socket file) startup-shutdown", 0, memcached_socket_cycle_test },
312 {"memcached_sasl() startup-shutdown", 0, memcached_sasl_test },
313 {0, 0, 0}
314 };
315
316 test_st environment_tests[] ={
317 {"LIBTOOL_COMMAND", 0, LIBTOOL_COMMAND_test },
318 {"VALGRIND_COMMAND", 0, VALGRIND_COMMAND_test },
319 {"HELGRIND_COMMAND", 0, HELGRIND_COMMAND_test },
320 {"GDB_COMMAND", 0, GDB_COMMAND_test },
321 {0, 0, 0}
322 };
323
324 test_st tests_log[] ={
325 {"TEST_SUCCESS", false, test_success_test },
326 {"TEST_FAILURE", false, test_failure_test },
327 {"TEST_SUCCESS == 0", false, test_success_equals_one_test },
328 {0, 0, 0}
329 };
330
331 test_st local_log[] ={
332 {"test_is_local()", 0, local_test },
333 {"test_is_local(NOT)", 0, local_not_test },
334 {0, 0, 0}
335 };
336
337 test_st directories_tests[] ={
338 {"var exists", 0, var_exists_test },
339 {"var/tmp exists", 0, var_tmp_exists_test },
340 {"var/run exists", 0, var_run_exists_test },
341 {"var/log exists", 0, var_log_exists_test },
342 {"var/tmp", 0, var_tmp_test },
343 {"var/run", 0, var_run_test },
344 {"var/log", 0, var_log_test },
345 {"var/tmp rm", 0, var_tmp_rm_test },
346 {"var/run rm", 0, var_run_rm_test },
347 {"var/log rm", 0, var_log_rm_test },
348 {0, 0, 0}
349 };
350
351 test_st comparison_tests[] ={
352 {"_compare(test_return_t)", 0, _compare_test_return_t_test },
353 {"_compare(memcached_return_t)", 0, _compare_memcached_return_t_test },
354 {"_compare(gearman_return_t)", 0, _compare_gearman_return_t_test },
355 {0, 0, 0}
356 };
357
358 collection_st collection[] ={
359 {"environment", 0, 0, environment_tests},
360 {"return values", 0, 0, tests_log},
361 {"local", 0, 0, local_log},
362 {"directories", 0, 0, directories_tests},
363 {"comparison", 0, 0, comparison_tests},
364 {"gearmand", 0, 0, gearmand_tests},
365 {"memcached", 0, 0, memcached_tests},
366 {0, 0, 0, 0}
367 };
368
369 static void *world_create(server_startup_st& servers, test_return_t&)
370 {
371 return &servers;
372 }
373
374 void get_world(Framework *world)
375 {
376 world->collections= collection;
377 world->_create= world_create;
378 }