framework in all projects.
*/
#include <libmemcached/common.h>
+#include <libmemcached/options.hpp>
#include <libmemcached/virtual_bucket.h>
#include <ctime>
size_t loop_max= 5;
- while (--loop_max) // Should only loop on cases of ERESTART or EINTR
+ if (ptr->root->poll_timeout == 0)
{
- int error;
- if (ptr->root->poll_timeout)
- {
- error= poll(fds, 1, ptr->root->connect_timeout);
- }
- else
- {
- error= 0;
- }
+ return memcached_set_error(*ptr, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+ }
+ while (--loop_max) // Should only loop on cases of ERESTART or EINTR
+ {
+ int error= poll(fds, 1, ptr->root->connect_timeout);
switch (error)
{
case 1:
libmemcached/is.h \
libmemcached/libmemcached_probes.h \
libmemcached/memory.h \
+ libmemcached/options.hpp \
libmemcached/protocol/ascii_handler.h \
libmemcached/protocol/binary_handler.h \
libmemcached/protocol/common.h \
fds.fd= ptr->fd;
fds.events= POLLIN;
- int error;
-
if (read_or_write == MEM_WRITE) /* write */
{
fds.events= POLLOUT;
}
}
+ if (ptr->root->poll_timeout == 0) // Mimic 0 causes timeout behavior (not all platforms do this)
+ {
+ return memcached_set_error(*ptr, MEMCACHED_TIMEOUT, MEMCACHED_AT);
+ }
+
size_t loop_max= 5;
while (--loop_max) // While loop is for ERESTART or EINTR
{
- if (ptr->root->poll_timeout) // Mimic 0 causes timeout behavior (not all platforms do this)
- {
- error= poll(&fds, 1, ptr->root->poll_timeout);
- }
- else
- {
- error= 0;
- }
+ int error= poll(&fds, 1, ptr->root->poll_timeout);
switch (error)
{
case 1: // Success!
}
}
- /* Imposssible for anything other then -1 */
- WATCHPOINT_ASSERT(error == -1);
ptr->cached_errno= get_socket_errno();
memcached_quit_server(ptr, true);
return NULL;
}
- switch (poll(fds, host_index, memc->poll_timeout))
+ int error= poll(fds, host_index, memc->poll_timeout);
+ switch (error)
{
case -1:
memcached_set_errno(*memc, get_socket_errno(), MEMCACHED_AT);
*/
#include <libmemcached/common.h>
+
+#include <libmemcached/options.hpp>
#include <libmemcached/virtual_bucket.h>
#if 0
if (memcached_success(rc) and memcached_parse_filename(self))
{
- rc= memcached_parse_configure_file(self, memcached_parse_filename(self), memcached_parse_filename_length(self));
+ rc= memcached_parse_configure_file(*self, memcached_parse_filename(self), memcached_parse_filename_length(self));
}
if (memcached_failed(rc))
if (ptr->configure.filename)
{
- return memcached_parse_configure_file(ptr, memcached_param_array(ptr->configure.filename));
+ return memcached_parse_configure_file(*ptr, memcached_param_array(ptr->configure.filename));
}
return MEMCACHED_SUCCESS;
*/
bool configure(const std::string &configuration)
{
- return memcached_success(memcached_parse_configuration(memc, configuration.c_str(), configuration.size()));
+ memcached_st *new_memc= memcached(configuration.c_str(), configuration.size());
+
+ if (new_memc)
+ {
+ memcached_free(memc);
+ memc= new_memc;
+
+ return true;
+ }
+
+ return false;
}
/**
*/
#include <libmemcached/common.h>
-#include <assert.h>
+#include <libmemcached/options.hpp>
+
+#include <cassert>
#include <libmemcached/options/context.h>
return memcached_array_size(memc->configure.filename);
}
-static memcached_return_t _parse_file_options(memcached_st *self, memcached_array_st *real_name)
+static memcached_return_t _parse_file_options(memcached_st& self, memcached_array_st *real_name)
{
FILE *fp= fopen(memcached_array_string(real_name), "r");
if (not fp)
{
memcached_string_t error_message= memcached_array_to_string(real_name);
- memcached_return_t rc= memcached_set_errno(*self, errno, MEMCACHED_AT, error_message);
+ memcached_return_t rc= memcached_set_errno(self, errno, MEMCACHED_AT, error_message);
return rc;
}
if (length == 1 and buffer[0] == '\n')
continue;
- if (memcached_failed(rc= memcached_parse_configuration(self, buffer, length)))
+ if (memcached_failed(rc= memcached_parse_configuration(&self, buffer, length)))
break;
}
fclose(fp);
assert(memcached_parse_filename(memc_ptr));
assert(memcached_parse_filename_length(memc_ptr));
memcached_string_t filename= memcached_array_to_string(memc_ptr->configure.filename);
- rc= _parse_file_options(memc_ptr, memc_ptr->configure.filename);
+ rc= _parse_file_options(*memc_ptr, memc_ptr->configure.filename);
if (memcached_failed(rc) and error_buffer && error_buffer_size)
{
self->configure.filename= memcached_strcpy(self, filename, filename_length);
}
-memcached_return_t memcached_parse_configure_file(memcached_st *self, const char *filename, size_t length)
+memcached_return_t memcached_parse_configure_file(memcached_st& self, const char *filename, size_t length)
{
- WATCHPOINT_ASSERT(self);
- if (not self)
- {
- return MEMCACHED_INVALID_ARGUMENTS;
- }
-
- WATCHPOINT_ASSERT(self);
if (not filename)
{
- return memcached_set_error(*self, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT);
+ return memcached_set_error(self, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT);
}
WATCHPOINT_ASSERT(self);
if (not length)
{
- return memcached_set_error(*self, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT);
+ return memcached_set_error(self, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT);
}
- memcached_array_st *tmp_array= memcached_strcpy(self, filename, length);
+ memcached_array_st *tmp_array= memcached_strcpy(&self, filename, length);
- memcached_return_t rc= memcached_parse_configure_file(self, tmp_array);
+ if (not tmp_array)
+ {
+ return memcached_set_error(self, MEMCACHED_MEMORY_ALLOCATION_FAILURE, MEMCACHED_AT);
+ }
+
+ memcached_return_t rc= memcached_parse_configure_file(self, *tmp_array);
memcached_array_free(tmp_array);
return rc;
}
-memcached_return_t memcached_parse_configure_file(memcached_st *self, memcached_array_st *filename)
+memcached_return_t memcached_parse_configure_file(memcached_st& self, memcached_array_st& filename)
{
- WATCHPOINT_ASSERT(self);
- if (not self)
- {
- return MEMCACHED_INVALID_ARGUMENTS;
- }
-
- WATCHPOINT_ASSERT(memcached_array_size(filename));
- if (not memcached_array_size(filename))
+ WATCHPOINT_ASSERT(memcached_array_size(&filename));
+ if (not memcached_array_size(&filename))
{
- return memcached_set_error(*self, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT);
+ return memcached_set_error(self, MEMCACHED_INVALID_ARGUMENTS, MEMCACHED_AT);
}
- return _parse_file_options(self, filename);
+ return _parse_file_options(self, &filename);
}
LIBMEMCACHED_API
memcached_return_t libmemcached_check_configuration(const char *option_string, size_t length, char *error_buffer, size_t error_buffer_size);
-LIBMEMCACHED_LOCAL
- void memcached_set_configuration_file(memcached_st *self, const char *filename, size_t filename_length);
-
-LIBMEMCACHED_LOCAL
- memcached_return_t memcached_parse_configuration(memcached_st *ptr, const char *option_string, size_t length);
-
-LIBMEMCACHED_LOCAL
- const char *memcached_parse_filename(memcached_st *memc);
-
-LIBMEMCACHED_LOCAL
- size_t memcached_parse_filename_length(memcached_st *memc);
-
#ifdef __cplusplus
}
#endif
-
-#ifdef __cplusplus
-
-LIBMEMCACHED_LOCAL
- memcached_return_t memcached_parse_configure_file(memcached_st *self, const char *filename, size_t length);
-
-LIBMEMCACHED_LOCAL
- memcached_return_t memcached_parse_configure_file(memcached_st *self, memcached_array_st *filename);
-
-#endif
--- /dev/null
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * Libmemcached library
+ *
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * * The names of its contributors may not be used to endorse or
+ * promote products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#pragma once
+
+LIBMEMCACHED_LOCAL
+ void memcached_set_configuration_file(memcached_st *self, const char *filename, size_t filename_length);
+
+LIBMEMCACHED_LOCAL
+ const char *memcached_parse_filename(memcached_st *memc);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_parse_configuration(memcached_st *ptr, const char *option_string, size_t length);
+
+LIBMEMCACHED_LOCAL
+ size_t memcached_parse_filename_length(memcached_st *memc);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_parse_configure_file(memcached_st&, const char *filename, size_t length);
+
+LIBMEMCACHED_LOCAL
+ memcached_return_t memcached_parse_configure_file(memcached_st&, memcached_array_st& filename);
#include <stdint.h>
#include <libmemcached/common.h>
+#include <libmemcached/options.hpp>
+
#include <libmemcached/options/context.h>
#include <libmemcached/options/symbol.h>
#include <libmemcached/options/scanner.h>
/* Line 189 of yacc.c */
-#line 106 "libmemcached/options/parser.cc"
+#line 108 "libmemcached/options/parser.cc"
/* Enabling traces. */
#ifndef YYDEBUG
/* Line 264 of yacc.c */
-#line 217 "libmemcached/options/parser.cc"
+#line 219 "libmemcached/options/parser.cc"
#ifdef short
# undef short
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] =
{
- 0, 157, 157, 158, 162, 164, 166, 168, 173, 178,
- 182, 186, 197, 205, 213, 217, 221, 225, 229, 236,
- 243, 254, 261, 268, 275, 281, 285, 289, 293, 297,
- 301, 305, 309, 313, 317, 321, 325, 332, 336, 340,
- 344, 348, 352, 356, 360, 364, 368, 372, 376, 383,
- 384, 389, 390, 395, 399, 403, 407, 411, 415, 419,
- 423, 427, 434, 438, 446, 450, 454
+ 0, 159, 159, 160, 164, 166, 168, 170, 175, 180,
+ 184, 188, 199, 207, 215, 219, 223, 227, 231, 238,
+ 245, 256, 263, 270, 277, 283, 287, 291, 295, 299,
+ 303, 307, 311, 315, 319, 323, 327, 334, 338, 342,
+ 346, 350, 354, 358, 362, 366, 370, 374, 378, 385,
+ 386, 391, 392, 397, 401, 405, 409, 413, 417, 421,
+ 425, 429, 436, 440, 448, 452, 456
};
#endif
case 4:
/* Line 1464 of yacc.c */
-#line 163 "libmemcached/options/parser.yy"
+#line 165 "libmemcached/options/parser.yy"
{ ;}
break;
case 5:
/* Line 1464 of yacc.c */
-#line 165 "libmemcached/options/parser.yy"
+#line 167 "libmemcached/options/parser.yy"
{ ;}
break;
case 6:
/* Line 1464 of yacc.c */
-#line 167 "libmemcached/options/parser.yy"
+#line 169 "libmemcached/options/parser.yy"
{ ;}
break;
case 7:
/* Line 1464 of yacc.c */
-#line 169 "libmemcached/options/parser.yy"
+#line 171 "libmemcached/options/parser.yy"
{
context->set_end();
YYACCEPT;
case 8:
/* Line 1464 of yacc.c */
-#line 174 "libmemcached/options/parser.yy"
+#line 176 "libmemcached/options/parser.yy"
{
context->rc= MEMCACHED_PARSE_USER_ERROR;
parser_abort(context, NULL);
case 9:
/* Line 1464 of yacc.c */
-#line 179 "libmemcached/options/parser.yy"
+#line 181 "libmemcached/options/parser.yy"
{
memcached_reset(context->memc);
;}
case 10:
/* Line 1464 of yacc.c */
-#line 183 "libmemcached/options/parser.yy"
+#line 185 "libmemcached/options/parser.yy"
{
yydebug= 1;
;}
case 11:
/* Line 1464 of yacc.c */
-#line 187 "libmemcached/options/parser.yy"
+#line 189 "libmemcached/options/parser.yy"
{
- if ((context->rc= memcached_parse_configure_file(context->memc, (yyvsp[(3) - (3)].string).c_str, (yyvsp[(3) - (3)].string).size)) != MEMCACHED_SUCCESS)
+ if ((context->rc= memcached_parse_configure_file(*context->memc, (yyvsp[(3) - (3)].string).c_str, (yyvsp[(3) - (3)].string).size)) != MEMCACHED_SUCCESS)
{
parser_abort(context, NULL);
}
case 12:
/* Line 1464 of yacc.c */
-#line 198 "libmemcached/options/parser.yy"
+#line 200 "libmemcached/options/parser.yy"
{
if (memcached_failed(context->rc= memcached_server_add_with_weight(context->memc, (yyvsp[(2) - (4)].server).c_str, (yyvsp[(3) - (4)].number), (yyvsp[(4) - (4)].number))))
{
case 13:
/* Line 1464 of yacc.c */
-#line 206 "libmemcached/options/parser.yy"
+#line 208 "libmemcached/options/parser.yy"
{
if (memcached_failed(context->rc= memcached_server_add_with_weight(context->memc, (yyvsp[(2) - (4)].server).c_str, (yyvsp[(3) - (4)].number), (yyvsp[(4) - (4)].number))))
{
case 14:
/* Line 1464 of yacc.c */
-#line 214 "libmemcached/options/parser.yy"
+#line 216 "libmemcached/options/parser.yy"
{
memcached_set_configuration_file(context->memc, (yyvsp[(2) - (2)].string).c_str, (yyvsp[(2) - (2)].string).size);
;}
case 15:
/* Line 1464 of yacc.c */
-#line 218 "libmemcached/options/parser.yy"
+#line 220 "libmemcached/options/parser.yy"
{
context->memc->configure.initial_pool_size= (yyvsp[(2) - (2)].number);
;}
case 16:
/* Line 1464 of yacc.c */
-#line 222 "libmemcached/options/parser.yy"
+#line 224 "libmemcached/options/parser.yy"
{
context->memc->configure.max_pool_size= (yyvsp[(2) - (2)].number);
;}
case 18:
/* Line 1464 of yacc.c */
-#line 230 "libmemcached/options/parser.yy"
+#line 232 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_set_prefix_key(context->memc, (yyvsp[(2) - (2)].string).c_str, (yyvsp[(2) - (2)].string).size)) != MEMCACHED_SUCCESS)
{
case 19:
/* Line 1464 of yacc.c */
-#line 237 "libmemcached/options/parser.yy"
+#line 239 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_behavior_set(context->memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, (yyvsp[(2) - (2)].distribution))) != MEMCACHED_SUCCESS)
{
case 20:
/* Line 1464 of yacc.c */
-#line 244 "libmemcached/options/parser.yy"
+#line 246 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_behavior_set(context->memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, (yyvsp[(2) - (4)].distribution))) != MEMCACHED_SUCCESS)
{
case 21:
/* Line 1464 of yacc.c */
-#line 255 "libmemcached/options/parser.yy"
+#line 257 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_behavior_set(context->memc, MEMCACHED_BEHAVIOR_HASH, (yyvsp[(2) - (2)].hash))) != MEMCACHED_SUCCESS)
{
case 22:
/* Line 1464 of yacc.c */
-#line 262 "libmemcached/options/parser.yy"
+#line 264 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_behavior_set(context->memc, (yyvsp[(1) - (2)].behavior), (yyvsp[(2) - (2)].number))) != MEMCACHED_SUCCESS)
{
case 23:
/* Line 1464 of yacc.c */
-#line 269 "libmemcached/options/parser.yy"
+#line 271 "libmemcached/options/parser.yy"
{
if ((context->rc= memcached_behavior_set(context->memc, (yyvsp[(1) - (1)].behavior), true)) != MEMCACHED_SUCCESS)
{
case 24:
/* Line 1464 of yacc.c */
-#line 276 "libmemcached/options/parser.yy"
+#line 278 "libmemcached/options/parser.yy"
{
;}
break;
case 25:
/* Line 1464 of yacc.c */
-#line 282 "libmemcached/options/parser.yy"
+#line 284 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS;
;}
case 26:
/* Line 1464 of yacc.c */
-#line 286 "libmemcached/options/parser.yy"
+#line 288 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT;
;}
case 27:
/* Line 1464 of yacc.c */
-#line 290 "libmemcached/options/parser.yy"
+#line 292 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK;
;}
case 28:
/* Line 1464 of yacc.c */
-#line 294 "libmemcached/options/parser.yy"
+#line 296 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK;
;}
case 29:
/* Line 1464 of yacc.c */
-#line 298 "libmemcached/options/parser.yy"
+#line 300 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH;
;}
case 30:
/* Line 1464 of yacc.c */
-#line 302 "libmemcached/options/parser.yy"
+#line 304 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS;
;}
case 31:
/* Line 1464 of yacc.c */
-#line 306 "libmemcached/options/parser.yy"
+#line 308 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_POLL_TIMEOUT;
;}
case 32:
/* Line 1464 of yacc.c */
-#line 310 "libmemcached/options/parser.yy"
+#line 312 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_RCV_TIMEOUT;
;}
case 33:
/* Line 1464 of yacc.c */
-#line 314 "libmemcached/options/parser.yy"
+#line 316 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_RETRY_TIMEOUT;
;}
case 34:
/* Line 1464 of yacc.c */
-#line 318 "libmemcached/options/parser.yy"
+#line 320 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_SND_TIMEOUT;
;}
case 35:
/* Line 1464 of yacc.c */
-#line 322 "libmemcached/options/parser.yy"
+#line 324 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE;
;}
case 36:
/* Line 1464 of yacc.c */
-#line 326 "libmemcached/options/parser.yy"
+#line 328 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE;
;}
case 37:
/* Line 1464 of yacc.c */
-#line 333 "libmemcached/options/parser.yy"
+#line 335 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_BINARY_PROTOCOL;
;}
case 38:
/* Line 1464 of yacc.c */
-#line 337 "libmemcached/options/parser.yy"
+#line 339 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_BUFFER_REQUESTS;
;}
case 39:
/* Line 1464 of yacc.c */
-#line 341 "libmemcached/options/parser.yy"
+#line 343 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY;
;}
case 40:
/* Line 1464 of yacc.c */
-#line 345 "libmemcached/options/parser.yy"
+#line 347 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_NOREPLY;
;}
case 41:
/* Line 1464 of yacc.c */
-#line 349 "libmemcached/options/parser.yy"
+#line 351 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ;
;}
case 42:
/* Line 1464 of yacc.c */
-#line 353 "libmemcached/options/parser.yy"
+#line 355 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_SORT_HOSTS;
;}
case 43:
/* Line 1464 of yacc.c */
-#line 357 "libmemcached/options/parser.yy"
+#line 359 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_SUPPORT_CAS;
;}
case 44:
/* Line 1464 of yacc.c */
-#line 361 "libmemcached/options/parser.yy"
+#line 363 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_TCP_NODELAY;
;}
case 45:
/* Line 1464 of yacc.c */
-#line 365 "libmemcached/options/parser.yy"
+#line 367 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_TCP_KEEPALIVE;
;}
case 46:
/* Line 1464 of yacc.c */
-#line 369 "libmemcached/options/parser.yy"
+#line 371 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_TCP_KEEPIDLE;
;}
case 47:
/* Line 1464 of yacc.c */
-#line 373 "libmemcached/options/parser.yy"
+#line 375 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_USE_UDP;
;}
case 48:
/* Line 1464 of yacc.c */
-#line 377 "libmemcached/options/parser.yy"
+#line 379 "libmemcached/options/parser.yy"
{
(yyval.behavior)= MEMCACHED_BEHAVIOR_VERIFY_KEY;
;}
case 49:
/* Line 1464 of yacc.c */
-#line 383 "libmemcached/options/parser.yy"
+#line 385 "libmemcached/options/parser.yy"
{ (yyval.number)= MEMCACHED_DEFAULT_PORT;;}
break;
case 50:
/* Line 1464 of yacc.c */
-#line 385 "libmemcached/options/parser.yy"
+#line 387 "libmemcached/options/parser.yy"
{ ;}
break;
case 51:
/* Line 1464 of yacc.c */
-#line 389 "libmemcached/options/parser.yy"
+#line 391 "libmemcached/options/parser.yy"
{ (yyval.number)= 1; ;}
break;
case 52:
/* Line 1464 of yacc.c */
-#line 391 "libmemcached/options/parser.yy"
+#line 393 "libmemcached/options/parser.yy"
{ ;}
break;
case 53:
/* Line 1464 of yacc.c */
-#line 396 "libmemcached/options/parser.yy"
+#line 398 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_MD5;
;}
case 54:
/* Line 1464 of yacc.c */
-#line 400 "libmemcached/options/parser.yy"
+#line 402 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_CRC;
;}
case 55:
/* Line 1464 of yacc.c */
-#line 404 "libmemcached/options/parser.yy"
+#line 406 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_FNV1_64;
;}
case 56:
/* Line 1464 of yacc.c */
-#line 408 "libmemcached/options/parser.yy"
+#line 410 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_FNV1A_64;
;}
case 57:
/* Line 1464 of yacc.c */
-#line 412 "libmemcached/options/parser.yy"
+#line 414 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_FNV1_32;
;}
case 58:
/* Line 1464 of yacc.c */
-#line 416 "libmemcached/options/parser.yy"
+#line 418 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_FNV1A_32;
;}
case 59:
/* Line 1464 of yacc.c */
-#line 420 "libmemcached/options/parser.yy"
+#line 422 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_HSIEH;
;}
case 60:
/* Line 1464 of yacc.c */
-#line 424 "libmemcached/options/parser.yy"
+#line 426 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_MURMUR;
;}
case 61:
/* Line 1464 of yacc.c */
-#line 428 "libmemcached/options/parser.yy"
+#line 430 "libmemcached/options/parser.yy"
{
(yyval.hash)= MEMCACHED_HASH_JENKINS;
;}
case 62:
/* Line 1464 of yacc.c */
-#line 435 "libmemcached/options/parser.yy"
+#line 437 "libmemcached/options/parser.yy"
{
(yyval.string)= (yyvsp[(1) - (1)].string);
;}
case 63:
/* Line 1464 of yacc.c */
-#line 439 "libmemcached/options/parser.yy"
+#line 441 "libmemcached/options/parser.yy"
{
(yyval.string).c_str= (yyvsp[(1) - (1)].string).c_str +1; // +1 to move use passed the initial quote
(yyval.string).size= (yyvsp[(1) - (1)].string).size -2; // -2 removes the begin and end quote
case 64:
/* Line 1464 of yacc.c */
-#line 447 "libmemcached/options/parser.yy"
+#line 449 "libmemcached/options/parser.yy"
{
(yyval.distribution)= MEMCACHED_DISTRIBUTION_CONSISTENT;
;}
case 65:
/* Line 1464 of yacc.c */
-#line 451 "libmemcached/options/parser.yy"
+#line 453 "libmemcached/options/parser.yy"
{
(yyval.distribution)= MEMCACHED_DISTRIBUTION_MODULA;
;}
case 66:
/* Line 1464 of yacc.c */
-#line 455 "libmemcached/options/parser.yy"
+#line 457 "libmemcached/options/parser.yy"
{
(yyval.distribution)= MEMCACHED_DISTRIBUTION_RANDOM;
;}
/* Line 1464 of yacc.c */
-#line 2103 "libmemcached/options/parser.cc"
+#line 2105 "libmemcached/options/parser.cc"
default: break;
}
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
/* Line 1684 of yacc.c */
-#line 460 "libmemcached/options/parser.yy"
+#line 462 "libmemcached/options/parser.yy"
void Context::start()
#include <stdint.h>
#include <libmemcached/common.h>
+#include <libmemcached/options.hpp>
+
#include <libmemcached/options/context.h>
#include <libmemcached/options/symbol.h>
#include <libmemcached/options/scanner.h>
}
| INCLUDE ' ' string
{
- if ((context->rc= memcached_parse_configure_file(context->memc, $3.c_str, $3.size)) != MEMCACHED_SUCCESS)
+ if ((context->rc= memcached_parse_configure_file(*context->memc, $3.c_str, $3.size)) != MEMCACHED_SUCCESS)
{
parser_abort(context, NULL);
}
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
/* %if-not-reentrant */
/* %endif */
#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
/* Number of characters read into yy_ch_buf, not including EOB
* characters.
*/
- int yy_n_chars;
+ yy_size_t yy_n_chars;
/* Whether we "own" the buffer - i.e., we know we created it,
* and can realloc() it to grow it, and should free() it to
YY_BUFFER_STATE config__scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
YY_BUFFER_STATE config__scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE config__scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
+YY_BUFFER_STATE config__scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
/* %endif */
size_t yy_buffer_stack_max; /**< capacity of stack. */
YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
char yy_hold_char;
- int yy_n_chars;
- int yyleng_r;
+ yy_size_t yy_n_chars;
+ yy_size_t yyleng_r;
char *yy_c_buf_p;
int yy_init;
int yy_start;
void config_set_out (FILE * out_str ,yyscan_t yyscanner );
-int config_get_leng (yyscan_t yyscanner );
+yy_size_t config_get_leng (yyscan_t yyscanner );
char *config_get_text (yyscan_t yyscanner );
void config_set_lineno (int line_number ,yyscan_t yyscanner );
-int config_get_column (yyscan_t yyscanner );
-
-void config_set_column (int column_no ,yyscan_t yyscanner );
-
/* %if-bison-bridge */
YYSTYPE * config_get_lval (yyscan_t yyscanner );
/* This used to be an fputs(), but since the string might contain NUL's,
* we now use fwrite().
*/
-#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
+#define ECHO fwrite( yytext, yyleng, 1, yyout )
/* %endif */
/* %if-c++-only C++ definition */
/* %endif */
if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
{ \
int c = '*'; \
- unsigned n; \
+ yy_size_t n; \
for ( n = 0; n < max_size && \
(c = getc( yyin )) != EOF && c != '\n'; ++n ) \
buf[n] = (char) c; \
-#line 1447 "libmemcached/options/scanner.cc"
+#line 1443 "libmemcached/options/scanner.cc"
yylval = yylval_param;
#line 196 "libmemcached/options/scanner.l"
ECHO;
YY_BREAK
-#line 1923 "libmemcached/options/scanner.cc"
+#line 1919 "libmemcached/options/scanner.cc"
case YY_STATE_EOF(INITIAL):
yyterminate();
else
{
- int num_to_read =
+ yy_size_t num_to_read =
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
while ( num_to_read <= 0 )
if ( b->yy_is_our_buffer )
{
- int new_size = b->yy_buf_size * 2;
+ yy_size_t new_size = b->yy_buf_size * 2;
if ( new_size <= 0 )
b->yy_buf_size += b->yy_buf_size / 8;
/* Read in more data. */
YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
- yyg->yy_n_chars, (size_t) num_to_read );
+ yyg->yy_n_chars, num_to_read );
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
}
else
{ /* need more input */
- int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
+ yy_size_t offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
++yyg->yy_c_buf_p;
switch ( yy_get_next_buffer( yyscanner ) )
case EOB_ACT_END_OF_FILE:
{
if ( config_wrap(yyscanner ) )
- return EOF;
+ return 0;
if ( ! yyg->yy_did_buffer_switch_on_eof )
YY_NEW_FILE;
/* %if-c++-only */
/* %endif */
{
- int num_to_alloc;
+ yy_size_t num_to_alloc;
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if (!yyg->yy_buffer_stack) {
* @param yyscanner The scanner object.
* @return the newly allocated buffer state object.
*/
-YY_BUFFER_STATE config__scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner)
+YY_BUFFER_STATE config__scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len , yyscan_t yyscanner)
{
YY_BUFFER_STATE b;
char *buf;
- yy_size_t n;
- int i;
+ yy_size_t n, i;
/* Get memory for full buffer, including space for trailing EOB's. */
n = _yybytes_len + 2;
/** Get the length of the current token.
* @param yyscanner The scanner object.
*/
-int config_get_leng (yyscan_t yyscanner)
+yy_size_t config_get_leng (yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
return yyleng;
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
/* %if-not-reentrant */
/* %endif */
/* %endif */
/* %endif */
-#ifndef YY_TYPEDEF_YY_SIZE_T
-#define YY_TYPEDEF_YY_SIZE_T
-typedef size_t yy_size_t;
-#endif
-
#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
/* Number of characters read into yy_ch_buf, not including EOB
* characters.
*/
- int yy_n_chars;
+ yy_size_t yy_n_chars;
/* Whether we "own" the buffer - i.e., we know we created it,
* and can realloc() it to grow it, and should free() it to
YY_BUFFER_STATE config__scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
YY_BUFFER_STATE config__scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
-YY_BUFFER_STATE config__scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
+YY_BUFFER_STATE config__scan_bytes (yyconst char *bytes,yy_size_t len ,yyscan_t yyscanner );
/* %endif */
void config_set_out (FILE * out_str ,yyscan_t yyscanner );
-int config_get_leng (yyscan_t yyscanner );
+yy_size_t config_get_leng (yyscan_t yyscanner );
char *config_get_text (yyscan_t yyscanner );
void config_set_lineno (int line_number ,yyscan_t yyscanner );
-int config_get_column (yyscan_t yyscanner );
-
-void config_set_column (int column_no ,yyscan_t yyscanner );
-
/* %if-bison-bridge */
YYSTYPE * config_get_lval (yyscan_t yyscanner );
#line 196 "libmemcached/options/scanner.l"
-#line 478 "libmemcached/options/scanner.h"
+#line 474 "libmemcached/options/scanner.h"
#undef config_IN_HEADER
#endif /* config_HEADER_H */
noinst_LTLIBRARIES+= libtest/libtest.la
libtest_libtest_la_SOURCES=\
- libtest/test.c
+ libtest/test.cc
libtest_libtest_la_CFLAGS= ${AM_CFLAGS} ${NO_CONVERSION}
libtest_libtest_la_CPPFLAGS= ${AM_CPPFLAGS}
+++ /dev/null
-/* uTest
- * Copyright (C) 2006-2009 Brian Aker
- * All rights reserved.
- *
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
- */
-
-/*
- Sample test application.
-*/
-
-#include <config.h>
-
-#include <unistd.h>
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <time.h>
-#include <stdint.h>
-
-#include <libtest/test.h>
-#include <libtest/failed.h>
-
-static void world_stats_print(world_stats_st *stats)
-{
- fputc('\n', stderr);
- fprintf(stderr, "Total Collections\t\t\t\t%u\n", stats->collection_total);
- fprintf(stderr, "\tFailed Collections\t\t\t%u\n", stats->collection_failed);
- fprintf(stderr, "\tSkipped Collections\t\t\t%u\n", stats->collection_skipped);
- fprintf(stderr, "\tSucceeded Collections\t\t%u\n", stats->collection_success);
- fputc('\n', stderr);
- fprintf(stderr, "Total\t\t\t\t%u\n", stats->total);
- fprintf(stderr, "\tFailed\t\t\t%u\n", stats->failed);
- fprintf(stderr, "\tSkipped\t\t\t%u\n", stats->skipped);
- fprintf(stderr, "\tSucceeded\t\t%u\n", stats->success);
-}
-
-long int timedif(struct timeval a, struct timeval b)
-{
- long us, s;
-
- us = (int)(a.tv_usec - b.tv_usec);
- us /= 1000;
- s = (int)(a.tv_sec - b.tv_sec);
- s *= 1000;
- return s + us;
-}
-
-const char *test_strerror(test_return_t code)
-{
- switch (code) {
- case TEST_SUCCESS:
- return "ok";
- case TEST_FAILURE:
- return "failed";
- case TEST_FATAL:
- return "failed";
- case TEST_SKIPPED:
- return "skipped";
- case TEST_MEMORY_ALLOCATION_FAILURE:
- return "memory allocation";
- case TEST_MAXIMUM_RETURN:
- default:
- fprintf(stderr, "Unknown return value\n");
- abort();
- }
-}
-
-void create_core(void)
-{
- if (getenv("LIBMEMCACHED_NO_COREDUMP") == NULL)
- {
- pid_t pid= fork();
-
- if (pid == 0)
- {
- abort();
- }
- else
- {
- while (waitpid(pid, NULL, 0) != pid)
- {
- ;
- }
- }
- }
-}
-
-
-static test_return_t _runner_default(test_callback_fn func, void *p)
-{
- if (func)
- {
- return func(p);
- }
- else
- {
- return TEST_SUCCESS;
- }
-}
-
-static world_runner_st defualt_runners= {
- _runner_default,
- _runner_default,
- _runner_default
-};
-
-static test_return_t _default_callback(void *p)
-{
- (void)p;
-
- return TEST_SUCCESS;
-}
-
-static inline void set_default_fn(test_callback_fn *fn)
-{
- if (*fn == NULL)
- {
- *fn= _default_callback;
- }
-}
-
-static collection_st *init_world(world_st *world)
-{
- if (! world->runner)
- {
- world->runner= &defualt_runners;
- }
-
- set_default_fn(&world->collection.startup);
- set_default_fn(&world->collection.shutdown);
-
- return world->collections;
-}
-
-
-int main(int argc, char *argv[])
-{
- test_return_t return_code;
- unsigned int x;
- char *collection_to_run= NULL;
- char *wildcard= NULL;
- world_st world;
- collection_st *collection;
- void *world_ptr;
-
- world_stats_st stats;
-
-#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
- if (sasl_client_init(NULL) != SASL_OK)
- {
- fprintf(stderr, "Failed to initialize sasl library!\n");
- return EXIT_FAILURE;
- }
-#endif
-
- memset(&stats, 0, sizeof(stats));
- memset(&world, 0, sizeof(world));
- get_world(&world);
-
- collection= init_world(&world);
-
- if (world.create)
- {
- test_return_t error;
- world_ptr= world.create(&error);
- if (error != TEST_SUCCESS)
- exit(1);
- }
- else
- {
- world_ptr= NULL;
- }
-
- if (argc > 1)
- {
- collection_to_run= argv[1];
- }
- else if (getenv("TEST_COLLECTION"))
- {
- collection_to_run= getenv("TEST_COLLECTION");
- }
-
- if (collection_to_run)
- printf("Only testing %s\n", collection_to_run);
-
- if (argc == 3)
- {
- wildcard= argv[2];
- }
-
- for (collection_st *next= collection; next->name; next++)
- {
- test_return_t collection_rc= TEST_SUCCESS;
- test_st *run;
- bool failed= false;
- bool skipped= false;
-
- run= next->tests;
- if (collection_to_run && fnmatch(collection_to_run, next->name, 0))
- continue;
-
- stats.collection_total++;
-
- collection_rc= world.collection.startup(world_ptr);
-
- if (collection_rc != TEST_SUCCESS)
- goto skip_pre;
-
- if (next->pre)
- {
- collection_rc= world.runner->pre(next->pre, world_ptr);
- }
-
-skip_pre:
- switch (collection_rc)
- {
- case TEST_SUCCESS:
- fprintf(stderr, "\n%s\n\n", next->name);
- break;
- case TEST_FATAL:
- fprintf(stderr, "\n%s [ failed ]\n\n", next->name);
- stats.collection_failed++;
- goto cleanup;
- case TEST_FAILURE:
- fprintf(stderr, "\n%s [ failed ]\n\n", next->name);
- stats.collection_failed++;
- goto cleanup;
- case TEST_SKIPPED:
- fprintf(stderr, "\n%s [ skipping ]\n\n", next->name);
- stats.collection_skipped++;
- goto cleanup;
- case TEST_MEMORY_ALLOCATION_FAILURE:
- case TEST_MAXIMUM_RETURN:
- default:
- assert(0);
- break;
- }
-
-
- for (x= 0; run->name; run++)
- {
- struct timeval start_time, end_time;
- long int load_time= 0;
-
- if (wildcard && fnmatch(wildcard, run->name, 0))
- continue;
-
- fprintf(stderr, "Testing %s", run->name);
-
- if (world.test.startup)
- {
- world.test.startup(world_ptr);
- }
-
- if (run->requires_flush && world.test.flush)
- {
- world.test.flush(world_ptr);
- }
-
- if (world.test.pre_run)
- {
- world.test.pre_run(world_ptr);
- }
-
-
- // Runner code
- {
-#if 0
- if (next->pre && world.runner->pre)
- {
- return_code= world.runner->pre(next->pre, world_ptr);
-
- if (return_code != TEST_SUCCESS)
- {
- goto error;
- }
- }
-#endif
-
- gettimeofday(&start_time, NULL);
- return_code= world.runner->run(run->test_fn, world_ptr);
- gettimeofday(&end_time, NULL);
- load_time= timedif(end_time, start_time);
-
-#if 0
- if (next->post && world.runner->post)
- {
- (void) world.runner->post(next->post, world_ptr);
- }
-#endif
- }
-
- if (world.test.post_run)
- {
- world.test.post_run(world_ptr);
- }
-
- stats.total++;
-
- fprintf(stderr, "\t\t\t\t\t");
-
- switch (return_code)
- {
- case TEST_SUCCESS:
- fprintf(stderr, "%ld.%03ld ", load_time / 1000, load_time % 1000);
- stats.success++;
- break;
-
- case TEST_FATAL:
- case TEST_FAILURE:
-#if 0
- push_failed_test(next->name, run->name);
-#endif
- stats.failed++;
- failed= true;
- break;
-
- case TEST_SKIPPED:
- stats.skipped++;
- skipped= true;
- break;
-
- case TEST_MEMORY_ALLOCATION_FAILURE:
- fprintf(stderr, "Exhausted memory, quitting\n");
- abort();
-
- case TEST_MAXIMUM_RETURN:
- default:
- assert(0); // Coding error.
- break;
- }
-
- fprintf(stderr, "[ %s ]\n", test_strerror(return_code));
-
- if (world.test.on_error)
- {
- test_return_t rc;
- rc= world.test.on_error(return_code, world_ptr);
-
- if (rc != TEST_SUCCESS)
- break;
- }
-
- // If we get a TEST_FATAL we move onto the next collection
- if (return_code == TEST_FATAL)
- {
- break;
- }
- }
-
- if (next->post && world.runner->post)
- {
- (void) world.runner->post(next->post, world_ptr);
- }
-
- if (! failed && ! skipped)
- {
- stats.collection_success++;
- }
-cleanup:
-
- world.collection.shutdown(world_ptr);
- }
-
- if (stats.collection_failed || stats.collection_skipped)
- {
- fprintf(stderr, "Some test failures and/or skipped test occurred.\n\n");
-#if 0
- print_failed_test();
-#endif
- }
- else
- {
- fprintf(stderr, "All tests completed successfully\n\n");
- }
-
- if (world.destroy)
- {
- test_return_t error;
- error= world.destroy(world_ptr);
-
- if (error != TEST_SUCCESS)
- {
- fprintf(stderr, "Failure during shutdown.\n");
- stats.failed++; // We do this to make our exit code return EXIT_FAILURE
- }
- }
-
- world_stats_print(&stats);
-
- return stats.failed == 0 ? 0 : 1;
-}
--- /dev/null
+/* uTest
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license. See
+ * the COPYING file in the parent directory for full text.
+ */
+
+
+#include <config.h>
+
+#include <stdint.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <time.h>
+#include <fnmatch.h>
+#include <iostream>
+
+#include <libtest/test.h>
+
+#ifndef __INTEL_COMPILER
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+
+static void world_stats_print(world_stats_st *stats)
+{
+ std::cout << "\tTotal Collections\t\t\t\t" << stats->collection_total << std::endl;
+ std::cout << "\tFailed Collections\t\t\t\t" << stats->collection_failed << std::endl;
+ std::cout << "\tSkipped Collections\t\t\t\t" << stats->collection_skipped << std::endl;
+ std::cout << "\tSucceeded Collections\t\t\t\t" << stats->collection_success << std::endl;
+ std::cout << std::endl;
+ std::cout << "Total\t\t\t\t" << stats->total << std::endl;
+ std::cout << "\tFailed\t\t\t" << stats->failed << std::endl;
+ std::cout << "\tSkipped\t\t\t" << stats->skipped << std::endl;
+ std::cout << "\tSucceeded\t\t" << stats->success << std::endl;
+}
+
+static long int timedif(struct timeval a, struct timeval b)
+{
+ long us, s;
+
+ us = (long)(a.tv_usec - b.tv_usec);
+ us /= 1000;
+ s = (long)(a.tv_sec - b.tv_sec);
+ s *= 1000;
+ return s + us;
+}
+
+const char *test_strerror(test_return_t code)
+{
+ switch (code) {
+ case TEST_SUCCESS:
+ return "ok";
+ case TEST_FAILURE:
+ return "failed";
+ case TEST_FATAL:
+ return "failed";
+ case TEST_MEMORY_ALLOCATION_FAILURE:
+ return "memory allocation";
+ case TEST_SKIPPED:
+ return "skipped";
+ case TEST_MAXIMUM_RETURN:
+ default:
+ std::cerr << "Unknown return value." << std::endl;
+ abort();
+ }
+}
+
+void create_core(void)
+{
+ if (getenv("LIBMEMCACHED_NO_COREDUMP") == NULL)
+ {
+ pid_t pid= fork();
+
+ if (pid == 0)
+ {
+ abort();
+ }
+ else
+ {
+ while (waitpid(pid, NULL, 0) != pid) {};
+ }
+ }
+}
+
+
+static test_return_t _runner_default(test_callback_fn func, void *p)
+{
+ if (func)
+ return func(p);
+
+ return TEST_SUCCESS;
+}
+
+static world_runner_st defualt_runners= {
+ _runner_default,
+ _runner_default,
+ _runner_default
+};
+
+static test_return_t _default_callback(void *p)
+{
+ (void)p;
+
+ return TEST_SUCCESS;
+}
+
+static collection_st *init_world(world_st *world)
+{
+ if (world->runner == NULL)
+ {
+ world->runner= &defualt_runners;
+ }
+
+ if (world->collection_startup == NULL)
+ world->collection_startup= _default_callback;
+
+ if (world->collection_shutdown == NULL)
+ world->collection_shutdown= _default_callback;
+
+ return world->collections;
+}
+
+
+int main(int argc, char *argv[])
+{
+ world_st world;
+ void *world_ptr;
+
+ world_stats_st stats;
+
+ get_world(&world);
+
+ if (not world.runner)
+ {
+ world.runner= &defualt_runners;
+ }
+
+ collection_st *collection= init_world(&world);
+
+ if (world.create)
+ {
+ test_return_t error;
+ world_ptr= world.create(&error);
+ if (error != TEST_SUCCESS)
+ {
+ return EXIT_FAILURE;
+ }
+ }
+ else
+ {
+ world_ptr= NULL;
+ }
+
+ char *collection_to_run= NULL;
+ if (argc > 1)
+ {
+ collection_to_run= argv[1];
+ }
+ else if (getenv("TEST_COLLECTION"))
+ {
+ collection_to_run= getenv("TEST_COLLECTION");
+ }
+
+ if (collection_to_run)
+ {
+ std::cout << "Only testing " << collection_to_run << std::endl;
+ }
+
+ char *wildcard= NULL;
+ if (argc == 3)
+ {
+ wildcard= argv[2];
+ }
+
+ for (collection_st *next= collection; next->name; next++)
+ {
+ test_return_t collection_rc= TEST_SUCCESS;
+ bool failed= false;
+ bool skipped= false;
+
+ if (collection_to_run && fnmatch(collection_to_run, next->name, 0))
+ continue;
+
+ stats.collection_total++;
+
+ collection_rc= world.collection_startup(world_ptr);
+
+ if (collection_rc == TEST_SUCCESS and next->pre)
+ {
+ collection_rc= world.runner->pre(next->pre, world_ptr);
+ }
+
+ switch (collection_rc)
+ {
+ case TEST_SUCCESS:
+ std::cerr << std::endl << next->name << std::endl << std::endl;
+ break;
+
+ case TEST_FATAL:
+ case TEST_FAILURE:
+ std::cerr << std::endl << next->name << " [ failed ]" << std::endl << std::endl;
+ stats.collection_failed++;
+ goto cleanup;
+
+ case TEST_SKIPPED:
+ std::cerr << std::endl << next->name << " [ skipping ]" << std::endl << std::endl;
+ stats.collection_skipped++;
+ goto cleanup;
+
+ case TEST_MEMORY_ALLOCATION_FAILURE:
+ case TEST_MAXIMUM_RETURN:
+ default:
+ assert(0);
+ break;
+ }
+
+ for (test_st *run= next->tests; run->name; run++)
+ {
+ struct timeval start_time, end_time;
+ long int load_time= 0;
+
+ if (wildcard && fnmatch(wildcard, run->name, 0))
+ {
+ continue;
+ }
+
+ std::cerr << "\tTesting " << run->name;
+
+ if (world.run_startup)
+ {
+ world.run_startup(world_ptr);
+ }
+
+ if (run->requires_flush && world.flush)
+ {
+ world.flush(world_ptr);
+ }
+
+ if (world.pre_run)
+ {
+ world.pre_run(world_ptr);
+ }
+
+
+ test_return_t return_code;
+ { // Runner Code
+#if 0
+ if (next->pre and world.runner->pre)
+ {
+ return_code= world.runner->pre(next->pre, world_ptr);
+
+ if (return_code != TEST_SUCCESS)
+ {
+ goto error;
+ }
+ }
+#endif
+
+ gettimeofday(&start_time, NULL);
+ return_code= world.runner->run(run->test_fn, world_ptr);
+ gettimeofday(&end_time, NULL);
+ load_time= timedif(end_time, start_time);
+
+#if 0
+ if (next->post && world.runner->post)
+ {
+ (void) world.runner->post(next->post, world_ptr);
+ }
+#endif
+ }
+
+ if (world.post_run)
+ {
+ world.post_run(world_ptr);
+ }
+
+ stats.total++;
+
+ std::cerr << "\t\t\t\t\t";
+
+ switch (return_code)
+ {
+ case TEST_SUCCESS:
+ std::cerr << load_time / 1000 << "." << load_time % 1000;
+ stats.success++;
+ break;
+
+ case TEST_FATAL:
+ case TEST_FAILURE:
+ stats.failed++;
+ failed= true;
+ break;
+
+ case TEST_SKIPPED:
+ stats.skipped++;
+ skipped= true;
+ break;
+
+ case TEST_MEMORY_ALLOCATION_FAILURE:
+ case TEST_MAXIMUM_RETURN:
+ default:
+ break;
+ abort();
+ }
+
+ std::cerr << "[ " << test_strerror(return_code) << " ]" << std::endl;
+
+ if (world.on_error)
+ {
+ test_return_t rc= world.on_error(return_code, world_ptr);
+
+ if (rc != TEST_SUCCESS)
+ break;
+ }
+
+ }
+
+ if (next->post && world.runner->post)
+ {
+ (void) world.runner->post(next->post, world_ptr);
+ }
+
+ if (failed == 0 and skipped == 0)
+ {
+ stats.collection_success++;
+ }
+cleanup:
+
+ if (world.collection_shutdown)
+ {
+ world.collection_shutdown(world_ptr);
+ }
+ }
+
+ if (stats.collection_failed || stats.collection_skipped)
+ {
+ std::cerr << std::endl << std::endl << "Some test failures and/or skipped test occurred." << std::endl << std::endl;
+#if 0
+ print_failed_test();
+#endif
+ }
+ else
+ {
+ std::cout << std::endl << std::endl << "All tests completed successfully." << std::endl << std::endl;
+ }
+
+ if (world.destroy)
+ {
+ test_return_t error= world.destroy(world_ptr);
+
+ if (error != TEST_SUCCESS)
+ {
+ std::cerr << "Failure during shutdown." << std::endl;
+ stats.failed++; // We do this to make our exit code return EXIT_FAILURE
+ }
+ }
+
+ world_stats_print(&stats);
+
+ return stats.failed == 0 ? 0 : 1;
+}
-/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- * Gearmand client and server library.
- *
- * Copyright (C) 2011 Data Differential, http://datadifferential.com/
- * Copyright (C) 2006-2010 Brian Aker
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- * * The names of its contributors may not be used to endorse or
- * promote products derived from this software without specific prior
- * written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+/* uTest
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
*
+ * Use and distribution licensed under the BSD license. See
+ * the COPYING file in the parent directory for full text.
*/
-#pragma once
-
-#include <libtest/visibility.h>
-
/*
Structures for generic tests.
*/
#include <stdio.h>
#include <stdlib.h>
+#include <stdbool.h>
#include <stdint.h>
+#include <libtest/visibility.h>
-#if !defined(__cplusplus)
-# include <stdbool.h>
-#endif
-
-typedef struct world_st world_st;
-typedef struct collection_st collection_st;
-typedef struct test_st test_st;
+#pragma once
enum test_return_t {
- TEST_SUCCESS, /* Backwards compatibility */
+ TEST_SUCCESS= 0, /* Backwards compatibility */
TEST_FAILURE,
TEST_MEMORY_ALLOCATION_FAILURE,
TEST_SKIPPED,
extern "C" {
#endif
-typedef enum test_return_t test_return_t;
+typedef void* (test_callback_create_fn)(enum test_return_t*);
+typedef enum test_return_t (test_callback_fn)(void *);
+typedef enum test_return_t (test_callback_runner_fn)(test_callback_fn*, void *);
+typedef enum test_return_t (test_callback_error_fn)(const enum test_return_t, void *);
#ifdef __cplusplus
}
#endif
-
-typedef void *(*test_callback_create_fn)(test_return_t *error);
-typedef test_return_t (*test_callback_fn)(void *);
-typedef test_return_t (*test_callback_runner_fn)(test_callback_fn, void *);
-typedef test_return_t (*test_callback_error_fn)(test_return_t, void *);
-
/**
A structure describing the test case.
*/
struct test_st {
const char *name;
bool requires_flush;
- test_callback_fn test_fn;
+ test_callback_fn *test_fn;
};
*/
struct collection_st {
const char *name;
- test_callback_fn pre;
- test_callback_fn post;
- test_st *tests;
+ test_callback_fn *pre;
+ test_callback_fn *post;
+ struct test_st *tests;
};
Structure which houses the actual callers for the test cases contained in
the collections.
*/
-typedef struct {
- test_callback_runner_fn pre;
- test_callback_runner_fn run;
- test_callback_runner_fn post;
-} world_runner_st;
+struct world_runner_st {
+ test_callback_runner_fn *pre;
+ test_callback_runner_fn *run;
+ test_callback_runner_fn *post;
+};
/**
collection_st *collections;
/* These methods are called outside of any collection call. */
- test_callback_create_fn create;
- test_callback_fn destroy;
-
- struct {
- /* This is called a the beginning of any test run. */
- test_callback_fn startup;
+ test_callback_create_fn *create;
+ test_callback_fn *destroy;
- /* This called on a test if the test requires a flush call (the bool is from test_st) */
- test_callback_fn flush;
+ /* This is called a the beginning of any collection run. */
+ test_callback_fn *collection_startup;
- /**
- These are run before/after the test. If implemented. Their execution is not controlled
- by the test.
- */
- test_callback_fn pre_run;
- test_callback_fn post_run;
+ /* This is called a the end of any collection run. */
+ test_callback_fn *collection_shutdown;
- /**
- If an error occurs during the test, this is called.
- */
- test_callback_error_fn on_error;
- } test;
+ /* This is called a the beginning of any run. */
+ test_callback_fn *run_startup;
- struct {
- /* This is called a the beginning of any collection run. */
- test_callback_fn startup;
+ /* This called on a test if the test requires a flush call (the bool is from test_st) */
+ test_callback_fn *flush;
- /* This is called at the end of any collection run. */
- test_callback_fn shutdown;
- } collection;
+ /**
+ These are run before/after the test. If implemented. Their execution is not controlled
+ by the test.
+ */
+ test_callback_fn *pre_run;
+ test_callback_fn *post_run;
+ /**
+ If an error occurs during the test, this is called.
+ */
+ test_callback_error_fn *on_error;
/**
Runner represents the callers for the tests. If not implemented we will use
a set of default implementations.
*/
world_runner_st *runner;
+
+ world_st() :
+ collections(NULL),
+ create(NULL),
+ destroy(NULL),
+ collection_startup(NULL),
+ collection_shutdown(NULL),
+ run_startup(NULL),
+ flush(NULL),
+ pre_run(NULL),
+ post_run(NULL),
+ on_error(NULL),
+ runner(NULL)
+ { }
+
+ virtual ~world_st()
+ { }
+
+private:
+ world_st(const world_st&);
+ world_st& operator=(const world_st&);
};
/**
@note world_stats_st is a simple structure for tracking test successes.
*/
-typedef struct {
- uint32_t collection_success;
- uint32_t collection_skipped;
- uint32_t collection_failed;
- uint32_t collection_total;
+struct world_stats_st {
+ int32_t collection_success;
+ int32_t collection_skipped;
+ int32_t collection_failed;
+ int32_t collection_total;
+
uint32_t success;
uint32_t skipped;
uint32_t failed;
uint32_t total;
-} world_stats_st;
+
+ world_stats_st() :
+ collection_success(0),
+ collection_skipped(0),
+ collection_failed(0),
+ collection_total(0),
+ success(0),
+ skipped(0),
+ failed(0),
+ total(0)
+ { }
+};
+
+#define TEST_STRINGIFY(x) #x
+#define TEST_TOSTRING(x) TEST_STRINGIFY(x)
+#define TEST_AT __FILE__ ":" TEST_TOSTRING(__LINE__)
#ifdef __cplusplus
extern "C" {
#endif
-/* Help function for use with gettimeofday() */
-LIBTEST_API
-long int timedif(struct timeval a, struct timeval b);
-
/* How we make all of this work :) */
LIBTEST_API
void get_world(world_st *world);
/**
@note Friendly print function for errors.
*/
-LIBTEST_API
+LIBTEST_INTERNAL_API
const char *test_strerror(test_return_t code);
-#define test_fail(A) \
+#define test_assert_errno(A) \
do \
{ \
- if (1) { \
- fprintf(stderr, "\nFailed at %s:%d: %s\n", __FILE__, __LINE__, #A);\
+ if ((A)) { \
+ fprintf(stderr, "\nAssertion failed at %s:%d: ", __FILE__, __LINE__);\
+ perror(#A); \
+ fprintf(stderr, "\n"); \
create_core(); \
- return TEST_FAILURE; \
+ assert((A)); \
} \
} while (0)
-#define test_true(A) \
+#define test_truth(A) \
do \
{ \
if (! (A)) { \
} \
} while (0)
-#define test_true_got(A,B) \
+#define test_true(A) \
do \
{ \
if (! (A)) { \
- fprintf(stderr, "\nAssertion failed at %s:%d: \"%s\" received \"%s\"\n", __FILE__, __LINE__, #A, (B));\
+ fprintf(stderr, "\nAssertion failed at %s:%d: %s\n", __FILE__, __LINE__, #A);\
create_core(); \
return TEST_FAILURE; \
} \
} while (0)
-#define test_compare(A,B) \
+#define test_true_got(A,B) \
do \
{ \
- if ((A) != (B)) \
- { \
- fprintf(stderr, "\n%s:%d: Expected %s, got %lu\n", __FILE__, __LINE__, #A, (unsigned long)(B)); \
+ if (! (A)) { \
+ fprintf(stderr, "\nAssertion failed at %s:%d: \"%s\" received \"%s\"\n", __FILE__, __LINE__, #A, (B));\
create_core(); \
return TEST_FAILURE; \
} \
} \
} while (0)
-#define test_compare_got(A,B,C) \
+#define test_fail(A) \
do \
{ \
- if ((A) != (B)) \
- { \
- fprintf(stderr, "\n%s:%d: Expected %s, got %s\n", __FILE__, __LINE__, #A, (C)); \
+ if (1) { \
+ fprintf(stderr, "\nFailed at %s:%d: %s\n", __FILE__, __LINE__, #A);\
create_core(); \
return TEST_FAILURE; \
} \
} while (0)
+
#define test_false(A) \
do \
{ \
if ((A)) { \
- fprintf(stderr, "\nAssertion failed at %s:%d: %s\n", __FILE__, __LINE__, #A);\
+ fprintf(stderr, "\nAssertion failed in %s:%d: %s\n", __FILE__, __LINE__, #A);\
create_core(); \
return TEST_FAILURE; \
} \
} \
} while (0)
+
+#define test_compare(A,B) \
+do \
+{ \
+ if ((A) != (B)) \
+ { \
+ fprintf(stderr, "\n%s:%d: Expected %s, got %lu\n", __FILE__, __LINE__, #A, (unsigned long)(B)); \
+ create_core(); \
+ return TEST_FAILURE; \
+ } \
+} while (0)
+
+#define test_compare_got(A,B,C) \
+do \
+{ \
+ if ((A) != (B)) \
+ { \
+ fprintf(stderr, "\n%s:%d: Expected %s, got %s\n", __FILE__, __LINE__, #A, (C)); \
+ create_core(); \
+ return TEST_FAILURE; \
+ } \
+} while (0)
+
+
#define test_strcmp(A,B) \
do \
{ \
if (strcmp((A), (B))) \
{ \
- fprintf(stderr, "\n%s:%d: `%s` -> `%s`\n", __FILE__, __LINE__, (A), (B)); \
+ fprintf(stderr, "\n%s:%d: Expected %s, got %s\n", __FILE__, __LINE__, (A), (B)); \
create_core(); \
return TEST_FAILURE; \
} \
} \
} while (0)
-#define STRINGIFY(x) #x
-#define TOSTRING(x) STRINGIFY(x)
-#define AT __FILE__ ":" TOSTRING(__LINE__)
-
-#ifdef __cplusplus
-#define STRING_WITH_LEN(X) (X), (static_cast<size_t>((sizeof(X) - 1)))
-#else
-#define STRING_WITH_LEN(X) (X), ((size_t)((sizeof(X) - 1)))
+#ifdef __cplusplus
+}
#endif
#ifdef __cplusplus
-#define STRING_PARAM_WITH_LEN(X) X, static_cast<size_t>(sizeof(X) - 1)
+#define test_literal_param(X) (X), (static_cast<size_t>((sizeof(X) - 1)))
#else
-#define STRING_PARAM_WITH_LEN(X) X, (size_t)((sizeof(X) - 1))
+#define test_literal_param(X) (X), ((size_t)((sizeof(X) - 1)))
#endif
-#ifdef __cplusplus
-}
-#endif
+#define test_string_make_from_cstr(X) (X), ((X) ? strlen(X) : 0)
+++ /dev/null
-/* LibMemcached
- * Copyright (C) 2006-2009 Brian Aker
- * All rights reserved.
- *
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
- *
- * Summary:
- *
- */
-
-/*
- Sample test application.
-*/
-#include "config.h"
-
-#include "libmemcached/memcached.h"
-#include "libmemcached/watchpoint.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <time.h>
-#include <clients/generator.h>
-#include <clients/execute.h>
-
-#include <libtest/server.h>
-#include <libtest/test.h>
-
-/* Number of items generated for tests */
-#define GLOBAL_COUNT 100000
-
-/* Number of times to run the test loop */
-#define TEST_COUNTER 500000
-static uint32_t global_count;
-
-static pairs_st *global_pairs;
-static char *global_keys[GLOBAL_COUNT];
-static size_t global_keys_length[GLOBAL_COUNT];
-
-static test_return_t cleanup_pairs(memcached_st *memc)
-{
- (void)memc;
- pairs_free(global_pairs);
-
- return EXIT_SUCCESS;
-}
-
-static test_return_t generate_pairs(memcached_st *memc)
-{
- (void)memc;
- global_pairs= pairs_generate(GLOBAL_COUNT, 400);
- global_count= GLOBAL_COUNT;
-
- for (size_t x= 0; x < global_count; x++)
- {
- global_keys[x]= global_pairs[x].key;
- global_keys_length[x]= global_pairs[x].key_length;
- }
-
- return EXIT_SUCCESS;
-}
-
-static test_return_t drizzle(memcached_st *memc)
-{
- memcached_return_t rc;
- char *return_value;
- size_t return_value_length;
- uint32_t flags;
-
-infinite:
- for (size_t x= 0; x < TEST_COUNTER; x++)
- {
- uint32_t test_bit;
- uint8_t which;
-
- test_bit= (uint32_t)(random() % GLOBAL_COUNT);
- which= (uint8_t)(random() % 2);
-
- if (which == 0)
- {
- return_value= memcached_get(memc, global_keys[test_bit], global_keys_length[test_bit],
- &return_value_length, &flags, &rc);
- if (rc == MEMCACHED_SUCCESS && return_value)
- {
- free(return_value);
- }
- else if (rc == MEMCACHED_NOTFOUND)
- {
- continue;
- }
- else
- {
- WATCHPOINT_ERROR(rc);
- WATCHPOINT_ASSERT(rc);
- }
- }
- else
- {
- rc= memcached_set(memc, global_pairs[test_bit].key,
- global_pairs[test_bit].key_length,
- global_pairs[test_bit].value,
- global_pairs[test_bit].value_length,
- 0, 0);
- if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
- {
- WATCHPOINT_ERROR(rc);
- WATCHPOINT_ASSERT(0);
- }
- }
- }
-
- if (getenv("MEMCACHED_ATOM_BURIN_IN"))
- goto infinite;
-
- return TEST_SUCCESS;
-}
-
-static test_return_t pre_nonblock(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
-
- return TEST_SUCCESS;
-}
-
-/*
- Set the value, then quit to make sure it is flushed.
- Come back in and test that add fails.
-*/
-static test_return_t add_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo";
- const char *value= "when we sanitize";
- unsigned long long setting_value;
-
- setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- memcached_quit(memc);
- rc= memcached_add(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
-
- /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
- if (setting_value)
- {
- test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
- }
- else
- {
- test_true(rc == MEMCACHED_NOTSTORED);
- }
-
- return EXIT_SUCCESS;
-}
-
-/*
- * repeating add_tests many times
- * may show a problem in timing
- */
-static test_return_t many_adds(memcached_st *memc)
-{
- for (size_t x= 0; x < TEST_COUNTER; x++)
- {
- add_test(memc);
- }
- return EXIT_SUCCESS;
-}
-
-test_st smash_tests[] ={
- {"generate_pairs", 1, (test_callback_fn)generate_pairs },
- {"drizzle", 1, (test_callback_fn)drizzle },
- {"cleanup", 1, (test_callback_fn)cleanup_pairs },
- {"many_adds", 1, (test_callback_fn)many_adds },
- {0, 0, 0}
-};
-
-#define BENCHMARK_TEST_LOOP 20000
-
-struct benchmark_state_st
-{
- bool create_init;
- bool clone_init;
- memcached_st *create;
- memcached_st *clone;
-} benchmark_state;
-
-static test_return_t memcached_create_benchmark(memcached_st *memc)
-{
- (void)memc;
- benchmark_state.create_init= true;
-
- for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++)
- {
- memcached_st *ptr;
- ptr= memcached_create(&benchmark_state.create[x]);
-
- test_true(ptr);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t memcached_clone_benchmark(memcached_st *memc)
-{
- benchmark_state.clone_init= true;
-
- for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++)
- {
- memcached_st *ptr;
- ptr= memcached_clone(&benchmark_state.clone[x], memc);
-
- test_true(ptr);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t pre_allocate(memcached_st *memc)
-{
- (void)memc;
- memset(&benchmark_state, 0, sizeof(benchmark_state));
-
- benchmark_state.create= (memcached_st *)calloc(BENCHMARK_TEST_LOOP, sizeof(memcached_st));
- test_true(benchmark_state.create);
- benchmark_state.clone= (memcached_st *)calloc(BENCHMARK_TEST_LOOP, sizeof(memcached_st));
- test_true(benchmark_state.clone);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t post_allocate(memcached_st *memc)
-{
- (void)memc;
- for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++)
- {
- if (benchmark_state.create_init)
- memcached_free(&benchmark_state.create[x]);
-
- if (benchmark_state.clone_init)
- memcached_free(&benchmark_state.clone[x]);
- }
-
- free(benchmark_state.create);
- free(benchmark_state.clone);
-
- return TEST_SUCCESS;
-}
-
-
-test_st micro_tests[] ={
- {"memcached_create", 1, (test_callback_fn)memcached_create_benchmark },
- {"memcached_clone", 1, (test_callback_fn)memcached_clone_benchmark },
- {0, 0, 0}
-};
-
-
-collection_st collection[] ={
- {"smash", 0, 0, smash_tests},
- {"smash_nonblock", (test_callback_fn)pre_nonblock, 0, smash_tests},
- {"micro-benchmark", (test_callback_fn)pre_allocate, (test_callback_fn)post_allocate, micro_tests},
- {0, 0, 0, 0}
-};
-
-
-#define SERVERS_TO_CREATE 5
-
-#include "libmemcached_world.h"
-
-void get_world(world_st *world)
-{
- world->collections= collection;
-
- world->create= (test_callback_create_fn)world_create;
- world->destroy= (test_callback_fn)world_destroy;
-
- world->test.startup= (test_callback_fn)world_test_startup;
- world->test.flush= (test_callback_fn)world_flush;
- world->test.pre_run= (test_callback_fn)world_pre_run;
- world->test.post_run= (test_callback_fn)world_post_run;
- world->test.on_error= (test_callback_error_fn)world_on_error;
-
- world->collection.startup= (test_callback_fn)world_container_startup;
- world->collection.shutdown= (test_callback_fn)world_container_shutdown;
-
- world->runner= &defualt_libmemcached_runner;
-}
--- /dev/null
+/* LibMemcached
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license. See
+ * the COPYING file in the parent directory for full text.
+ *
+ * Summary:
+ *
+ */
+
+/*
+ Sample test application.
+*/
+#include "config.h"
+
+#include <libmemcached/memcached.h>
+#include <libmemcached/watchpoint.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <time.h>
+#include <clients/generator.h>
+#include <clients/execute.h>
+
+#include <libtest/server.h>
+#include <libtest/test.h>
+
+/* Number of items generated for tests */
+#define GLOBAL_COUNT 100000
+
+/* Number of times to run the test loop */
+#define TEST_COUNTER 500000
+static uint32_t global_count;
+
+static pairs_st *global_pairs;
+static char *global_keys[GLOBAL_COUNT];
+static size_t global_keys_length[GLOBAL_COUNT];
+
+static test_return_t cleanup_pairs(memcached_st *memc)
+{
+ (void)memc;
+ pairs_free(global_pairs);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t generate_pairs(memcached_st *memc)
+{
+ (void)memc;
+ global_pairs= pairs_generate(GLOBAL_COUNT, 400);
+ global_count= GLOBAL_COUNT;
+
+ for (size_t x= 0; x < global_count; x++)
+ {
+ global_keys[x]= global_pairs[x].key;
+ global_keys_length[x]= global_pairs[x].key_length;
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t drizzle(memcached_st *memc)
+{
+ memcached_return_t rc;
+ char *return_value;
+ size_t return_value_length;
+ uint32_t flags;
+
+infinite:
+ for (size_t x= 0; x < TEST_COUNTER; x++)
+ {
+ uint32_t test_bit;
+ uint8_t which;
+
+ test_bit= (uint32_t)(random() % GLOBAL_COUNT);
+ which= (uint8_t)(random() % 2);
+
+ if (which == 0)
+ {
+ return_value= memcached_get(memc, global_keys[test_bit], global_keys_length[test_bit],
+ &return_value_length, &flags, &rc);
+ if (rc == MEMCACHED_SUCCESS && return_value)
+ {
+ free(return_value);
+ }
+ else if (rc == MEMCACHED_NOTFOUND)
+ {
+ continue;
+ }
+ else
+ {
+ WATCHPOINT_ERROR(rc);
+ WATCHPOINT_ASSERT(rc);
+ }
+ }
+ else
+ {
+ rc= memcached_set(memc, global_pairs[test_bit].key,
+ global_pairs[test_bit].key_length,
+ global_pairs[test_bit].value,
+ global_pairs[test_bit].value_length,
+ 0, 0);
+ if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
+ {
+ WATCHPOINT_ERROR(rc);
+ WATCHPOINT_ASSERT(0);
+ }
+ }
+ }
+
+ if (getenv("MEMCACHED_ATOM_BURIN_IN"))
+ goto infinite;
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t pre_nonblock(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
+
+ return TEST_SUCCESS;
+}
+
+/*
+ Set the value, then quit to make sure it is flushed.
+ Come back in and test that add fails.
+*/
+static test_return_t add_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "foo";
+ const char *value= "when we sanitize";
+ unsigned long long setting_value;
+
+ setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ memcached_quit(memc);
+ rc= memcached_add(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+
+ /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
+ if (setting_value)
+ {
+ test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
+ }
+ else
+ {
+ test_true(rc == MEMCACHED_NOTSTORED);
+ }
+
+ return TEST_SUCCESS;
+}
+
+/*
+ * repeating add_tests many times
+ * may show a problem in timing
+ */
+static test_return_t many_adds(memcached_st *memc)
+{
+ for (size_t x= 0; x < TEST_COUNTER; x++)
+ {
+ add_test(memc);
+ }
+ return TEST_SUCCESS;
+}
+
+test_st smash_tests[] ={
+ {"generate_pairs", 1, (test_callback_fn*)generate_pairs },
+ {"drizzle", 1, (test_callback_fn*)drizzle },
+ {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
+ {"many_adds", 1, (test_callback_fn*)many_adds },
+ {0, 0, 0}
+};
+
+#define BENCHMARK_TEST_LOOP 20000
+
+struct benchmark_state_st
+{
+ bool create_init;
+ bool clone_init;
+ memcached_st *create;
+ memcached_st *clone;
+} benchmark_state;
+
+static test_return_t memcached_create_benchmark(memcached_st *memc)
+{
+ (void)memc;
+ benchmark_state.create_init= true;
+
+ for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++)
+ {
+ memcached_st *ptr;
+ ptr= memcached_create(&benchmark_state.create[x]);
+
+ test_true(ptr);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t memcached_clone_benchmark(memcached_st *memc)
+{
+ benchmark_state.clone_init= true;
+
+ for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++)
+ {
+ memcached_st *ptr;
+ ptr= memcached_clone(&benchmark_state.clone[x], memc);
+
+ test_true(ptr);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t pre_allocate(memcached_st *memc)
+{
+ (void)memc;
+ memset(&benchmark_state, 0, sizeof(benchmark_state));
+
+ benchmark_state.create= (memcached_st *)calloc(BENCHMARK_TEST_LOOP, sizeof(memcached_st));
+ test_true(benchmark_state.create);
+ benchmark_state.clone= (memcached_st *)calloc(BENCHMARK_TEST_LOOP, sizeof(memcached_st));
+ test_true(benchmark_state.clone);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t post_allocate(memcached_st *memc)
+{
+ (void)memc;
+ for (size_t x= 0; x < BENCHMARK_TEST_LOOP; x++)
+ {
+ if (benchmark_state.create_init)
+ memcached_free(&benchmark_state.create[x]);
+
+ if (benchmark_state.clone_init)
+ memcached_free(&benchmark_state.clone[x]);
+ }
+
+ free(benchmark_state.create);
+ free(benchmark_state.clone);
+
+ return TEST_SUCCESS;
+}
+
+
+test_st micro_tests[] ={
+ {"memcached_create", 1, (test_callback_fn*)memcached_create_benchmark },
+ {"memcached_clone", 1, (test_callback_fn*)memcached_clone_benchmark },
+ {0, 0, 0}
+};
+
+
+collection_st collection[] ={
+ {"smash", 0, 0, smash_tests},
+ {"smash_nonblock", (test_callback_fn*)pre_nonblock, 0, smash_tests},
+ {"micro-benchmark", (test_callback_fn*)pre_allocate, (test_callback_fn*)post_allocate, micro_tests},
+ {0, 0, 0, 0}
+};
+
+
+#define SERVERS_TO_CREATE 5
+
+#include "libmemcached_world.h"
+
+void get_world(world_st *world)
+{
+ world->collections= collection;
+
+ world->create= (test_callback_create_fn*)world_create;
+ world->destroy= (test_callback_fn*)world_destroy;
+
+ world->run_startup= (test_callback_fn*)world_test_startup;
+ world->flush= (test_callback_fn*)world_flush;
+ world->pre_run= (test_callback_fn*)world_pre_run;
+ world->post_run= (test_callback_fn*)world_post_run;
+ world->on_error= (test_callback_error_fn*)world_on_error;
+
+ world->collection_startup= (test_callback_fn*)world_container_startup;
+ world->collection_shutdown= (test_callback_fn*)world_container_shutdown;
+
+ world->runner= &defualt_libmemcached_runner;
+}
}
test_st basic[] ={
- { "exists", 0, reinterpret_cast<test_callback_fn>(exists_test) },
- { "new", 0, reinterpret_cast<test_callback_fn>(new_test) },
- { "copy", 0, reinterpret_cast<test_callback_fn>(copy_test) },
- { "assign", 0, reinterpret_cast<test_callback_fn>(assign_test) },
- { "digest", 0, reinterpret_cast<test_callback_fn>(digest_test) },
- { "set_function", 0, reinterpret_cast<test_callback_fn>(set_function_test) },
- { "set_distribution_function", 0, reinterpret_cast<test_callback_fn>(set_distribution_function_test) },
- { "compare", 0, reinterpret_cast<test_callback_fn>(compare_function_test) },
+ { "exists", 0, reinterpret_cast<test_callback_fn*>(exists_test) },
+ { "new", 0, reinterpret_cast<test_callback_fn*>(new_test) },
+ { "copy", 0, reinterpret_cast<test_callback_fn*>(copy_test) },
+ { "assign", 0, reinterpret_cast<test_callback_fn*>(assign_test) },
+ { "digest", 0, reinterpret_cast<test_callback_fn*>(digest_test) },
+ { "set_function", 0, reinterpret_cast<test_callback_fn*>(set_function_test) },
+ { "set_distribution_function", 0, reinterpret_cast<test_callback_fn*>(set_distribution_function_test) },
+ { "compare", 0, reinterpret_cast<test_callback_fn*>(compare_function_test) },
{ 0, 0, 0}
};
+++ /dev/null
-/* libHashKit Functions Test
- * Copyright (C) 2006-2009 Brian Aker
- * All rights reserved.
- *
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
- */
-
-#include "config.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <libhashkit/hashkit.h>
-
-#include <libtest/test.h>
-
-#include "hash_results.h"
-
-static hashkit_st global_hashk;
-
-/**
- @brief hash_test_st is a structure we use in testing. It is currently empty.
-*/
-typedef struct hash_test_st hash_test_st;
-
-struct hash_test_st
-{
- bool _unused;
-};
-
-static test_return_t init_test(void *not_used)
-{
- hashkit_st hashk;
- hashkit_st *hashk_ptr;
- (void)not_used;
-
- hashk_ptr= hashkit_create(&hashk);
- test_true(hashk_ptr);
- test_true(hashk_ptr == &hashk);
- test_true(hashkit_is_allocated(hashk_ptr) == false);
-
- hashkit_free(hashk_ptr);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t allocation_test(void *not_used)
-{
- hashkit_st *hashk_ptr;
- (void)not_used;
-
- hashk_ptr= hashkit_create(NULL);
- test_true(hashk_ptr);
- test_true(hashkit_is_allocated(hashk_ptr) == true);
- hashkit_free(hashk_ptr);
-
- return TEST_SUCCESS;
-}
-
-static test_return_t clone_test(hashkit_st *hashk)
-{
- // First we make sure that the testing system is giving us what we expect.
- assert(&global_hashk == hashk);
-
- // Second we test if hashk is even valid
-
- /* All null? */
- {
- hashkit_st *hashk_ptr;
- hashk_ptr= hashkit_clone(NULL, NULL);
- test_true(hashk_ptr);
- test_true(hashkit_is_allocated(hashk_ptr));
- hashkit_free(hashk_ptr);
- }
-
- /* Can we init from null? */
- {
- hashkit_st *hashk_ptr;
-
- hashk_ptr= hashkit_clone(NULL, hashk);
-
- test_true(hashk_ptr);
- test_true(hashkit_is_allocated(hashk_ptr));
-
- hashkit_free(hashk_ptr);
- }
-
- /* Can we init from struct? */
- {
- hashkit_st declared_clone;
- hashkit_st *hash_clone;
-
- hash_clone= hashkit_clone(&declared_clone, NULL);
- test_true(hash_clone);
- test_true(hash_clone == &declared_clone);
- test_false(hashkit_is_allocated(hash_clone));
-
- hashkit_free(hash_clone);
- }
-
- /* Can we init from struct? */
- {
- hashkit_st declared_clone;
- hashkit_st *hash_clone;
-
- hash_clone= hashkit_clone(&declared_clone, hashk);
- test_true(hash_clone);
- test_true(hash_clone == &declared_clone);
- test_false(hashkit_is_allocated(hash_clone));
-
- hashkit_free(hash_clone);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t one_at_a_time_run (hashkit_st *hashk)
-{
- uint32_t x;
- const char **ptr;
- (void)hashk;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= libhashkit_one_at_a_time(*ptr, strlen(*ptr));
- test_true(one_at_a_time_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t md5_run (hashkit_st *hashk)
-{
- uint32_t x;
- const char **ptr;
- (void)hashk;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= libhashkit_md5(*ptr, strlen(*ptr));
- test_true(md5_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t crc_run (hashkit_st *hashk)
-{
- uint32_t x;
- const char **ptr;
- (void)hashk;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= libhashkit_crc32(*ptr, strlen(*ptr));
- assert(crc_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t fnv1_64_run (hashkit_st *hashk)
-{
- uint32_t x;
- const char **ptr;
- (void)hashk;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= libhashkit_fnv1_64(*ptr, strlen(*ptr));
- assert(fnv1_64_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t fnv1a_64_run (hashkit_st *hashk)
-{
- uint32_t x;
- const char **ptr;
- (void)hashk;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= libhashkit_fnv1a_64(*ptr, strlen(*ptr));
- assert(fnv1a_64_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t fnv1_32_run (hashkit_st *hashk)
-{
- uint32_t x;
- const char **ptr;
- (void)hashk;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= libhashkit_fnv1_32(*ptr, strlen(*ptr));
- assert(fnv1_32_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t fnv1a_32_run (hashkit_st *hashk)
-{
- uint32_t x;
- const char **ptr;
- (void)hashk;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= libhashkit_fnv1a_32(*ptr, strlen(*ptr));
- assert(fnv1a_32_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t hsieh_run (hashkit_st *hashk)
-{
- uint32_t x;
- const char **ptr;
- (void)hashk;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
-#ifdef HAVE_HSIEH_HASH
- hash_val= libhashkit_hsieh(*ptr, strlen(*ptr));
-#else
- hash_val= 1;
-#endif
- assert(hsieh_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t murmur_run (hashkit_st *hashk)
-{
- (void)hashk;
-
-#ifdef WORDS_BIGENDIAN
- (void)murmur_values;
- return TEST_SKIPPED;
-#else
- uint32_t x;
- const char **ptr;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
-#ifdef HAVE_MURMUR_HASH
- hash_val= libhashkit_murmur(*ptr, strlen(*ptr));
-#else
- hash_val= 1;
-#endif
- assert(murmur_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-#endif
-}
-
-static test_return_t jenkins_run (hashkit_st *hashk)
-{
- uint32_t x;
- const char **ptr;
- (void)hashk;
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= libhashkit_jenkins(*ptr, strlen(*ptr));
- assert(jenkins_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-
-
-
-/**
- @brief now we list out the tests.
-*/
-
-test_st allocation[]= {
- {"init", 0, (test_callback_fn)init_test},
- {"create and free", 0, (test_callback_fn)allocation_test},
- {"clone", 0, (test_callback_fn)clone_test},
- {0, 0, 0}
-};
-
-static test_return_t hashkit_digest_test(hashkit_st *hashk)
-{
- uint32_t value;
- value= hashkit_digest(hashk, "a", sizeof("a"));
-
- return TEST_SUCCESS;
-}
-
-static test_return_t hashkit_set_function_test(hashkit_st *hashk)
-{
- for (hashkit_hash_algorithm_t algo = HASHKIT_HASH_DEFAULT; algo < HASHKIT_HASH_MAX; algo++)
- {
- hashkit_return_t rc;
- uint32_t x;
- const char **ptr;
- uint32_t *list;
-
- rc= hashkit_set_function(hashk, algo);
-
- /* Hsieh is disabled most of the time for patent issues */
-#ifndef HAVE_HSIEH_HASH
- if (rc == HASHKIT_FAILURE && algo == HASHKIT_HASH_HSIEH)
- continue;
-#endif
-
-#ifndef HAVE_MURMUR_HASH
- if (rc == HASHKIT_FAILURE && algo == HASHKIT_HASH_MURMUR)
- continue;
-#endif
-
- if (rc == HASHKIT_INVALID_ARGUMENT && algo == HASHKIT_HASH_CUSTOM)
- continue;
-
- test_true_got(rc == HASHKIT_SUCCESS, hashkit_strerror(NULL, rc));
-
- switch (algo)
- {
- case HASHKIT_HASH_DEFAULT:
- list= one_at_a_time_values;
- break;
- case HASHKIT_HASH_MD5:
- list= md5_values;
- break;
- case HASHKIT_HASH_CRC:
- list= crc_values;
- break;
- case HASHKIT_HASH_FNV1_64:
- list= fnv1_64_values;
- break;
- case HASHKIT_HASH_FNV1A_64:
- list= fnv1a_64_values;
- break;
- case HASHKIT_HASH_FNV1_32:
- list= fnv1_32_values;
- break;
- case HASHKIT_HASH_FNV1A_32:
- list= fnv1a_32_values;
- break;
- case HASHKIT_HASH_HSIEH:
- list= hsieh_values;
- break;
- case HASHKIT_HASH_MURMUR:
- list= murmur_values;
- break;
- case HASHKIT_HASH_JENKINS:
- list= jenkins_values;
- break;
- case HASHKIT_HASH_CUSTOM:
- case HASHKIT_HASH_MAX:
- default:
- list= NULL;
- break;
- }
-
- // Now we make sure we did set the hash correctly.
- if (list)
- {
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= hashkit_digest(hashk, *ptr, strlen(*ptr));
- test_true(list[x] == hash_val);
- }
- }
- else
- {
- return TEST_FAILURE;
- }
- }
-
- return TEST_SUCCESS;
-}
-
-static uint32_t hash_test_function(const char *string, size_t string_length, void *context)
-{
- (void)context;
- return libhashkit_md5(string, string_length);
-}
-
-static test_return_t hashkit_set_custom_function_test(hashkit_st *hashk)
-{
- hashkit_return_t rc;
- uint32_t x;
- const char **ptr;
-
-
- rc= hashkit_set_custom_function(hashk, hash_test_function, NULL);
- test_true(rc == HASHKIT_SUCCESS);
-
- for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
- {
- uint32_t hash_val;
-
- hash_val= hashkit_digest(hashk, *ptr, strlen(*ptr));
- test_true(md5_values[x] == hash_val);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t hashkit_set_distribution_function_test(hashkit_st *hashk)
-{
- for (hashkit_hash_algorithm_t algo = HASHKIT_HASH_DEFAULT; algo < HASHKIT_HASH_MAX; algo++)
- {
- hashkit_return_t rc;
-
- rc= hashkit_set_distribution_function(hashk, algo);
-
- /* Hsieh is disabled most of the time for patent issues */
- if (rc == HASHKIT_FAILURE && algo == HASHKIT_HASH_HSIEH)
- continue;
-
- if (rc == HASHKIT_INVALID_ARGUMENT && algo == HASHKIT_HASH_CUSTOM)
- continue;
-
- test_true(rc == HASHKIT_SUCCESS);
- }
-
- return TEST_SUCCESS;
-}
-
-static test_return_t hashkit_set_custom_distribution_function_test(hashkit_st *hashk)
-{
- hashkit_return_t rc;
-
- rc= hashkit_set_custom_distribution_function(hashk, hash_test_function, NULL);
- test_true(rc == HASHKIT_SUCCESS);
-
- return TEST_SUCCESS;
-}
-
-
-static test_return_t hashkit_get_function_test(hashkit_st *hashk)
-{
- for (hashkit_hash_algorithm_t algo = HASHKIT_HASH_DEFAULT; algo < HASHKIT_HASH_MAX; algo++)
- {
- hashkit_return_t rc;
-
- if (HASHKIT_HASH_CUSTOM || HASHKIT_HASH_HSIEH)
- continue;
-
- rc= hashkit_set_function(hashk, algo);
- test_true(rc == HASHKIT_SUCCESS);
-
- test_true(hashkit_get_function(hashk) == algo);
- }
- return TEST_SUCCESS;
-}
-
-static test_return_t hashkit_compare_test(hashkit_st *hashk)
-{
- hashkit_st *clone;
-
- clone= hashkit_clone(NULL, hashk);
-
- test_true(hashkit_compare(clone, hashk));
- hashkit_free(clone);
-
- return TEST_SUCCESS;
-}
-
-test_st hashkit_st_functions[] ={
- {"hashkit_digest", 0, (test_callback_fn)hashkit_digest_test},
- {"hashkit_set_function", 0, (test_callback_fn)hashkit_set_function_test},
- {"hashkit_set_custom_function", 0, (test_callback_fn)hashkit_set_custom_function_test},
- {"hashkit_get_function", 0, (test_callback_fn)hashkit_get_function_test},
- {"hashkit_set_distribution_function", 0, (test_callback_fn)hashkit_set_distribution_function_test},
- {"hashkit_set_custom_distribution_function", 0, (test_callback_fn)hashkit_set_custom_distribution_function_test},
- {"hashkit_compare", 0, (test_callback_fn)hashkit_compare_test},
- {0, 0, 0}
-};
-
-static test_return_t libhashkit_digest_test(hashkit_st *hashk)
-{
- uint32_t value;
-
- (void)hashk;
-
- value= libhashkit_digest("a", sizeof("a"), HASHKIT_HASH_DEFAULT);
-
- return TEST_SUCCESS;
-}
-
-test_st library_functions[] ={
- {"libhashkit_digest", 0, (test_callback_fn)libhashkit_digest_test},
- {0, 0, 0}
-};
-
-test_st hash_tests[] ={
- {"one_at_a_time", 0, (test_callback_fn)one_at_a_time_run },
- {"md5", 0, (test_callback_fn)md5_run },
- {"crc", 0, (test_callback_fn)crc_run },
- {"fnv1_64", 0, (test_callback_fn)fnv1_64_run },
- {"fnv1a_64", 0, (test_callback_fn)fnv1a_64_run },
- {"fnv1_32", 0, (test_callback_fn)fnv1_32_run },
- {"fnv1a_32", 0, (test_callback_fn)fnv1a_32_run },
- {"hsieh", 0, (test_callback_fn)hsieh_run },
- {"murmur", 0, (test_callback_fn)murmur_run },
- {"jenkis", 0, (test_callback_fn)jenkins_run },
- {0, 0, (test_callback_fn)0}
-};
-
-/*
- * The following test suite is used to verify that we don't introduce
- * regression bugs. If you want more information about the bug / test,
- * you should look in the bug report at
- * http://bugs.launchpad.net/libmemcached
- */
-test_st regression[]= {
- {0, 0, 0}
-};
-
-collection_st collection[] ={
- {"allocation", 0, 0, allocation},
- {"hashkit_st_functions", 0, 0, hashkit_st_functions},
- {"library_functions", 0, 0, library_functions},
- {"hashing", 0, 0, hash_tests},
- {"regression", 0, 0, regression},
- {0, 0, 0, 0}
-};
-
-/* Prototypes for functions we will pass to test framework */
-void *world_create(test_return_t *error);
-test_return_t world_destroy(hashkit_st *hashk);
-
-void *world_create(test_return_t *error)
-{
- hashkit_st *hashk_ptr;
-
- hashk_ptr= hashkit_create(&global_hashk);
-
- if (hashk_ptr != &global_hashk)
- {
- *error= TEST_FAILURE;
- return NULL;
- }
-
- if (hashkit_is_allocated(hashk_ptr) == true)
- {
- *error= TEST_FAILURE;
- return NULL;
- }
-
- *error= TEST_SUCCESS;
-
- return hashk_ptr;
-}
-
-
-test_return_t world_destroy(hashkit_st *hashk)
-{
- // Did we get back what we expected?
- assert(hashkit_is_allocated(hashk) == false);
- hashkit_free(&global_hashk);
-
- return TEST_SUCCESS;
-}
-
-void get_world(world_st *world)
-{
- world->collections= collection;
- world->create= (test_callback_create_fn)world_create;
- world->destroy= (test_callback_fn)world_destroy;
-}
--- /dev/null
+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ * libHashKit Functions Test
+ *
+ * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2006-2009 Brian Aker All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * * The names of its contributors may not be used to endorse or
+ * promote products derived from this software without specific prior
+ * written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libhashkit/hashkit.h>
+
+#include <libtest/test.h>
+
+#include "hash_results.h"
+
+static hashkit_st global_hashk;
+
+/**
+ @brief hash_test_st is a structure we use in testing. It is currently empty.
+*/
+typedef struct hash_test_st hash_test_st;
+
+struct hash_test_st
+{
+ bool _unused;
+};
+
+static test_return_t init_test(void *not_used)
+{
+ hashkit_st hashk;
+ hashkit_st *hashk_ptr;
+ (void)not_used;
+
+ hashk_ptr= hashkit_create(&hashk);
+ test_true(hashk_ptr);
+ test_true(hashk_ptr == &hashk);
+ test_true(hashkit_is_allocated(hashk_ptr) == false);
+
+ hashkit_free(hashk_ptr);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t allocation_test(void *not_used)
+{
+ hashkit_st *hashk_ptr;
+ (void)not_used;
+
+ hashk_ptr= hashkit_create(NULL);
+ test_true(hashk_ptr);
+ test_true(hashkit_is_allocated(hashk_ptr) == true);
+ hashkit_free(hashk_ptr);
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t clone_test(hashkit_st *hashk)
+{
+ // First we make sure that the testing system is giving us what we expect.
+ assert(&global_hashk == hashk);
+
+ // Second we test if hashk is even valid
+
+ /* All null? */
+ {
+ hashkit_st *hashk_ptr;
+ hashk_ptr= hashkit_clone(NULL, NULL);
+ test_true(hashk_ptr);
+ test_true(hashkit_is_allocated(hashk_ptr));
+ hashkit_free(hashk_ptr);
+ }
+
+ /* Can we init from null? */
+ {
+ hashkit_st *hashk_ptr;
+
+ hashk_ptr= hashkit_clone(NULL, hashk);
+
+ test_true(hashk_ptr);
+ test_true(hashkit_is_allocated(hashk_ptr));
+
+ hashkit_free(hashk_ptr);
+ }
+
+ /* Can we init from struct? */
+ {
+ hashkit_st declared_clone;
+ hashkit_st *hash_clone;
+
+ hash_clone= hashkit_clone(&declared_clone, NULL);
+ test_true(hash_clone);
+ test_true(hash_clone == &declared_clone);
+ test_false(hashkit_is_allocated(hash_clone));
+
+ hashkit_free(hash_clone);
+ }
+
+ /* Can we init from struct? */
+ {
+ hashkit_st declared_clone;
+ hashkit_st *hash_clone;
+
+ hash_clone= hashkit_clone(&declared_clone, hashk);
+ test_true(hash_clone);
+ test_true(hash_clone == &declared_clone);
+ test_false(hashkit_is_allocated(hash_clone));
+
+ hashkit_free(hash_clone);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t one_at_a_time_run (hashkit_st *hashk)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)hashk;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= libhashkit_one_at_a_time(*ptr, strlen(*ptr));
+ test_true(one_at_a_time_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t md5_run (hashkit_st *hashk)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)hashk;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= libhashkit_md5(*ptr, strlen(*ptr));
+ test_true(md5_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t crc_run (hashkit_st *hashk)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)hashk;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= libhashkit_crc32(*ptr, strlen(*ptr));
+ assert(crc_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t fnv1_64_run (hashkit_st *hashk)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)hashk;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= libhashkit_fnv1_64(*ptr, strlen(*ptr));
+ assert(fnv1_64_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t fnv1a_64_run (hashkit_st *hashk)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)hashk;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= libhashkit_fnv1a_64(*ptr, strlen(*ptr));
+ assert(fnv1a_64_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t fnv1_32_run (hashkit_st *hashk)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)hashk;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= libhashkit_fnv1_32(*ptr, strlen(*ptr));
+ assert(fnv1_32_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t fnv1a_32_run (hashkit_st *hashk)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)hashk;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= libhashkit_fnv1a_32(*ptr, strlen(*ptr));
+ assert(fnv1a_32_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t hsieh_run (hashkit_st *hashk)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)hashk;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+#ifdef HAVE_HSIEH_HASH
+ hash_val= libhashkit_hsieh(*ptr, strlen(*ptr));
+#else
+ hash_val= 1;
+#endif
+ assert(hsieh_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t murmur_run (hashkit_st *hashk)
+{
+ (void)hashk;
+
+#ifdef WORDS_BIGENDIAN
+ (void)murmur_values;
+ return TEST_SKIPPED;
+#else
+ uint32_t x;
+ const char **ptr;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+#ifdef HAVE_MURMUR_HASH
+ hash_val= libhashkit_murmur(*ptr, strlen(*ptr));
+#else
+ hash_val= 1;
+#endif
+ assert(murmur_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+#endif
+}
+
+static test_return_t jenkins_run (hashkit_st *hashk)
+{
+ uint32_t x;
+ const char **ptr;
+ (void)hashk;
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= libhashkit_jenkins(*ptr, strlen(*ptr));
+ assert(jenkins_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+
+
+
+/**
+ @brief now we list out the tests.
+*/
+
+test_st allocation[]= {
+ {"init", 0, (test_callback_fn*)init_test},
+ {"create and free", 0, (test_callback_fn*)allocation_test},
+ {"clone", 0, (test_callback_fn*)clone_test},
+ {0, 0, 0}
+};
+
+static test_return_t hashkit_digest_test(hashkit_st *hashk)
+{
+ uint32_t value;
+ value= hashkit_digest(hashk, "a", sizeof("a"));
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t hashkit_set_function_test(hashkit_st *hashk)
+{
+ for (int algo= int(HASHKIT_HASH_DEFAULT); algo < int(HASHKIT_HASH_MAX); algo++)
+ {
+ uint32_t x;
+ const char **ptr;
+ uint32_t *list;
+
+ hashkit_return_t rc= hashkit_set_function(hashk, static_cast<hashkit_hash_algorithm_t>(algo));
+
+ /* Hsieh is disabled most of the time for patent issues */
+#ifndef HAVE_HSIEH_HASH
+ if (rc == HASHKIT_FAILURE && algo == HASHKIT_HASH_HSIEH)
+ continue;
+#endif
+
+#ifndef HAVE_MURMUR_HASH
+ if (rc == HASHKIT_FAILURE && algo == HASHKIT_HASH_MURMUR)
+ continue;
+#endif
+
+ if (rc == HASHKIT_INVALID_ARGUMENT && algo == HASHKIT_HASH_CUSTOM)
+ continue;
+
+ test_true_got(rc == HASHKIT_SUCCESS, hashkit_strerror(NULL, rc));
+
+ switch (algo)
+ {
+ case HASHKIT_HASH_DEFAULT:
+ list= one_at_a_time_values;
+ break;
+ case HASHKIT_HASH_MD5:
+ list= md5_values;
+ break;
+ case HASHKIT_HASH_CRC:
+ list= crc_values;
+ break;
+ case HASHKIT_HASH_FNV1_64:
+ list= fnv1_64_values;
+ break;
+ case HASHKIT_HASH_FNV1A_64:
+ list= fnv1a_64_values;
+ break;
+ case HASHKIT_HASH_FNV1_32:
+ list= fnv1_32_values;
+ break;
+ case HASHKIT_HASH_FNV1A_32:
+ list= fnv1a_32_values;
+ break;
+ case HASHKIT_HASH_HSIEH:
+ list= hsieh_values;
+ break;
+ case HASHKIT_HASH_MURMUR:
+ list= murmur_values;
+ break;
+ case HASHKIT_HASH_JENKINS:
+ list= jenkins_values;
+ break;
+ case HASHKIT_HASH_CUSTOM:
+ case HASHKIT_HASH_MAX:
+ default:
+ list= NULL;
+ break;
+ }
+
+ // Now we make sure we did set the hash correctly.
+ if (list)
+ {
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= hashkit_digest(hashk, *ptr, strlen(*ptr));
+ test_true(list[x] == hash_val);
+ }
+ }
+ else
+ {
+ return TEST_FAILURE;
+ }
+ }
+
+ return TEST_SUCCESS;
+}
+
+static uint32_t hash_test_function(const char *string, size_t string_length, void *context)
+{
+ (void)context;
+ return libhashkit_md5(string, string_length);
+}
+
+static test_return_t hashkit_set_custom_function_test(hashkit_st *hashk)
+{
+ hashkit_return_t rc;
+ uint32_t x;
+ const char **ptr;
+
+
+ rc= hashkit_set_custom_function(hashk, hash_test_function, NULL);
+ test_true(rc == HASHKIT_SUCCESS);
+
+ for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
+ {
+ uint32_t hash_val;
+
+ hash_val= hashkit_digest(hashk, *ptr, strlen(*ptr));
+ test_true(md5_values[x] == hash_val);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t hashkit_set_distribution_function_test(hashkit_st *hashk)
+{
+ for (int algo= int(HASHKIT_HASH_DEFAULT); algo < int(HASHKIT_HASH_MAX); algo++)
+ {
+ hashkit_return_t rc= hashkit_set_distribution_function(hashk, static_cast<hashkit_hash_algorithm_t>(algo));
+
+ /* Hsieh is disabled most of the time for patent issues */
+ if (rc == HASHKIT_FAILURE && algo == HASHKIT_HASH_HSIEH)
+ continue;
+
+ if (rc == HASHKIT_INVALID_ARGUMENT && algo == HASHKIT_HASH_CUSTOM)
+ continue;
+
+ test_true(rc == HASHKIT_SUCCESS);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t hashkit_set_custom_distribution_function_test(hashkit_st *hashk)
+{
+ hashkit_return_t rc= hashkit_set_custom_distribution_function(hashk, hash_test_function, NULL);
+ test_true(rc == HASHKIT_SUCCESS);
+
+ return TEST_SUCCESS;
+}
+
+
+static test_return_t hashkit_get_function_test(hashkit_st *hashk)
+{
+ for (int algo= int(HASHKIT_HASH_DEFAULT); algo < int(HASHKIT_HASH_MAX); algo++)
+ {
+
+ if (HASHKIT_HASH_CUSTOM or HASHKIT_HASH_HSIEH)
+ continue;
+
+ hashkit_return_t rc= hashkit_set_function(hashk, static_cast<hashkit_hash_algorithm_t>(algo));
+ test_true(rc == HASHKIT_SUCCESS);
+
+ test_true(hashkit_get_function(hashk) == algo);
+ }
+ return TEST_SUCCESS;
+}
+
+static test_return_t hashkit_compare_test(hashkit_st *hashk)
+{
+ hashkit_st *clone= hashkit_clone(NULL, hashk);
+
+ test_true(hashkit_compare(clone, hashk));
+ hashkit_free(clone);
+
+ return TEST_SUCCESS;
+}
+
+test_st hashkit_st_functions[] ={
+ {"hashkit_digest", 0, (test_callback_fn*)hashkit_digest_test},
+ {"hashkit_set_function", 0, (test_callback_fn*)hashkit_set_function_test},
+ {"hashkit_set_custom_function", 0, (test_callback_fn*)hashkit_set_custom_function_test},
+ {"hashkit_get_function", 0, (test_callback_fn*)hashkit_get_function_test},
+ {"hashkit_set_distribution_function", 0, (test_callback_fn*)hashkit_set_distribution_function_test},
+ {"hashkit_set_custom_distribution_function", 0, (test_callback_fn*)hashkit_set_custom_distribution_function_test},
+ {"hashkit_compare", 0, (test_callback_fn*)hashkit_compare_test},
+ {0, 0, 0}
+};
+
+static test_return_t libhashkit_digest_test(hashkit_st *hashk)
+{
+
+ (void)hashk;
+
+ uint32_t value= libhashkit_digest("a", sizeof("a"), HASHKIT_HASH_DEFAULT);
+ test_true(value);
+
+ return TEST_SUCCESS;
+}
+
+test_st library_functions[] ={
+ {"libhashkit_digest", 0, (test_callback_fn*)libhashkit_digest_test},
+ {0, 0, 0}
+};
+
+test_st hash_tests[] ={
+ {"one_at_a_time", 0, (test_callback_fn*)one_at_a_time_run },
+ {"md5", 0, (test_callback_fn*)md5_run },
+ {"crc", 0, (test_callback_fn*)crc_run },
+ {"fnv1_64", 0, (test_callback_fn*)fnv1_64_run },
+ {"fnv1a_64", 0, (test_callback_fn*)fnv1a_64_run },
+ {"fnv1_32", 0, (test_callback_fn*)fnv1_32_run },
+ {"fnv1a_32", 0, (test_callback_fn*)fnv1a_32_run },
+ {"hsieh", 0, (test_callback_fn*)hsieh_run },
+ {"murmur", 0, (test_callback_fn*)murmur_run },
+ {"jenkis", 0, (test_callback_fn*)jenkins_run },
+ {0, 0, (test_callback_fn*)0}
+};
+
+/*
+ * The following test suite is used to verify that we don't introduce
+ * regression bugs. If you want more information about the bug / test,
+ * you should look in the bug report at
+ * http://bugs.launchpad.net/libmemcached
+ */
+test_st regression[]= {
+ {0, 0, 0}
+};
+
+collection_st collection[] ={
+ {"allocation", 0, 0, allocation},
+ {"hashkit_st_functions", 0, 0, hashkit_st_functions},
+ {"library_functions", 0, 0, library_functions},
+ {"hashing", 0, 0, hash_tests},
+ {"regression", 0, 0, regression},
+ {0, 0, 0, 0}
+};
+
+/* Prototypes for functions we will pass to test framework */
+void *world_create(test_return_t *error);
+test_return_t world_destroy(hashkit_st *hashk);
+
+void *world_create(test_return_t *error)
+{
+ hashkit_st *hashk_ptr= hashkit_create(&global_hashk);
+
+ if (hashk_ptr != &global_hashk)
+ {
+ *error= TEST_FAILURE;
+ return NULL;
+ }
+
+ if (hashkit_is_allocated(hashk_ptr) == true)
+ {
+ *error= TEST_FAILURE;
+ return NULL;
+ }
+
+ *error= TEST_SUCCESS;
+
+ return hashk_ptr;
+}
+
+
+test_return_t world_destroy(hashkit_st *hashk)
+{
+ // Did we get back what we expected?
+ assert(hashkit_is_allocated(hashk) == false);
+ hashkit_free(&global_hashk);
+
+ return TEST_SUCCESS;
+}
+
+void get_world(world_st *world)
+{
+ world->collections= collection;
+ world->create= (test_callback_create_fn*)world_create;
+ world->destroy= (test_callback_fn*)world_destroy;
+}
tests_testplus_LDADD= $(tests_testplus_DEPENDENCIES) $(LIBSASL)
check_PROGRAMS+= tests/testplus
-tests_atomsmasher_SOURCES= tests/atomsmasher.c
+tests_atomsmasher_SOURCES= tests/atomsmasher.cc
tests_atomsmasher_SOURCES+= clients/generator.cc clients/execute.cc
tests_atomsmasher_DEPENDENCIES= $(TESTS_LDADDS)
tests_atomsmasher_LDADD= $(tests_atomsmasher_DEPENDENCIES) $(LIBSASL)
tests_testudp_CFLAGS= $(AM_CFLAGS) $(NO_CONVERSION) $(NO_STRICT_ALIASING)
-tests_testudp_SOURCES= tests/mem_udp.c
+tests_testudp_SOURCES= tests/mem_udp.cc
tests_testudp_DEPENDENCIES= $(TESTS_LDADDS)
tests_testudp_LDADD= $(tests_testudp_DEPENDENCIES) $(LIBSASL)
-tests_startservers_SOURCES= tests/start.c
+tests_startservers_SOURCES= tests/start.cc
tests_startservers_DEPENDENCIES= $(TESTS_LDADDS)
tests_startservers_LDADD= $(tests_startservers_DEPENDENCIES) $(LIBSASL)
-tests_testhashkit_SOURCES = tests/hashkit_functions.c
+tests_testhashkit_SOURCES = tests/hashkit_functions.cc
tests_testhashkit_DEPENDENCIES = libtest/libtest.la libhashkit/libhashkit.la
tests_testhashkit_LDADD = $(tests_testhashkit_DEPENDENCIES)
#endif
/* The structure we use for the test system */
-typedef struct
+struct libmemcached_test_container_st
{
server_startup_st construct;
memcached_st *parent;
memcached_st *memc;
-} libmemcached_test_container_st;
+
+ libmemcached_test_container_st() :
+ parent(NULL),
+ memc(NULL)
+ {
+ memset(&construct, 0, sizeof(server_startup_st));
+ }
+};
/* Prototypes for functions we will pass to test framework */
libmemcached_test_container_st *world_create(test_return_t *error);
libmemcached_test_container_st *world_create(test_return_t *error)
{
- memset(&global_container, 0, sizeof(global_container));
global_container.construct.count= SERVERS_TO_CREATE;
global_container.construct.udp= 0;
server_startup(&global_container.construct);
- if (! global_container.construct.servers)
+ if (not global_container.construct.servers)
{
*error= TEST_FAILURE;
server_shutdown(&global_container.construct);
test_return_t world_container_startup(libmemcached_test_container_st *container)
{
- memcached_return_t rc;
container->parent= memcached_create(NULL);
test_true((container->parent != NULL));
- rc= memcached_server_push(container->parent, container->construct.servers);
- test_true(rc == MEMCACHED_SUCCESS);
+ test_compare(MEMCACHED_SUCCESS,
+ memcached_server_push(container->parent, container->construct.servers));
return TEST_SUCCESS;
}
memcached_server_instance_st instance=
memcached_server_instance_by_position(container->memc, loop);
- test_true(instance->fd == -1);
- test_true(instance->cursor_active == 0);
+ test_compare(-1, instance->fd);
+ test_compare(0, instance->cursor_active);
}
return TEST_SUCCESS;
#ifdef __cplusplus
static world_runner_st defualt_libmemcached_runner= {
- reinterpret_cast<test_callback_runner_fn>(_pre_runner_default),
- reinterpret_cast<test_callback_runner_fn>(_runner_default),
- reinterpret_cast<test_callback_runner_fn>(_post_runner_default)
+ reinterpret_cast<test_callback_runner_fn*>(_pre_runner_default),
+ reinterpret_cast<test_callback_runner_fn*>(_runner_default),
+ reinterpret_cast<test_callback_runner_fn*>(_post_runner_default)
};
#else
/* Make sure be default none exists */
value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
- test_true(rc == MEMCACHED_FAILURE);
+ test_compare_got(MEMCACHED_FAILURE, rc, memcached_strerror(NULL, rc));
/* Test a clean set */
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
- test_true_got(rc == MEMCACHED_SUCCESS, memcached_last_error_message(memc));
+ test_compare_got(MEMCACHED_SUCCESS, rc , memcached_last_error_message(memc));
value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
test_true(value);
test_memcmp(value, key, 4);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
/* Test that we can turn it off */
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
test_false(value);
- test_true(rc == MEMCACHED_FAILURE);
+ test_compare_got(MEMCACHED_FAILURE, rc, memcached_strerror(NULL, rc));
/* Now setup for main test */
rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
value= (char *)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
test_true(value);
- test_compare(MEMCACHED_SUCCESS, rc);
+ test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
test_memcmp(value, key, 4);
/* Set to Zero, and then Set to something too large */
test_true(clone);
char payload[100];
+#ifdef __APPLE__
+ return TEST_SKIPPED;
+#endif
+
test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1));
test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
for (uint32_t x= 0; x < regression_bug_655423_COUNT; x++)
{
- char key[1024];
+ char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
snprintf(key, sizeof(key), "%u", x);
test_compare(MEMCACHED_SUCCESS, memcached_set(clone, key, strlen(key), payload, sizeof(payload), 0, 0));
for (uint32_t x= 0; x < regression_bug_655423_COUNT; x++)
{
- char key[1024];
+ char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
snprintf(key, sizeof(key), "%u", x);
size_t value_length;
size_t *key_length= (size_t *)calloc(regression_bug_655423_COUNT, sizeof(size_t));
for (uint32_t x= 0; x < regression_bug_655423_COUNT; x++)
{
- char key[1024];
+ char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
snprintf(key, sizeof(key), "%u", x);
keys[x]= strdup(key);
+ test_true(keys[x]);
key_length[x]= strlen(key);
+ test_true(key_length[x]);
}
memcached_return_t rc;
/* Clean the server before beginning testing */
test_st tests[] ={
- {"util_version", 1, (test_callback_fn)util_version_test },
- {"flush", 0, (test_callback_fn)flush_test },
- {"init", 0, (test_callback_fn)init_test },
- {"allocation", 0, (test_callback_fn)allocation_test },
- {"server_list_null_test", 0, (test_callback_fn)server_list_null_test},
- {"server_unsort", 0, (test_callback_fn)server_unsort_test},
- {"server_sort", 0, (test_callback_fn)server_sort_test},
- {"server_sort2", 0, (test_callback_fn)server_sort2_test},
- {"memcached_server_remove", 0, (test_callback_fn)memcached_server_remove_test},
- {"clone_test", 0, (test_callback_fn)clone_test },
- {"connection_test", 0, (test_callback_fn)connection_test},
- {"callback_test", 0, (test_callback_fn)callback_test},
- {"userdata_test", 0, (test_callback_fn)userdata_test},
- {"error", 0, (test_callback_fn)error_test },
- {"set", 0, (test_callback_fn)set_test },
- {"set2", 0, (test_callback_fn)set_test2 },
- {"set3", 0, (test_callback_fn)set_test3 },
- {"dump", 1, (test_callback_fn)dump_test},
- {"add", 1, (test_callback_fn)add_test },
- {"memcached_fetch_result(MEMCACHED_NOTFOUND)", 1, (test_callback_fn)memcached_fetch_result_NOT_FOUND },
- {"replace", 1, (test_callback_fn)replace_test },
- {"delete", 1, (test_callback_fn)delete_test },
- {"get", 1, (test_callback_fn)get_test },
- {"get2", 0, (test_callback_fn)get_test2 },
- {"get3", 0, (test_callback_fn)get_test3 },
- {"get4", 0, (test_callback_fn)get_test4 },
- {"partial mget", 0, (test_callback_fn)get_test5 },
- {"stats_servername", 0, (test_callback_fn)stats_servername_test },
- {"increment", 0, (test_callback_fn)increment_test },
- {"increment_with_initial", 1, (test_callback_fn)increment_with_initial_test },
- {"decrement", 0, (test_callback_fn)decrement_test },
- {"decrement_with_initial", 1, (test_callback_fn)decrement_with_initial_test },
- {"increment_by_key", 0, (test_callback_fn)increment_by_key_test },
- {"increment_with_initial_by_key", 1, (test_callback_fn)increment_with_initial_by_key_test },
- {"decrement_by_key", 0, (test_callback_fn)decrement_by_key_test },
- {"decrement_with_initial_by_key", 1, (test_callback_fn)decrement_with_initial_by_key_test },
- {"quit", 0, (test_callback_fn)quit_test },
- {"mget", 1, (test_callback_fn)mget_test },
- {"mget_result", 1, (test_callback_fn)mget_result_test },
- {"mget_result_alloc", 1, (test_callback_fn)mget_result_alloc_test },
- {"mget_result_function", 1, (test_callback_fn)mget_result_function },
- {"mget_execute", 1, (test_callback_fn)mget_execute },
- {"mget_end", 0, (test_callback_fn)mget_end },
- {"get_stats", 0, (test_callback_fn)get_stats },
- {"add_host_test", 0, (test_callback_fn)add_host_test },
- {"add_host_test_1", 0, (test_callback_fn)add_host_test1 },
- {"get_stats_keys", 0, (test_callback_fn)get_stats_keys },
- {"version_string_test", 0, (test_callback_fn)version_string_test},
- {"bad_key", 1, (test_callback_fn)bad_key_test },
- {"memcached_server_cursor", 1, (test_callback_fn)memcached_server_cursor_test },
- {"read_through", 1, (test_callback_fn)read_through },
- {"delete_through", 1, (test_callback_fn)delete_through },
- {"noreply", 1, (test_callback_fn)noreply_test},
- {"analyzer", 1, (test_callback_fn)analyzer_test},
- {"connectionpool", 1, (test_callback_fn)connection_pool_test },
- {"memcached_pool_test", 1, (test_callback_fn)memcached_pool_test },
- {"ping", 1, (test_callback_fn)ping_test },
- {"test_get_last_disconnect", 1, (test_callback_fn)test_get_last_disconnect},
- {"verbosity", 1, (test_callback_fn)test_verbosity},
- {"test_server_failure", 1, (test_callback_fn)test_server_failure},
- {"cull_servers", 1, (test_callback_fn)test_cull_servers},
- {"memcached_stat_execute", 1, (test_callback_fn)memcached_stat_execute_test},
+ {"util_version", 1, (test_callback_fn*)util_version_test },
+ {"flush", 0, (test_callback_fn*)flush_test },
+ {"init", 0, (test_callback_fn*)init_test },
+ {"allocation", 0, (test_callback_fn*)allocation_test },
+ {"server_list_null_test", 0, (test_callback_fn*)server_list_null_test},
+ {"server_unsort", 0, (test_callback_fn*)server_unsort_test},
+ {"server_sort", 0, (test_callback_fn*)server_sort_test},
+ {"server_sort2", 0, (test_callback_fn*)server_sort2_test},
+ {"memcached_server_remove", 0, (test_callback_fn*)memcached_server_remove_test},
+ {"clone_test", 0, (test_callback_fn*)clone_test },
+ {"connection_test", 0, (test_callback_fn*)connection_test},
+ {"callback_test", 0, (test_callback_fn*)callback_test},
+ {"userdata_test", 0, (test_callback_fn*)userdata_test},
+ {"error", 0, (test_callback_fn*)error_test },
+ {"set", 0, (test_callback_fn*)set_test },
+ {"set2", 0, (test_callback_fn*)set_test2 },
+ {"set3", 0, (test_callback_fn*)set_test3 },
+ {"dump", 1, (test_callback_fn*)dump_test},
+ {"add", 1, (test_callback_fn*)add_test },
+ {"memcached_fetch_result(MEMCACHED_NOTFOUND)", 1, (test_callback_fn*)memcached_fetch_result_NOT_FOUND },
+ {"replace", 1, (test_callback_fn*)replace_test },
+ {"delete", 1, (test_callback_fn*)delete_test },
+ {"get", 1, (test_callback_fn*)get_test },
+ {"get2", 0, (test_callback_fn*)get_test2 },
+ {"get3", 0, (test_callback_fn*)get_test3 },
+ {"get4", 0, (test_callback_fn*)get_test4 },
+ {"partial mget", 0, (test_callback_fn*)get_test5 },
+ {"stats_servername", 0, (test_callback_fn*)stats_servername_test },
+ {"increment", 0, (test_callback_fn*)increment_test },
+ {"increment_with_initial", 1, (test_callback_fn*)increment_with_initial_test },
+ {"decrement", 0, (test_callback_fn*)decrement_test },
+ {"decrement_with_initial", 1, (test_callback_fn*)decrement_with_initial_test },
+ {"increment_by_key", 0, (test_callback_fn*)increment_by_key_test },
+ {"increment_with_initial_by_key", 1, (test_callback_fn*)increment_with_initial_by_key_test },
+ {"decrement_by_key", 0, (test_callback_fn*)decrement_by_key_test },
+ {"decrement_with_initial_by_key", 1, (test_callback_fn*)decrement_with_initial_by_key_test },
+ {"quit", 0, (test_callback_fn*)quit_test },
+ {"mget", 1, (test_callback_fn*)mget_test },
+ {"mget_result", 1, (test_callback_fn*)mget_result_test },
+ {"mget_result_alloc", 1, (test_callback_fn*)mget_result_alloc_test },
+ {"mget_result_function", 1, (test_callback_fn*)mget_result_function },
+ {"mget_execute", 1, (test_callback_fn*)mget_execute },
+ {"mget_end", 0, (test_callback_fn*)mget_end },
+ {"get_stats", 0, (test_callback_fn*)get_stats },
+ {"add_host_test", 0, (test_callback_fn*)add_host_test },
+ {"add_host_test_1", 0, (test_callback_fn*)add_host_test1 },
+ {"get_stats_keys", 0, (test_callback_fn*)get_stats_keys },
+ {"version_string_test", 0, (test_callback_fn*)version_string_test},
+ {"bad_key", 1, (test_callback_fn*)bad_key_test },
+ {"memcached_server_cursor", 1, (test_callback_fn*)memcached_server_cursor_test },
+ {"read_through", 1, (test_callback_fn*)read_through },
+ {"delete_through", 1, (test_callback_fn*)delete_through },
+ {"noreply", 1, (test_callback_fn*)noreply_test},
+ {"analyzer", 1, (test_callback_fn*)analyzer_test},
+ {"connectionpool", 1, (test_callback_fn*)connection_pool_test },
+ {"memcached_pool_test", 1, (test_callback_fn*)memcached_pool_test },
+ {"ping", 1, (test_callback_fn*)ping_test },
+ {"test_get_last_disconnect", 1, (test_callback_fn*)test_get_last_disconnect},
+ {"verbosity", 1, (test_callback_fn*)test_verbosity},
+ {"test_server_failure", 1, (test_callback_fn*)test_server_failure},
+ {"cull_servers", 1, (test_callback_fn*)test_cull_servers},
+ {"memcached_stat_execute", 1, (test_callback_fn*)memcached_stat_execute_test},
{0, 0, 0}
};
test_st behavior_tests[] ={
- {"libmemcached_string_behavior()", 0, (test_callback_fn)libmemcached_string_behavior_test},
- {"libmemcached_string_distribution()", 0, (test_callback_fn)libmemcached_string_distribution_test},
- {"behavior_test", 0, (test_callback_fn)behavior_test},
- {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_CORK_test},
- {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
- {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
+ {"libmemcached_string_behavior()", 0, (test_callback_fn*)libmemcached_string_behavior_test},
+ {"libmemcached_string_distribution()", 0, (test_callback_fn*)libmemcached_string_distribution_test},
+ {"behavior_test", 0, (test_callback_fn*)behavior_test},
+ {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn*)MEMCACHED_BEHAVIOR_CORK_test},
+ {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
+ {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn*)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
{0, 0, 0}
};
test_st basic_tests[] ={
- {"init", 1, (test_callback_fn)basic_init_test},
- {"clone", 1, (test_callback_fn)basic_clone_test},
- {"reset", 1, (test_callback_fn)basic_reset_stack_test},
- {"reset heap", 1, (test_callback_fn)basic_reset_heap_test},
- {"reset stack clone", 1, (test_callback_fn)basic_reset_stack_clone_test},
- {"reset heap clone", 1, (test_callback_fn)basic_reset_heap_clone_test},
+ {"init", 1, (test_callback_fn*)basic_init_test},
+ {"clone", 1, (test_callback_fn*)basic_clone_test},
+ {"reset", 1, (test_callback_fn*)basic_reset_stack_test},
+ {"reset heap", 1, (test_callback_fn*)basic_reset_heap_test},
+ {"reset stack clone", 1, (test_callback_fn*)basic_reset_stack_clone_test},
+ {"reset heap clone", 1, (test_callback_fn*)basic_reset_heap_clone_test},
{0, 0, 0}
};
test_st regression_binary_vs_block[] ={
- {"block add", 1, (test_callback_fn)block_add_regression},
- {"binary add", 1, (test_callback_fn)binary_add_regression},
+ {"block add", 1, (test_callback_fn*)block_add_regression},
+ {"binary add", 1, (test_callback_fn*)binary_add_regression},
{0, 0, 0}
};
test_st async_tests[] ={
- {"add", 1, (test_callback_fn)add_wrapper },
+ {"add", 1, (test_callback_fn*)add_wrapper },
{0, 0, 0}
};
test_st string_tests[] ={
- {"string static with null", 0, (test_callback_fn)string_static_null },
- {"string alloc with null", 0, (test_callback_fn)string_alloc_null },
- {"string alloc with 1K", 0, (test_callback_fn)string_alloc_with_size },
- {"string alloc with malloc failure", 0, (test_callback_fn)string_alloc_with_size_toobig },
- {"string append", 0, (test_callback_fn)string_alloc_append },
- {"string append failure (too big)", 0, (test_callback_fn)string_alloc_append_toobig },
- {"string_alloc_append_multiple", 0, (test_callback_fn)string_alloc_append_multiple },
- {0, 0, (test_callback_fn)0}
+ {"string static with null", 0, (test_callback_fn*)string_static_null },
+ {"string alloc with null", 0, (test_callback_fn*)string_alloc_null },
+ {"string alloc with 1K", 0, (test_callback_fn*)string_alloc_with_size },
+ {"string alloc with malloc failure", 0, (test_callback_fn*)string_alloc_with_size_toobig },
+ {"string append", 0, (test_callback_fn*)string_alloc_append },
+ {"string append failure (too big)", 0, (test_callback_fn*)string_alloc_append_toobig },
+ {"string_alloc_append_multiple", 0, (test_callback_fn*)string_alloc_append_multiple },
+ {0, 0, (test_callback_fn*)0}
};
test_st memcached_server_get_last_disconnect_tests[] ={
- {"memcached_server_get_last_disconnect()", 0, (test_callback_fn)test_multiple_get_last_disconnect},
- {0, 0, (test_callback_fn)0}
+ {"memcached_server_get_last_disconnect()", 0, (test_callback_fn*)test_multiple_get_last_disconnect},
+ {0, 0, (test_callback_fn*)0}
};
test_st result_tests[] ={
- {"result static", 0, (test_callback_fn)result_static},
- {"result alloc", 0, (test_callback_fn)result_alloc},
- {0, 0, (test_callback_fn)0}
+ {"result static", 0, (test_callback_fn*)result_static},
+ {"result alloc", 0, (test_callback_fn*)result_alloc},
+ {0, 0, (test_callback_fn*)0}
};
test_st version_1_2_3[] ={
- {"append", 0, (test_callback_fn)append_test },
- {"prepend", 0, (test_callback_fn)prepend_test },
- {"cas", 0, (test_callback_fn)cas_test },
- {"cas2", 0, (test_callback_fn)cas2_test },
- {"append_binary", 0, (test_callback_fn)append_binary_test },
- {0, 0, (test_callback_fn)0}
+ {"append", 0, (test_callback_fn*)append_test },
+ {"prepend", 0, (test_callback_fn*)prepend_test },
+ {"cas", 0, (test_callback_fn*)cas_test },
+ {"cas2", 0, (test_callback_fn*)cas2_test },
+ {"append_binary", 0, (test_callback_fn*)append_binary_test },
+ {0, 0, (test_callback_fn*)0}
};
test_st haldenbrand_tests[] ={
- {"memcached_set", 0, (test_callback_fn)user_supplied_bug1 },
- {"memcached_get()", 0, (test_callback_fn)user_supplied_bug2 },
- {"memcached_mget()", 0, (test_callback_fn)user_supplied_bug3 },
- {0, 0, (test_callback_fn)0}
+ {"memcached_set", 0, (test_callback_fn*)user_supplied_bug1 },
+ {"memcached_get()", 0, (test_callback_fn*)user_supplied_bug2 },
+ {"memcached_mget()", 0, (test_callback_fn*)user_supplied_bug3 },
+ {0, 0, (test_callback_fn*)0}
};
test_st user_tests[] ={
- {"user_supplied_bug4", true, (test_callback_fn)user_supplied_bug4 },
- {"user_supplied_bug5", 1, (test_callback_fn)user_supplied_bug5 },
- {"user_supplied_bug6", 1, (test_callback_fn)user_supplied_bug6 },
- {"user_supplied_bug7", 1, (test_callback_fn)user_supplied_bug7 },
- {"user_supplied_bug8", 1, (test_callback_fn)user_supplied_bug8 },
- {"user_supplied_bug9", 1, (test_callback_fn)user_supplied_bug9 },
- {"user_supplied_bug10", 1, (test_callback_fn)user_supplied_bug10 },
- {"user_supplied_bug11", 1, (test_callback_fn)user_supplied_bug11 },
- {"user_supplied_bug12", 1, (test_callback_fn)user_supplied_bug12 },
- {"user_supplied_bug13", 1, (test_callback_fn)user_supplied_bug13 },
- {"user_supplied_bug14", 1, (test_callback_fn)user_supplied_bug14 },
- {"user_supplied_bug15", 1, (test_callback_fn)user_supplied_bug15 },
- {"user_supplied_bug16", 1, (test_callback_fn)user_supplied_bug16 },
+ {"user_supplied_bug4", true, (test_callback_fn*)user_supplied_bug4 },
+ {"user_supplied_bug5", 1, (test_callback_fn*)user_supplied_bug5 },
+ {"user_supplied_bug6", 1, (test_callback_fn*)user_supplied_bug6 },
+ {"user_supplied_bug7", 1, (test_callback_fn*)user_supplied_bug7 },
+ {"user_supplied_bug8", 1, (test_callback_fn*)user_supplied_bug8 },
+ {"user_supplied_bug9", 1, (test_callback_fn*)user_supplied_bug9 },
+ {"user_supplied_bug10", 1, (test_callback_fn*)user_supplied_bug10 },
+ {"user_supplied_bug11", 1, (test_callback_fn*)user_supplied_bug11 },
+ {"user_supplied_bug12", 1, (test_callback_fn*)user_supplied_bug12 },
+ {"user_supplied_bug13", 1, (test_callback_fn*)user_supplied_bug13 },
+ {"user_supplied_bug14", 1, (test_callback_fn*)user_supplied_bug14 },
+ {"user_supplied_bug15", 1, (test_callback_fn*)user_supplied_bug15 },
+ {"user_supplied_bug16", 1, (test_callback_fn*)user_supplied_bug16 },
#if !defined(__sun) && !defined(__OpenBSD__)
/*
** It seems to be something weird with the character sets..
** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
** so just disable the code for now...).
*/
- {"user_supplied_bug17", 1, (test_callback_fn)user_supplied_bug17 },
+ {"user_supplied_bug17", 1, (test_callback_fn*)user_supplied_bug17 },
#endif
- {"user_supplied_bug18", 1, (test_callback_fn)user_supplied_bug18 },
- {"user_supplied_bug19", 1, (test_callback_fn)user_supplied_bug19 },
- {"user_supplied_bug20", 1, (test_callback_fn)user_supplied_bug20 },
- {"user_supplied_bug21", 1, (test_callback_fn)user_supplied_bug21 },
- {"wrong_failure_counter_test", 1, (test_callback_fn)wrong_failure_counter_test},
- {"wrong_failure_counter_two_test", 1, (test_callback_fn)wrong_failure_counter_two_test},
- {0, 0, (test_callback_fn)0}
+ {"user_supplied_bug18", 1, (test_callback_fn*)user_supplied_bug18 },
+ {"user_supplied_bug19", 1, (test_callback_fn*)user_supplied_bug19 },
+ {"user_supplied_bug20", 1, (test_callback_fn*)user_supplied_bug20 },
+ {"user_supplied_bug21", 1, (test_callback_fn*)user_supplied_bug21 },
+ {"wrong_failure_counter_test", 1, (test_callback_fn*)wrong_failure_counter_test},
+ {"wrong_failure_counter_two_test", 1, (test_callback_fn*)wrong_failure_counter_two_test},
+ {0, 0, (test_callback_fn*)0}
};
test_st replication_tests[]= {
- {"set", 1, (test_callback_fn)replication_set_test },
- {"get", 0, (test_callback_fn)replication_get_test },
- {"mget", 0, (test_callback_fn)replication_mget_test },
- {"delete", 0, (test_callback_fn)replication_delete_test },
- {"rand_mget", 0, (test_callback_fn)replication_randomize_mget_test },
- {"fail", 0, (test_callback_fn)replication_randomize_mget_fail_test },
- {0, 0, (test_callback_fn)0}
+ {"set", 1, (test_callback_fn*)replication_set_test },
+ {"get", 0, (test_callback_fn*)replication_get_test },
+ {"mget", 0, (test_callback_fn*)replication_mget_test },
+ {"delete", 0, (test_callback_fn*)replication_delete_test },
+ {"rand_mget", 0, (test_callback_fn*)replication_randomize_mget_test },
+ {"fail", 0, (test_callback_fn*)replication_randomize_mget_fail_test },
+ {0, 0, (test_callback_fn*)0}
};
/*
* http://bugs.launchpad.net/libmemcached
*/
test_st regression_tests[]= {
- {"lp:434484", 1, (test_callback_fn)regression_bug_434484 },
- {"lp:434843", 1, (test_callback_fn)regression_bug_434843 },
- {"lp:434843-buffered", 1, (test_callback_fn)regression_bug_434843_buffered },
- {"lp:421108", 1, (test_callback_fn)regression_bug_421108 },
- {"lp:442914", 1, (test_callback_fn)regression_bug_442914 },
- {"lp:447342", 1, (test_callback_fn)regression_bug_447342 },
- {"lp:463297", 1, (test_callback_fn)regression_bug_463297 },
- {"lp:490486", 1, (test_callback_fn)regression_bug_490486 },
- {"lp:583031", 1, (test_callback_fn)regression_bug_583031 },
- {"lp:?", 1, (test_callback_fn)regression_bug_ },
- {"lp:728286", 1, (test_callback_fn)regression_bug_728286 },
- {"lp:581030", 1, (test_callback_fn)regression_bug_581030 },
- {"lp:71231153 connect()", 1, (test_callback_fn)regression_bug_71231153_connect },
- {"lp:71231153 poll()", 1, (test_callback_fn)regression_bug_71231153_poll },
- {"lp:655423", 1, (test_callback_fn)regression_bug_655423 },
- {"lp:490520", 1, (test_callback_fn)regression_bug_490520 },
- {0, 0, (test_callback_fn)0}
+ {"lp:434484", 1, (test_callback_fn*)regression_bug_434484 },
+ {"lp:434843", 1, (test_callback_fn*)regression_bug_434843 },
+ {"lp:434843-buffered", 1, (test_callback_fn*)regression_bug_434843_buffered },
+ {"lp:421108", 1, (test_callback_fn*)regression_bug_421108 },
+ {"lp:442914", 1, (test_callback_fn*)regression_bug_442914 },
+ {"lp:447342", 1, (test_callback_fn*)regression_bug_447342 },
+ {"lp:463297", 1, (test_callback_fn*)regression_bug_463297 },
+ {"lp:490486", 1, (test_callback_fn*)regression_bug_490486 },
+ {"lp:583031", 1, (test_callback_fn*)regression_bug_583031 },
+ {"lp:?", 1, (test_callback_fn*)regression_bug_ },
+ {"lp:728286", 1, (test_callback_fn*)regression_bug_728286 },
+ {"lp:581030", 1, (test_callback_fn*)regression_bug_581030 },
+ {"lp:71231153 connect()", 1, (test_callback_fn*)regression_bug_71231153_connect },
+ {"lp:71231153 poll()", 1, (test_callback_fn*)regression_bug_71231153_poll },
+ {"lp:655423", 1, (test_callback_fn*)regression_bug_655423 },
+ {"lp:490520", 1, (test_callback_fn*)regression_bug_490520 },
+ {0, 0, (test_callback_fn*)0}
};
test_st sasl_auth_tests[]= {
- {"sasl_auth", 1, (test_callback_fn)sasl_auth_test },
- {0, 0, (test_callback_fn)0}
+ {"sasl_auth", 1, (test_callback_fn*)sasl_auth_test },
+ {0, 0, (test_callback_fn*)0}
};
test_st ketama_compatibility[]= {
- {"libmemcached", 1, (test_callback_fn)ketama_compatibility_libmemcached },
- {"spymemcached", 1, (test_callback_fn)ketama_compatibility_spymemcached },
- {0, 0, (test_callback_fn)0}
+ {"libmemcached", 1, (test_callback_fn*)ketama_compatibility_libmemcached },
+ {"spymemcached", 1, (test_callback_fn*)ketama_compatibility_spymemcached },
+ {0, 0, (test_callback_fn*)0}
};
test_st generate_tests[] ={
- {"generate_pairs", 1, (test_callback_fn)generate_pairs },
- {"generate_data", 1, (test_callback_fn)generate_data },
- {"get_read", 0, (test_callback_fn)get_read },
- {"delete_generate", 0, (test_callback_fn)delete_generate },
- {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
- {"delete_buffer", 0, (test_callback_fn)delete_buffer_generate},
- {"generate_data", 1, (test_callback_fn)generate_data },
- {"mget_read", 0, (test_callback_fn)mget_read },
- {"mget_read_result", 0, (test_callback_fn)mget_read_result },
- {"memcached_fetch_result() use internal result", 0, (test_callback_fn)mget_read_internal_result },
- {"memcached_fetch_result() partial read", 0, (test_callback_fn)mget_read_partial_result },
- {"mget_read_function", 0, (test_callback_fn)mget_read_function },
- {"cleanup", 1, (test_callback_fn)cleanup_pairs },
- {"generate_large_pairs", 1, (test_callback_fn)generate_large_pairs },
- {"generate_data", 1, (test_callback_fn)generate_data },
- {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
- {"cleanup", 1, (test_callback_fn)cleanup_pairs },
- {0, 0, (test_callback_fn)0}
+ {"generate_pairs", 1, (test_callback_fn*)generate_pairs },
+ {"generate_data", 1, (test_callback_fn*)generate_data },
+ {"get_read", 0, (test_callback_fn*)get_read },
+ {"delete_generate", 0, (test_callback_fn*)delete_generate },
+ {"generate_buffer_data", 1, (test_callback_fn*)generate_buffer_data },
+ {"delete_buffer", 0, (test_callback_fn*)delete_buffer_generate},
+ {"generate_data", 1, (test_callback_fn*)generate_data },
+ {"mget_read", 0, (test_callback_fn*)mget_read },
+ {"mget_read_result", 0, (test_callback_fn*)mget_read_result },
+ {"memcached_fetch_result() use internal result", 0, (test_callback_fn*)mget_read_internal_result },
+ {"memcached_fetch_result() partial read", 0, (test_callback_fn*)mget_read_partial_result },
+ {"mget_read_function", 0, (test_callback_fn*)mget_read_function },
+ {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
+ {"generate_large_pairs", 1, (test_callback_fn*)generate_large_pairs },
+ {"generate_data", 1, (test_callback_fn*)generate_data },
+ {"generate_buffer_data", 1, (test_callback_fn*)generate_buffer_data },
+ {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
+ {0, 0, (test_callback_fn*)0}
};
test_st consistent_tests[] ={
- {"generate_pairs", 1, (test_callback_fn)generate_pairs },
- {"generate_data", 1, (test_callback_fn)generate_data },
- {"get_read", 0, (test_callback_fn)get_read_count },
- {"cleanup", 1, (test_callback_fn)cleanup_pairs },
- {0, 0, (test_callback_fn)0}
+ {"generate_pairs", 1, (test_callback_fn*)generate_pairs },
+ {"generate_data", 1, (test_callback_fn*)generate_data },
+ {"get_read", 0, (test_callback_fn*)get_read_count },
+ {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
+ {0, 0, (test_callback_fn*)0}
};
test_st consistent_weighted_tests[] ={
- {"generate_pairs", 1, (test_callback_fn)generate_pairs },
- {"generate_data", 1, (test_callback_fn)generate_data_with_stats },
- {"get_read", 0, (test_callback_fn)get_read_count },
- {"cleanup", 1, (test_callback_fn)cleanup_pairs },
- {0, 0, (test_callback_fn)0}
+ {"generate_pairs", 1, (test_callback_fn*)generate_pairs },
+ {"generate_data", 1, (test_callback_fn*)generate_data_with_stats },
+ {"get_read", 0, (test_callback_fn*)get_read_count },
+ {"cleanup", 1, (test_callback_fn*)cleanup_pairs },
+ {0, 0, (test_callback_fn*)0}
};
test_st hsieh_availability[] ={
- {"hsieh_avaibility_test", 0, (test_callback_fn)hsieh_avaibility_test},
- {0, 0, (test_callback_fn)0}
+ {"hsieh_avaibility_test", 0, (test_callback_fn*)hsieh_avaibility_test},
+ {0, 0, (test_callback_fn*)0}
};
test_st murmur_availability[] ={
- {"murmur_avaibility_test", 0, (test_callback_fn)murmur_avaibility_test},
- {0, 0, (test_callback_fn)0}
+ {"murmur_avaibility_test", 0, (test_callback_fn*)murmur_avaibility_test},
+ {0, 0, (test_callback_fn*)0}
};
#if 0
test_st hash_sanity[] ={
- {"hash sanity", 0, (test_callback_fn)hash_sanity_test},
- {0, 0, (test_callback_fn)0}
+ {"hash sanity", 0, (test_callback_fn*)hash_sanity_test},
+ {0, 0, (test_callback_fn*)0}
};
#endif
test_st ketama_auto_eject_hosts[] ={
- {"auto_eject_hosts", 1, (test_callback_fn)auto_eject_hosts },
- {"output_ketama_weighted_keys", 1, (test_callback_fn)output_ketama_weighted_keys },
- {0, 0, (test_callback_fn)0}
+ {"auto_eject_hosts", 1, (test_callback_fn*)auto_eject_hosts },
+ {"output_ketama_weighted_keys", 1, (test_callback_fn*)output_ketama_weighted_keys },
+ {0, 0, (test_callback_fn*)0}
};
test_st hash_tests[] ={
- {"one_at_a_time_run", 0, (test_callback_fn)one_at_a_time_run },
- {"md5", 0, (test_callback_fn)md5_run },
- {"crc", 0, (test_callback_fn)crc_run },
- {"fnv1_64", 0, (test_callback_fn)fnv1_64_run },
- {"fnv1a_64", 0, (test_callback_fn)fnv1a_64_run },
- {"fnv1_32", 0, (test_callback_fn)fnv1_32_run },
- {"fnv1a_32", 0, (test_callback_fn)fnv1a_32_run },
- {"hsieh", 0, (test_callback_fn)hsieh_run },
- {"murmur", 0, (test_callback_fn)murmur_run },
- {"jenkis", 0, (test_callback_fn)jenkins_run },
- {"memcached_get_hashkit", 0, (test_callback_fn)memcached_get_hashkit_test },
- {0, 0, (test_callback_fn)0}
+ {"one_at_a_time_run", 0, (test_callback_fn*)one_at_a_time_run },
+ {"md5", 0, (test_callback_fn*)md5_run },
+ {"crc", 0, (test_callback_fn*)crc_run },
+ {"fnv1_64", 0, (test_callback_fn*)fnv1_64_run },
+ {"fnv1a_64", 0, (test_callback_fn*)fnv1a_64_run },
+ {"fnv1_32", 0, (test_callback_fn*)fnv1_32_run },
+ {"fnv1a_32", 0, (test_callback_fn*)fnv1a_32_run },
+ {"hsieh", 0, (test_callback_fn*)hsieh_run },
+ {"murmur", 0, (test_callback_fn*)murmur_run },
+ {"jenkis", 0, (test_callback_fn*)jenkins_run },
+ {"memcached_get_hashkit", 0, (test_callback_fn*)memcached_get_hashkit_test },
+ {0, 0, (test_callback_fn*)0}
};
test_st error_conditions[] ={
- {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_MEMCACHED_ERRNO },
- {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
- {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_ERRNO },
- {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
- {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
- {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn)memcached_increment_MEMCACHED_NO_SERVERS },
- {0, 0, (test_callback_fn)0}
+ {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn*)memcached_get_MEMCACHED_ERRNO },
+ {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn*)memcached_get_MEMCACHED_NOTFOUND },
+ {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn*)memcached_get_by_key_MEMCACHED_ERRNO },
+ {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn*)memcached_get_by_key_MEMCACHED_NOTFOUND },
+ {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn*)memcached_get_by_key_MEMCACHED_NOTFOUND },
+ {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn*)memcached_increment_MEMCACHED_NO_SERVERS },
+ {0, 0, (test_callback_fn*)0}
};
test_st parser_tests[] ={
- {"behavior", 0, (test_callback_fn)behavior_parser_test },
- {"boolean_options", 0, (test_callback_fn)parser_boolean_options_test },
- {"configure_file", 0, (test_callback_fn)memcached_create_with_options_with_filename },
- {"distribtions", 0, (test_callback_fn)parser_distribution_test },
- {"hash", 0, (test_callback_fn)parser_hash_test },
- {"libmemcached_check_configuration", 0, (test_callback_fn)libmemcached_check_configuration_test },
- {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn)libmemcached_check_configuration_with_filename_test },
- {"number_options", 0, (test_callback_fn)parser_number_options_test },
- {"randomly generated options", 0, (test_callback_fn)random_statement_build_test },
- {"prefix_key", 0, (test_callback_fn)parser_key_prefix_test },
- {"server", 0, (test_callback_fn)server_test },
- {"bad server strings", 0, (test_callback_fn)servers_bad_test },
- {"server with weights", 0, (test_callback_fn)server_with_weight_test },
- {"parsing servername, port, and weight", 0, (test_callback_fn)test_hostname_port_weight },
- {0, 0, (test_callback_fn)0}
+ {"behavior", 0, (test_callback_fn*)behavior_parser_test },
+ {"boolean_options", 0, (test_callback_fn*)parser_boolean_options_test },
+ {"configure_file", 0, (test_callback_fn*)memcached_create_with_options_with_filename },
+ {"distribtions", 0, (test_callback_fn*)parser_distribution_test },
+ {"hash", 0, (test_callback_fn*)parser_hash_test },
+ {"libmemcached_check_configuration", 0, (test_callback_fn*)libmemcached_check_configuration_test },
+ {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn*)libmemcached_check_configuration_with_filename_test },
+ {"number_options", 0, (test_callback_fn*)parser_number_options_test },
+ {"randomly generated options", 0, (test_callback_fn*)random_statement_build_test },
+ {"prefix_key", 0, (test_callback_fn*)parser_key_prefix_test },
+ {"server", 0, (test_callback_fn*)server_test },
+ {"bad server strings", 0, (test_callback_fn*)servers_bad_test },
+ {"server with weights", 0, (test_callback_fn*)server_with_weight_test },
+ {"parsing servername, port, and weight", 0, (test_callback_fn*)test_hostname_port_weight },
+ {0, 0, (test_callback_fn*)0}
};
test_st virtual_bucket_tests[] ={
- {"basic", 0, (test_callback_fn)virtual_back_map },
- {0, 0, (test_callback_fn)0}
+ {"basic", 0, (test_callback_fn*)virtual_back_map },
+ {0, 0, (test_callback_fn*)0}
};
collection_st collection[] ={
{"hsieh_availability", 0, 0, hsieh_availability},
{"murmur_availability", 0, 0, murmur_availability},
{"block", 0, 0, tests},
- {"binary", (test_callback_fn)pre_binary, 0, tests},
- {"nonblock", (test_callback_fn)pre_nonblock, 0, tests},
- {"nodelay", (test_callback_fn)pre_nodelay, 0, tests},
- {"settimer", (test_callback_fn)pre_settimer, 0, tests},
- {"md5", (test_callback_fn)pre_md5, 0, tests},
- {"crc", (test_callback_fn)pre_crc, 0, tests},
- {"hsieh", (test_callback_fn)pre_hsieh, 0, tests},
- {"jenkins", (test_callback_fn)pre_jenkins, 0, tests},
- {"fnv1_64", (test_callback_fn)pre_hash_fnv1_64, 0, tests},
- {"fnv1a_64", (test_callback_fn)pre_hash_fnv1a_64, 0, tests},
- {"fnv1_32", (test_callback_fn)pre_hash_fnv1_32, 0, tests},
- {"fnv1a_32", (test_callback_fn)pre_hash_fnv1a_32, 0, tests},
- {"ketama", (test_callback_fn)pre_behavior_ketama, 0, tests},
- {"ketama_auto_eject_hosts", (test_callback_fn)pre_behavior_ketama, 0, ketama_auto_eject_hosts},
- {"unix_socket", (test_callback_fn)pre_unix_socket, 0, tests},
- {"unix_socket_nodelay", (test_callback_fn)pre_nodelay, 0, tests},
- {"poll_timeout", (test_callback_fn)poll_timeout, 0, tests},
- {"gets", (test_callback_fn)enable_cas, 0, tests},
- {"consistent_crc", (test_callback_fn)enable_consistent_crc, 0, tests},
- {"consistent_hsieh", (test_callback_fn)enable_consistent_hsieh, 0, tests},
+ {"binary", (test_callback_fn*)pre_binary, 0, tests},
+ {"nonblock", (test_callback_fn*)pre_nonblock, 0, tests},
+ {"nodelay", (test_callback_fn*)pre_nodelay, 0, tests},
+ {"settimer", (test_callback_fn*)pre_settimer, 0, tests},
+ {"md5", (test_callback_fn*)pre_md5, 0, tests},
+ {"crc", (test_callback_fn*)pre_crc, 0, tests},
+ {"hsieh", (test_callback_fn*)pre_hsieh, 0, tests},
+ {"jenkins", (test_callback_fn*)pre_jenkins, 0, tests},
+ {"fnv1_64", (test_callback_fn*)pre_hash_fnv1_64, 0, tests},
+ {"fnv1a_64", (test_callback_fn*)pre_hash_fnv1a_64, 0, tests},
+ {"fnv1_32", (test_callback_fn*)pre_hash_fnv1_32, 0, tests},
+ {"fnv1a_32", (test_callback_fn*)pre_hash_fnv1a_32, 0, tests},
+ {"ketama", (test_callback_fn*)pre_behavior_ketama, 0, tests},
+ {"ketama_auto_eject_hosts", (test_callback_fn*)pre_behavior_ketama, 0, ketama_auto_eject_hosts},
+ {"unix_socket", (test_callback_fn*)pre_unix_socket, 0, tests},
+ {"unix_socket_nodelay", (test_callback_fn*)pre_nodelay, 0, tests},
+ {"poll_timeout", (test_callback_fn*)poll_timeout, 0, tests},
+ {"gets", (test_callback_fn*)enable_cas, 0, tests},
+ {"consistent_crc", (test_callback_fn*)enable_consistent_crc, 0, tests},
+ {"consistent_hsieh", (test_callback_fn*)enable_consistent_hsieh, 0, tests},
#ifdef MEMCACHED_ENABLE_DEPRECATED
- {"deprecated_memory_allocators", (test_callback_fn)deprecated_set_memory_alloc, 0, tests},
+ {"deprecated_memory_allocators", (test_callback_fn*)deprecated_set_memory_alloc, 0, tests},
#endif
- {"memory_allocators", (test_callback_fn)set_memory_alloc, 0, tests},
- {"prefix", (test_callback_fn)set_prefix, 0, tests},
- {"sasl_auth", (test_callback_fn)pre_sasl, 0, sasl_auth_tests },
- {"sasl", (test_callback_fn)pre_sasl, 0, tests },
- {"version_1_2_3", (test_callback_fn)check_for_1_2_3, 0, version_1_2_3},
+ {"memory_allocators", (test_callback_fn*)set_memory_alloc, 0, tests},
+ {"prefix", (test_callback_fn*)set_prefix, 0, tests},
+ {"sasl_auth", (test_callback_fn*)pre_sasl, 0, sasl_auth_tests },
+ {"sasl", (test_callback_fn*)pre_sasl, 0, tests },
+ {"version_1_2_3", (test_callback_fn*)check_for_1_2_3, 0, version_1_2_3},
{"string", 0, 0, string_tests},
{"result", 0, 0, result_tests},
- {"async", (test_callback_fn)pre_nonblock, 0, async_tests},
- {"async_binary", (test_callback_fn)pre_nonblock_binary, 0, async_tests},
+ {"async", (test_callback_fn*)pre_nonblock, 0, async_tests},
+ {"async_binary", (test_callback_fn*)pre_nonblock_binary, 0, async_tests},
{"Cal Haldenbrand's tests", 0, 0, haldenbrand_tests},
{"user", 0, 0, user_tests},
{"generate", 0, 0, generate_tests},
- {"generate_hsieh", (test_callback_fn)pre_hsieh, 0, generate_tests},
- {"generate_ketama", (test_callback_fn)pre_behavior_ketama, 0, generate_tests},
- {"generate_hsieh_consistent", (test_callback_fn)enable_consistent_hsieh, 0, generate_tests},
- {"generate_md5", (test_callback_fn)pre_md5, 0, generate_tests},
- {"generate_murmur", (test_callback_fn)pre_murmur, 0, generate_tests},
- {"generate_jenkins", (test_callback_fn)pre_jenkins, 0, generate_tests},
- {"generate_nonblock", (test_callback_fn)pre_nonblock, 0, generate_tests},
+ {"generate_hsieh", (test_callback_fn*)pre_hsieh, 0, generate_tests},
+ {"generate_ketama", (test_callback_fn*)pre_behavior_ketama, 0, generate_tests},
+ {"generate_hsieh_consistent", (test_callback_fn*)enable_consistent_hsieh, 0, generate_tests},
+ {"generate_md5", (test_callback_fn*)pre_md5, 0, generate_tests},
+ {"generate_murmur", (test_callback_fn*)pre_murmur, 0, generate_tests},
+ {"generate_jenkins", (test_callback_fn*)pre_jenkins, 0, generate_tests},
+ {"generate_nonblock", (test_callback_fn*)pre_nonblock, 0, generate_tests},
// Too slow
- {"generate_corked", (test_callback_fn)pre_cork, 0, generate_tests},
- {"generate_corked_and_nonblock", (test_callback_fn)pre_cork_and_nonblock, 0, generate_tests},
+ {"generate_corked", (test_callback_fn*)pre_cork, 0, generate_tests},
+ {"generate_corked_and_nonblock", (test_callback_fn*)pre_cork_and_nonblock, 0, generate_tests},
{"consistent_not", 0, 0, consistent_tests},
- {"consistent_ketama", (test_callback_fn)pre_behavior_ketama, 0, consistent_tests},
- {"consistent_ketama_weighted", (test_callback_fn)pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
+ {"consistent_ketama", (test_callback_fn*)pre_behavior_ketama, 0, consistent_tests},
+ {"consistent_ketama_weighted", (test_callback_fn*)pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
{"ketama_compat", 0, 0, ketama_compatibility},
{"test_hashes", 0, 0, hash_tests},
- {"replication", (test_callback_fn)pre_replication, 0, replication_tests},
- {"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests},
+ {"replication", (test_callback_fn*)pre_replication, 0, replication_tests},
+ {"replication_noblock", (test_callback_fn*)pre_replication_noblock, 0, replication_tests},
{"regression", 0, 0, regression_tests},
{"behaviors", 0, 0, behavior_tests},
- {"regression_binary_vs_block", (test_callback_fn)key_setup, (test_callback_fn)key_teardown, regression_binary_vs_block},
+ {"regression_binary_vs_block", (test_callback_fn*)key_setup, (test_callback_fn*)key_teardown, regression_binary_vs_block},
{"error_conditions", 0, 0, error_conditions},
{"parser", 0, 0, parser_tests},
{"virtual buckets", 0, 0, virtual_bucket_tests},
{
world->collections= collection;
- world->create= (test_callback_create_fn)world_create;
- world->destroy= (test_callback_fn)world_destroy;
+ world->create= (test_callback_create_fn*)world_create;
+ world->destroy= (test_callback_fn*)world_destroy;
- world->test.startup= (test_callback_fn)world_test_startup;
- world->test.flush= (test_callback_fn)world_flush;
- world->test.pre_run= (test_callback_fn)world_pre_run;
- world->test.post_run= (test_callback_fn)world_post_run;
- world->test.on_error= (test_callback_error_fn)world_on_error;
+ world->run_startup= (test_callback_fn*)world_test_startup;
+ world->flush= (test_callback_fn*)world_flush;
+ world->pre_run= (test_callback_fn*)world_pre_run;
+ world->post_run= (test_callback_fn*)world_post_run;
+ world->on_error= (test_callback_error_fn*)world_on_error;
- world->collection.startup= (test_callback_fn)world_container_startup;
- world->collection.shutdown= (test_callback_fn)world_container_shutdown;
+ world->collection_startup= (test_callback_fn*)world_container_startup;
+ world->collection_shutdown= (test_callback_fn*)world_container_shutdown;
world->runner= &defualt_libmemcached_runner;
}
+++ /dev/null
-/* libMemcached Functions Test
- * Copyright (C) 2006-2009 Brian Aker
- * All rights reserved.
- *
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
- */
-
-/*
- Sample test application.
-*/
-
-#include "config.h"
-
-#include "libmemcached/common.h"
-
-#include <assert.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <signal.h>
-#include <unistd.h>
-#include <time.h>
-
-#include <libtest/server.h>
-#include <libtest/test.h>
-
-#define SERVERS_TO_CREATE 5
-
-
-/**
- @note This should be testing to see if the server really supports the binary protocol.
-*/
-static test_return_t pre_binary(memcached_st *memc)
-{
- memcached_return_t rc= MEMCACHED_FAILURE;
- memcached_st *memc_clone;
- memcached_server_instance_st instance;
-
- memc_clone= memcached_clone(NULL, memc);
- test_true(memc_clone);
- // The memcached_version needs to be done on a clone, because the server
- // will not toggle protocol on an connection.
- memcached_version(memc_clone);
-
- instance= memcached_server_instance_by_position(memc_clone, 0);
-
- if (instance->major_version >= 1 && instance->minor_version > 2)
- {
- rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
- test_true(rc == MEMCACHED_SUCCESS);
- test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
- }
-
- memcached_free(memc_clone);
-
- return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
-}
-
-static void increment_request_id(uint16_t *id)
-{
- (*id)++;
- if ((*id & UDP_REQUEST_ID_THREAD_MASK) != 0)
- *id= 0;
-}
-
-static uint16_t *get_udp_request_ids(memcached_st *memc)
-{
- uint16_t *ids= malloc(sizeof(uint16_t) * memcached_server_count(memc));
- assert(ids != NULL);
-
- for (uint32_t x= 0; x < memcached_server_count(memc); x++)
- {
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, x);
-
- ids[x]= get_udp_datagram_request_id((struct udp_datagram_header_st *) ((memcached_server_instance_st )instance)->write_buffer);
- }
-
- return ids;
-}
-
-static test_return_t post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ids)
-{
- (void)memc;
- (void)expected_req_ids;
-#if 0
- memcached_server_st *cur_server = memcached_server_list(memc);
- uint16_t *cur_req_ids = get_udp_request_ids(memc);
-
- for (size_t x= 0; x < memcached_server_count(memc); x++)
- {
- test_true(cur_server[x].cursor_active == 0);
- test_true(cur_req_ids[x] == expected_req_ids[x]);
- }
- free(expected_req_ids);
- free(cur_req_ids);
-
-#endif
- return TEST_SUCCESS;
-}
-
-/*
-** There is a little bit of a hack here, instead of removing
-** the servers, I just set num host to 0 and them add then new udp servers
-**/
-static test_return_t init_udp(memcached_st *memc)
-{
- memcached_version(memc);
-#if 0
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, 0);
-
- /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
- if (instance->major_version != 1 || instance->minor_version != 2
- || instance->micro_version < 6)
- return TEST_SKIPPED;
-
- uint32_t num_hosts= memcached_server_count(memc);
- memcached_server_st servers[num_hosts];
- memcpy(servers, memcached_server_list(memc), sizeof(memcached_server_st) * num_hosts);
- for (uint32_t x= 0; x < num_hosts; x++)
- {
- memcached_server_instance_st set_instance=
- memcached_server_instance_by_position(memc, x);
-
- memcached_server_free(((memcached_server_write_instance_st)set_instance));
- }
-
- memc->number_of_hosts= 0;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1);
- for (uint32_t x= 0; x < num_hosts; x++)
- {
- memcached_server_instance_st set_instance=
- memcached_server_instance_by_position(memc, x);
-
- test_true(memcached_server_add_udp(memc, servers[x].hostname, servers[x].port) == MEMCACHED_SUCCESS);
- test_true(set_instance->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
- }
-#endif
-
- return TEST_SKIPPED;
-}
-
-static test_return_t binary_init_udp(memcached_st *memc)
-{
- test_return_t test_rc;
- test_rc= pre_binary(memc);
-
- if (test_rc != TEST_SUCCESS)
- return test_rc;
-
- return init_udp(memc);
-}
-
-/* Make sure that I cant add a tcp server to a udp client */
-static test_return_t add_tcp_server_udp_client_test(memcached_st *memc)
-{
- (void)memc;
-#if 0
- memcached_server_st server;
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, 0);
- memcached_server_clone(&server, &memc->hosts[0]);
- test_true(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
- test_true(memcached_server_add(memc, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
-#endif
- return TEST_SUCCESS;
-}
-
-/* Make sure that I cant add a udp server to a tcp client */
-static test_return_t add_udp_server_tcp_client_test(memcached_st *memc)
-{
- (void)memc;
-#if 0
- memcached_server_st server;
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, 0);
- memcached_server_clone(&server, &memc->hosts[0]);
- test_true(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
-
- memcached_st tcp_client;
- memcached_create(&tcp_client);
- test_true(memcached_server_add_udp(&tcp_client, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
-#endif
-
- return TEST_SUCCESS;
-}
-
-static test_return_t set_udp_behavior_test(memcached_st *memc)
-{
-
- memcached_quit(memc);
- memc->number_of_hosts= 0;
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, memc->distribution);
- test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1) == MEMCACHED_SUCCESS);
- test_true(memc->flags.use_udp);
- test_true(memc->flags.no_reply);
-
- test_true(memcached_server_count(memc) == 0);
-
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP,0);
- test_true(! (memc->flags.use_udp));
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY,0);
- test_true(! (memc->flags.no_reply));
-
- return TEST_SUCCESS;
-}
-
-static test_return_t udp_set_test(memcached_st *memc)
-{
- unsigned int num_iters= 1025; //request id rolls over at 1024
-
- for (size_t x= 0; x < num_iters;x++)
- {
- memcached_return_t rc;
- const char *key= "foo";
- const char *value= "when we sanitize";
- uint16_t *expected_ids= get_udp_request_ids(memc);
- unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, server_key);
- size_t init_offset= instance->write_buffer_offset;
-
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
- /** NB, the check below assumes that if new write_ptr is less than
- * the original write_ptr that we have flushed. For large payloads, this
- * maybe an invalid assumption, but for the small payload we have it is OK
- */
- if (rc == MEMCACHED_SUCCESS ||
- instance->write_buffer_offset < init_offset)
- increment_request_id(&expected_ids[server_key]);
-
- if (rc == MEMCACHED_SUCCESS)
- {
- test_true(instance->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
- }
- else
- {
- test_true(instance->write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
- test_true(instance->write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
- }
- test_true(post_udp_op_check(memc, expected_ids) == TEST_SUCCESS);
- }
- return TEST_SUCCESS;
-}
-
-static test_return_t udp_buffered_set_test(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
- return udp_set_test(memc);
-}
-
-static test_return_t udp_set_too_big_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "bar";
- char value[MAX_UDP_DATAGRAM_LENGTH];
- uint16_t *expected_ids= get_udp_request_ids(memc);
- rc= memcached_set(memc, key, strlen(key),
- value, MAX_UDP_DATAGRAM_LENGTH,
- (time_t)0, (uint32_t)0);
- test_true(rc == MEMCACHED_WRITE_FAILURE);
-
- return post_udp_op_check(memc,expected_ids);
-}
-
-static test_return_t udp_delete_test(memcached_st *memc)
-{
- unsigned int num_iters= 1025; //request id rolls over at 1024
-
- for (size_t x= 0; x < num_iters;x++)
- {
- memcached_return_t rc;
- const char *key= "foo";
- uint16_t *expected_ids=get_udp_request_ids(memc);
- unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
- memcached_server_instance_st instance=
- memcached_server_instance_by_position(memc, server_key);
- size_t init_offset= instance->write_buffer_offset;
-
- rc= memcached_delete(memc, key, strlen(key), 0);
- test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
-
- if (rc == MEMCACHED_SUCCESS || instance->write_buffer_offset < init_offset)
- increment_request_id(&expected_ids[server_key]);
- if (rc == MEMCACHED_SUCCESS)
- {
- test_true(instance->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
- }
- else
- {
- test_true(instance->write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
- test_true(instance->write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
- }
- test_true(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
- }
- return TEST_SUCCESS;
-}
-
-static test_return_t udp_buffered_delete_test(memcached_st *memc)
-{
- memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
- return udp_delete_test(memc);
-}
-
-static test_return_t udp_verbosity_test(memcached_st *memc)
-{
- memcached_return_t rc;
- uint16_t *expected_ids= get_udp_request_ids(memc);
-
- for (size_t x= 0; x < memcached_server_count(memc); x++)
- {
- increment_request_id(&expected_ids[x]);
- }
-
- rc= memcached_verbosity(memc,3);
- test_true(rc == MEMCACHED_SUCCESS);
- return post_udp_op_check(memc,expected_ids);
-}
-
-static test_return_t udp_quit_test(memcached_st *memc)
-{
- uint16_t *expected_ids= get_udp_request_ids(memc);
- memcached_quit(memc);
- return post_udp_op_check(memc, expected_ids);
-}
-
-static test_return_t udp_flush_test(memcached_st *memc)
-{
- memcached_return_t rc;
- uint16_t *expected_ids= get_udp_request_ids(memc);
-
- for (size_t x= 0; x < memcached_server_count(memc); x++)
- {
- increment_request_id(&expected_ids[x]);
- }
-
- rc= memcached_flush(memc,0);
- test_true(rc == MEMCACHED_SUCCESS);
- return post_udp_op_check(memc,expected_ids);
-}
-
-static test_return_t udp_incr_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "incr";
- const char *value= "1";
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
-
- test_true(rc == MEMCACHED_SUCCESS);
- uint16_t *expected_ids= get_udp_request_ids(memc);
- unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
- increment_request_id(&expected_ids[server_key]);
- uint64_t newvalue;
- rc= memcached_increment(memc, key, strlen(key), 1, &newvalue);
- test_true(rc == MEMCACHED_SUCCESS);
- return post_udp_op_check(memc, expected_ids);
-}
-
-static test_return_t udp_decr_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "decr";
- const char *value= "1";
- rc= memcached_set(memc, key, strlen(key),
- value, strlen(value),
- (time_t)0, (uint32_t)0);
-
- test_true(rc == MEMCACHED_SUCCESS);
- uint16_t *expected_ids= get_udp_request_ids(memc);
- unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
- increment_request_id(&expected_ids[server_key]);
- uint64_t newvalue;
- rc= memcached_decrement(memc, key, strlen(key), 1, &newvalue);
- test_true(rc == MEMCACHED_SUCCESS);
- return post_udp_op_check(memc, expected_ids);
-}
-
-
-static test_return_t udp_stat_test(memcached_st *memc)
-{
- memcached_stat_st * rv= NULL;
- memcached_return_t rc;
- char args[]= "";
- uint16_t *expected_ids = get_udp_request_ids(memc);
- rv = memcached_stat(memc, args, &rc);
- free(rv);
- test_true(rc == MEMCACHED_NOT_SUPPORTED);
- return post_udp_op_check(memc, expected_ids);
-}
-
-static test_return_t udp_version_test(memcached_st *memc)
-{
- memcached_return_t rc;
- uint16_t *expected_ids = get_udp_request_ids(memc);
- rc = memcached_version(memc);
- test_true(rc == MEMCACHED_NOT_SUPPORTED);
- return post_udp_op_check(memc, expected_ids);
-}
-
-static test_return_t udp_get_test(memcached_st *memc)
-{
- memcached_return_t rc;
- const char *key= "foo";
- size_t vlen;
- uint16_t *expected_ids = get_udp_request_ids(memc);
- char *val= memcached_get(memc, key, strlen(key), &vlen, (uint32_t)0, &rc);
- test_true(rc == MEMCACHED_NOT_SUPPORTED);
- test_true(val == NULL);
- return post_udp_op_check(memc, expected_ids);
-}
-
-static test_return_t udp_mixed_io_test(memcached_st *memc)
-{
- test_st current_op;
- test_st mixed_io_ops [] ={
- {"udp_set_test", 0,
- (test_callback_fn)udp_set_test},
- {"udp_set_too_big_test", 0,
- (test_callback_fn)udp_set_too_big_test},
- {"udp_delete_test", 0,
- (test_callback_fn)udp_delete_test},
- {"udp_verbosity_test", 0,
- (test_callback_fn)udp_verbosity_test},
- {"udp_quit_test", 0,
- (test_callback_fn)udp_quit_test},
- {"udp_flush_test", 0,
- (test_callback_fn)udp_flush_test},
- {"udp_incr_test", 0,
- (test_callback_fn)udp_incr_test},
- {"udp_decr_test", 0,
- (test_callback_fn)udp_decr_test},
- {"udp_version_test", 0,
- (test_callback_fn)udp_version_test}
- };
-
- for (size_t x= 0; x < 500; x++)
- {
- current_op= mixed_io_ops[random() % 9];
- test_true(current_op.test_fn(memc) == TEST_SUCCESS);
- }
- return TEST_SUCCESS;
-}
-
-test_st udp_setup_server_tests[] ={
- {"set_udp_behavior_test", 0, (test_callback_fn)set_udp_behavior_test},
- {"add_tcp_server_udp_client_test", 0, (test_callback_fn)add_tcp_server_udp_client_test},
- {"add_udp_server_tcp_client_test", 0, (test_callback_fn)add_udp_server_tcp_client_test},
- {0, 0, 0}
-};
-
-test_st upd_io_tests[] ={
- {"udp_set_test", 0, (test_callback_fn)udp_set_test},
- {"udp_buffered_set_test", 0, (test_callback_fn)udp_buffered_set_test},
- {"udp_set_too_big_test", 0, (test_callback_fn)udp_set_too_big_test},
- {"udp_delete_test", 0, (test_callback_fn)udp_delete_test},
- {"udp_buffered_delete_test", 0, (test_callback_fn)udp_buffered_delete_test},
- {"udp_verbosity_test", 0, (test_callback_fn)udp_verbosity_test},
- {"udp_quit_test", 0, (test_callback_fn)udp_quit_test},
- {"udp_flush_test", 0, (test_callback_fn)udp_flush_test},
- {"udp_incr_test", 0, (test_callback_fn)udp_incr_test},
- {"udp_decr_test", 0, (test_callback_fn)udp_decr_test},
- {"udp_stat_test", 0, (test_callback_fn)udp_stat_test},
- {"udp_version_test", 0, (test_callback_fn)udp_version_test},
- {"udp_get_test", 0, (test_callback_fn)udp_get_test},
- {"udp_mixed_io_test", 0, (test_callback_fn)udp_mixed_io_test},
- {0, 0, 0}
-};
-
-collection_st collection[] ={
- {"udp_setup", (test_callback_fn)init_udp, 0, udp_setup_server_tests},
- {"udp_io", (test_callback_fn)init_udp, 0, upd_io_tests},
- {"udp_binary_io", (test_callback_fn)binary_init_udp, 0, upd_io_tests},
- {0, 0, 0, 0}
-};
-
-#define SERVERS_TO_CREATE 5
-
-#include "libmemcached_world.h"
-
-void get_world(world_st *world)
-{
- world->collections= collection;
-
- world->create= (test_callback_create_fn)world_create;
- world->destroy= (test_callback_fn)world_destroy;
-
- world->test.startup= (test_callback_fn)world_test_startup;
- world->test.flush= (test_callback_fn)world_flush;
- world->test.pre_run= (test_callback_fn)world_pre_run;
- world->test.post_run= (test_callback_fn)world_post_run;
- world->test.on_error= (test_callback_error_fn)world_on_error;
-
- world->collection.startup= (test_callback_fn)world_container_startup;
- world->collection.shutdown= (test_callback_fn)world_container_shutdown;
-
- world->runner= &defualt_libmemcached_runner;
-}
--- /dev/null
+/* libMemcached Functions Test
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license. See
+ * the COPYING file in the parent directory for full text.
+ */
+
+/*
+ Sample test application.
+*/
+
+#include "config.h"
+
+#include "libmemcached/common.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <unistd.h>
+#include <time.h>
+
+#include <libtest/server.h>
+#include <libtest/test.h>
+
+#define SERVERS_TO_CREATE 5
+
+
+/**
+ @note This should be testing to see if the server really supports the binary protocol.
+*/
+static test_return_t pre_binary(memcached_st *memc)
+{
+ memcached_return_t rc= MEMCACHED_FAILURE;
+ memcached_st *memc_clone;
+ memcached_server_instance_st instance;
+
+ memc_clone= memcached_clone(NULL, memc);
+ test_true(memc_clone);
+ // The memcached_version needs to be done on a clone, because the server
+ // will not toggle protocol on an connection.
+ memcached_version(memc_clone);
+
+ instance= memcached_server_instance_by_position(memc_clone, 0);
+
+ if (instance->major_version >= 1 && instance->minor_version > 2)
+ {
+ rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
+ test_true(rc == MEMCACHED_SUCCESS);
+ test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
+ }
+
+ memcached_free(memc_clone);
+
+ return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
+}
+
+static void increment_request_id(uint16_t *id)
+{
+ (*id)++;
+ if ((*id & UDP_REQUEST_ID_THREAD_MASK) != 0)
+ *id= 0;
+}
+
+static uint16_t *get_udp_request_ids(memcached_st *memc)
+{
+ uint16_t *ids= (uint16_t*)malloc(sizeof(uint16_t) * memcached_server_count(memc));
+ assert(ids);
+
+ for (uint32_t x= 0; x < memcached_server_count(memc); x++)
+ {
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, x);
+
+ ids[x]= get_udp_datagram_request_id((struct udp_datagram_header_st *) ((memcached_server_instance_st )instance)->write_buffer);
+ }
+
+ return ids;
+}
+
+static test_return_t post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ids)
+{
+ (void)memc;
+ (void)expected_req_ids;
+#if 0
+ memcached_server_st *cur_server = memcached_server_list(memc);
+ uint16_t *cur_req_ids = get_udp_request_ids(memc);
+
+ for (size_t x= 0; x < memcached_server_count(memc); x++)
+ {
+ test_true(cur_server[x].cursor_active == 0);
+ test_true(cur_req_ids[x] == expected_req_ids[x]);
+ }
+ free(expected_req_ids);
+ free(cur_req_ids);
+
+#endif
+ return TEST_SUCCESS;
+}
+
+/*
+** There is a little bit of a hack here, instead of removing
+** the servers, I just set num host to 0 and them add then new udp servers
+**/
+static test_return_t init_udp(memcached_st *memc)
+{
+ memcached_version(memc);
+#if 0
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, 0);
+
+ /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
+ if (instance->major_version != 1 || instance->minor_version != 2
+ || instance->micro_version < 6)
+ return TEST_SKIPPED;
+
+ uint32_t num_hosts= memcached_server_count(memc);
+ memcached_server_st servers[num_hosts];
+ memcpy(servers, memcached_server_list(memc), sizeof(memcached_server_st) * num_hosts);
+ for (uint32_t x= 0; x < num_hosts; x++)
+ {
+ memcached_server_instance_st set_instance=
+ memcached_server_instance_by_position(memc, x);
+
+ memcached_server_free(((memcached_server_write_instance_st)set_instance));
+ }
+
+ memc->number_of_hosts= 0;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1);
+ for (uint32_t x= 0; x < num_hosts; x++)
+ {
+ memcached_server_instance_st set_instance=
+ memcached_server_instance_by_position(memc, x);
+
+ test_true(memcached_server_add_udp(memc, servers[x].hostname, servers[x].port) == MEMCACHED_SUCCESS);
+ test_true(set_instance->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
+ }
+#endif
+
+ return TEST_SKIPPED;
+}
+
+static test_return_t binary_init_udp(memcached_st *memc)
+{
+ test_return_t test_rc;
+ test_rc= pre_binary(memc);
+
+ if (test_rc != TEST_SUCCESS)
+ return test_rc;
+
+ return init_udp(memc);
+}
+
+/* Make sure that I cant add a tcp server to a udp client */
+static test_return_t add_tcp_server_udp_client_test(memcached_st *memc)
+{
+ (void)memc;
+#if 0
+ memcached_server_st server;
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, 0);
+ memcached_server_clone(&server, &memc->hosts[0]);
+ test_true(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
+ test_true(memcached_server_add(memc, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
+#endif
+ return TEST_SUCCESS;
+}
+
+/* Make sure that I cant add a udp server to a tcp client */
+static test_return_t add_udp_server_tcp_client_test(memcached_st *memc)
+{
+ (void)memc;
+#if 0
+ memcached_server_st server;
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, 0);
+ memcached_server_clone(&server, &memc->hosts[0]);
+ test_true(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
+
+ memcached_st tcp_client;
+ memcached_create(&tcp_client);
+ test_true(memcached_server_add_udp(&tcp_client, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
+#endif
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t set_udp_behavior_test(memcached_st *memc)
+{
+
+ memcached_quit(memc);
+ memc->number_of_hosts= 0;
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, memc->distribution);
+ test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1) == MEMCACHED_SUCCESS);
+ test_true(memc->flags.use_udp);
+ test_true(memc->flags.no_reply);
+
+ test_true(memcached_server_count(memc) == 0);
+
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP,0);
+ test_true(! (memc->flags.use_udp));
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY,0);
+ test_true(! (memc->flags.no_reply));
+
+ return TEST_SUCCESS;
+}
+
+static test_return_t udp_set_test(memcached_st *memc)
+{
+ unsigned int num_iters= 1025; //request id rolls over at 1024
+
+ for (size_t x= 0; x < num_iters;x++)
+ {
+ memcached_return_t rc;
+ const char *key= "foo";
+ const char *value= "when we sanitize";
+ uint16_t *expected_ids= get_udp_request_ids(memc);
+ unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, server_key);
+ size_t init_offset= instance->write_buffer_offset;
+
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+ /** NB, the check below assumes that if new write_ptr is less than
+ * the original write_ptr that we have flushed. For large payloads, this
+ * maybe an invalid assumption, but for the small payload we have it is OK
+ */
+ if (rc == MEMCACHED_SUCCESS ||
+ instance->write_buffer_offset < init_offset)
+ increment_request_id(&expected_ids[server_key]);
+
+ if (rc == MEMCACHED_SUCCESS)
+ {
+ test_true(instance->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
+ }
+ else
+ {
+ test_true(instance->write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
+ test_true(instance->write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
+ }
+ test_true(post_udp_op_check(memc, expected_ids) == TEST_SUCCESS);
+ }
+ return TEST_SUCCESS;
+}
+
+static test_return_t udp_buffered_set_test(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
+ return udp_set_test(memc);
+}
+
+static test_return_t udp_set_too_big_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "bar";
+ char value[MAX_UDP_DATAGRAM_LENGTH];
+ uint16_t *expected_ids= get_udp_request_ids(memc);
+ rc= memcached_set(memc, key, strlen(key),
+ value, MAX_UDP_DATAGRAM_LENGTH,
+ (time_t)0, (uint32_t)0);
+ test_true(rc == MEMCACHED_WRITE_FAILURE);
+
+ return post_udp_op_check(memc,expected_ids);
+}
+
+static test_return_t udp_delete_test(memcached_st *memc)
+{
+ unsigned int num_iters= 1025; //request id rolls over at 1024
+
+ for (size_t x= 0; x < num_iters;x++)
+ {
+ memcached_return_t rc;
+ const char *key= "foo";
+ uint16_t *expected_ids=get_udp_request_ids(memc);
+ unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
+ memcached_server_instance_st instance=
+ memcached_server_instance_by_position(memc, server_key);
+ size_t init_offset= instance->write_buffer_offset;
+
+ rc= memcached_delete(memc, key, strlen(key), 0);
+ test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
+
+ if (rc == MEMCACHED_SUCCESS || instance->write_buffer_offset < init_offset)
+ increment_request_id(&expected_ids[server_key]);
+ if (rc == MEMCACHED_SUCCESS)
+ {
+ test_true(instance->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
+ }
+ else
+ {
+ test_true(instance->write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
+ test_true(instance->write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
+ }
+ test_true(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
+ }
+ return TEST_SUCCESS;
+}
+
+static test_return_t udp_buffered_delete_test(memcached_st *memc)
+{
+ memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
+ return udp_delete_test(memc);
+}
+
+static test_return_t udp_verbosity_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ uint16_t *expected_ids= get_udp_request_ids(memc);
+
+ for (size_t x= 0; x < memcached_server_count(memc); x++)
+ {
+ increment_request_id(&expected_ids[x]);
+ }
+
+ rc= memcached_verbosity(memc,3);
+ test_true(rc == MEMCACHED_SUCCESS);
+ return post_udp_op_check(memc,expected_ids);
+}
+
+static test_return_t udp_quit_test(memcached_st *memc)
+{
+ uint16_t *expected_ids= get_udp_request_ids(memc);
+ memcached_quit(memc);
+ return post_udp_op_check(memc, expected_ids);
+}
+
+static test_return_t udp_flush_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ uint16_t *expected_ids= get_udp_request_ids(memc);
+
+ for (size_t x= 0; x < memcached_server_count(memc); x++)
+ {
+ increment_request_id(&expected_ids[x]);
+ }
+
+ rc= memcached_flush(memc,0);
+ test_true(rc == MEMCACHED_SUCCESS);
+ return post_udp_op_check(memc,expected_ids);
+}
+
+static test_return_t udp_incr_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "incr";
+ const char *value= "1";
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+ uint16_t *expected_ids= get_udp_request_ids(memc);
+ unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
+ increment_request_id(&expected_ids[server_key]);
+ uint64_t newvalue;
+ rc= memcached_increment(memc, key, strlen(key), 1, &newvalue);
+ test_true(rc == MEMCACHED_SUCCESS);
+ return post_udp_op_check(memc, expected_ids);
+}
+
+static test_return_t udp_decr_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "decr";
+ const char *value= "1";
+ rc= memcached_set(memc, key, strlen(key),
+ value, strlen(value),
+ (time_t)0, (uint32_t)0);
+
+ test_true(rc == MEMCACHED_SUCCESS);
+ uint16_t *expected_ids= get_udp_request_ids(memc);
+ unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
+ increment_request_id(&expected_ids[server_key]);
+ uint64_t newvalue;
+ rc= memcached_decrement(memc, key, strlen(key), 1, &newvalue);
+ test_true(rc == MEMCACHED_SUCCESS);
+ return post_udp_op_check(memc, expected_ids);
+}
+
+
+static test_return_t udp_stat_test(memcached_st *memc)
+{
+ memcached_stat_st * rv= NULL;
+ memcached_return_t rc;
+ char args[]= "";
+ uint16_t *expected_ids = get_udp_request_ids(memc);
+ rv = memcached_stat(memc, args, &rc);
+ free(rv);
+ test_true(rc == MEMCACHED_NOT_SUPPORTED);
+ return post_udp_op_check(memc, expected_ids);
+}
+
+static test_return_t udp_version_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ uint16_t *expected_ids = get_udp_request_ids(memc);
+ rc = memcached_version(memc);
+ test_true(rc == MEMCACHED_NOT_SUPPORTED);
+ return post_udp_op_check(memc, expected_ids);
+}
+
+static test_return_t udp_get_test(memcached_st *memc)
+{
+ memcached_return_t rc;
+ const char *key= "foo";
+ size_t vlen;
+ uint16_t *expected_ids = get_udp_request_ids(memc);
+ char *val= memcached_get(memc, key, strlen(key), &vlen, (uint32_t)0, &rc);
+ test_true(rc == MEMCACHED_NOT_SUPPORTED);
+ test_true(val == NULL);
+ return post_udp_op_check(memc, expected_ids);
+}
+
+static test_return_t udp_mixed_io_test(memcached_st *memc)
+{
+ test_st current_op;
+ test_st mixed_io_ops [] ={
+ {"udp_set_test", 0,
+ (test_callback_fn*)udp_set_test},
+ {"udp_set_too_big_test", 0,
+ (test_callback_fn*)udp_set_too_big_test},
+ {"udp_delete_test", 0,
+ (test_callback_fn*)udp_delete_test},
+ {"udp_verbosity_test", 0,
+ (test_callback_fn*)udp_verbosity_test},
+ {"udp_quit_test", 0,
+ (test_callback_fn*)udp_quit_test},
+ {"udp_flush_test", 0,
+ (test_callback_fn*)udp_flush_test},
+ {"udp_incr_test", 0,
+ (test_callback_fn*)udp_incr_test},
+ {"udp_decr_test", 0,
+ (test_callback_fn*)udp_decr_test},
+ {"udp_version_test", 0,
+ (test_callback_fn*)udp_version_test}
+ };
+
+ for (size_t x= 0; x < 500; x++)
+ {
+ current_op= mixed_io_ops[random() % 9];
+ test_true(current_op.test_fn(memc) == TEST_SUCCESS);
+ }
+ return TEST_SUCCESS;
+}
+
+test_st udp_setup_server_tests[] ={
+ {"set_udp_behavior_test", 0, (test_callback_fn*)set_udp_behavior_test},
+ {"add_tcp_server_udp_client_test", 0, (test_callback_fn*)add_tcp_server_udp_client_test},
+ {"add_udp_server_tcp_client_test", 0, (test_callback_fn*)add_udp_server_tcp_client_test},
+ {0, 0, 0}
+};
+
+test_st upd_io_tests[] ={
+ {"udp_set_test", 0, (test_callback_fn*)udp_set_test},
+ {"udp_buffered_set_test", 0, (test_callback_fn*)udp_buffered_set_test},
+ {"udp_set_too_big_test", 0, (test_callback_fn*)udp_set_too_big_test},
+ {"udp_delete_test", 0, (test_callback_fn*)udp_delete_test},
+ {"udp_buffered_delete_test", 0, (test_callback_fn*)udp_buffered_delete_test},
+ {"udp_verbosity_test", 0, (test_callback_fn*)udp_verbosity_test},
+ {"udp_quit_test", 0, (test_callback_fn*)udp_quit_test},
+ {"udp_flush_test", 0, (test_callback_fn*)udp_flush_test},
+ {"udp_incr_test", 0, (test_callback_fn*)udp_incr_test},
+ {"udp_decr_test", 0, (test_callback_fn*)udp_decr_test},
+ {"udp_stat_test", 0, (test_callback_fn*)udp_stat_test},
+ {"udp_version_test", 0, (test_callback_fn*)udp_version_test},
+ {"udp_get_test", 0, (test_callback_fn*)udp_get_test},
+ {"udp_mixed_io_test", 0, (test_callback_fn*)udp_mixed_io_test},
+ {0, 0, 0}
+};
+
+collection_st collection[] ={
+ {"udp_setup", (test_callback_fn*)init_udp, 0, udp_setup_server_tests},
+ {"udp_io", (test_callback_fn*)init_udp, 0, upd_io_tests},
+ {"udp_binary_io", (test_callback_fn*)binary_init_udp, 0, upd_io_tests},
+ {0, 0, 0, 0}
+};
+
+#define SERVERS_TO_CREATE 5
+
+#include "libmemcached_world.h"
+
+void get_world(world_st *world)
+{
+ world->collections= collection;
+
+ world->create= (test_callback_create_fn*)world_create;
+ world->destroy= (test_callback_fn*)world_destroy;
+
+ world->run_startup= (test_callback_fn*)world_test_startup;
+ world->flush= (test_callback_fn*)world_flush;
+ world->pre_run= (test_callback_fn*)world_pre_run;
+ world->post_run= (test_callback_fn*)world_post_run;
+ world->on_error= (test_callback_error_fn*)world_on_error;
+
+ world->collection_startup= (test_callback_fn*)world_container_startup;
+ world->collection_shutdown= (test_callback_fn*)world_container_shutdown;
+
+ world->runner= &defualt_libmemcached_runner;
+}
return TEST_SKIPPED;
memcached_st *memc_ptr;
- memc_ptr= memcached(STRING_WITH_LEN("--CONFIGURE-FILE=\"support/example.cnf\""));
+ memc_ptr= memcached(test_literal_param("--CONFIGURE-FILE=\"support/example.cnf\""));
test_true_got(memc_ptr, "memcached() failed");
test_strcmp(SUPPORT_EXAMPLE_CNF, memcached_array_string(memc_ptr->configure.filename));
memcached_free(memc_ptr);
memcached_return_t rc;
char buffer[BUFSIZ];
- rc= libmemcached_check_configuration(STRING_WITH_LEN("--CONFIGURE-FILE=\"support/example.cnf\""), buffer, sizeof(buffer));
+ rc= libmemcached_check_configuration(test_literal_param("--CONFIGURE-FILE=\"support/example.cnf\""), buffer, sizeof(buffer));
test_true_got(rc == MEMCACHED_SUCCESS, (rc == MEMCACHED_ERRNO) ? strerror(errno) : memcached_strerror(NULL, rc));
- rc= libmemcached_check_configuration(STRING_WITH_LEN("--CONFIGURE-FILE=support/example.cnf"), buffer, sizeof(buffer));
+ rc= libmemcached_check_configuration(test_literal_param("--CONFIGURE-FILE=support/example.cnf"), buffer, sizeof(buffer));
test_false_with(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
- rc= libmemcached_check_configuration(STRING_WITH_LEN("--CONFIGURE-FILE=\"bad-path/example.cnf\""), buffer, sizeof(buffer));
+ rc= libmemcached_check_configuration(test_literal_param("--CONFIGURE-FILE=\"bad-path/example.cnf\""), buffer, sizeof(buffer));
test_true_got(rc == MEMCACHED_ERRNO, memcached_strerror(NULL, rc));
return TEST_SUCCESS;
memcached_return_t rc;
char buffer[BUFSIZ];
- rc= libmemcached_check_configuration(STRING_WITH_LEN("--server=localhost"), buffer, sizeof(buffer));
+ rc= libmemcached_check_configuration(test_literal_param("--server=localhost"), buffer, sizeof(buffer));
test_true_got(rc == MEMCACHED_SUCCESS, buffer);
- rc= libmemcached_check_configuration(STRING_WITH_LEN("--dude=localhost"), buffer, sizeof(buffer));
+ rc= libmemcached_check_configuration(test_literal_param("--dude=localhost"), buffer, sizeof(buffer));
test_false_with(rc == MEMCACHED_SUCCESS, buffer);
test_true(rc == MEMCACHED_PARSE_ERROR);
test_return_t memcached_create_with_options_test(memcached_st*)
{
memcached_st *memc_ptr;
- memc_ptr= memcached(STRING_WITH_LEN("--server=localhost"));
+ memc_ptr= memcached(test_literal_param("--server=localhost"));
test_true_got(memc_ptr, memcached_last_error_message(memc_ptr));
memcached_free(memc_ptr);
- memc_ptr= memcached(STRING_WITH_LEN("--dude=localhost"));
+ memc_ptr= memcached(test_literal_param("--dude=localhost"));
test_false_with(memc_ptr, memcached_last_error_message(memc_ptr));
return TEST_SUCCESS;
char buffer[BUFSIZ];
memcached_return_t rc;
- rc= libmemcached_check_configuration(STRING_WITH_LEN("INCLUDE \"support/example.cnf\""), buffer, sizeof(buffer));
+ rc= libmemcached_check_configuration(test_literal_param("INCLUDE \"support/example.cnf\""), buffer, sizeof(buffer));
test_true_got(rc == MEMCACHED_SUCCESS, buffer);
return TEST_SUCCESS;
{
char buffer[BUFSIZ];
memcached_return_t rc;
- rc= libmemcached_check_configuration(STRING_WITH_LEN("--server=localhost END bad keywords"), buffer, sizeof(buffer));
+ rc= libmemcached_check_configuration(test_literal_param("--server=localhost END bad keywords"), buffer, sizeof(buffer));
test_true_got(rc == MEMCACHED_SUCCESS, buffer);
return TEST_SUCCESS;
{
char buffer[BUFSIZ];
memcached_return_t rc;
- rc= libmemcached_check_configuration(STRING_WITH_LEN("--server=localhost reset --server=bad.com"), buffer, sizeof(buffer));
+ rc= libmemcached_check_configuration(test_literal_param("--server=localhost reset --server=bad.com"), buffer, sizeof(buffer));
test_true_got(rc == MEMCACHED_SUCCESS, buffer);
return TEST_SUCCESS;
{
char buffer[BUFSIZ];
memcached_return_t rc;
- rc= libmemcached_check_configuration(STRING_WITH_LEN("--server=localhost ERROR --server=bad.com"), buffer, sizeof(buffer));
+ rc= libmemcached_check_configuration(test_literal_param("--server=localhost ERROR --server=bad.com"), buffer, sizeof(buffer));
test_true_got(rc != MEMCACHED_SUCCESS, buffer);
return TEST_SUCCESS;
test_st tests[] ={
{ "basic", 0,
- reinterpret_cast<test_callback_fn>(basic_test) },
+ reinterpret_cast<test_callback_fn*>(basic_test) },
{ "basic_master_key", 0,
- reinterpret_cast<test_callback_fn>(basic_master_key_test) },
+ reinterpret_cast<test_callback_fn*>(basic_master_key_test) },
{ "increment_test", 0,
- reinterpret_cast<test_callback_fn>(increment_test) },
+ reinterpret_cast<test_callback_fn*>(increment_test) },
{ "mget", 1,
- reinterpret_cast<test_callback_fn>(mget_test) },
+ reinterpret_cast<test_callback_fn*>(mget_test) },
{ "basic_behavior", 0,
- reinterpret_cast<test_callback_fn>(basic_behavior) },
+ reinterpret_cast<test_callback_fn*>(basic_behavior) },
{0, 0, 0}
};
{
world->collections= collection;
- world->create= reinterpret_cast<test_callback_create_fn>(world_create);
- world->destroy= reinterpret_cast<test_callback_fn>(world_destroy);
+ world->create= reinterpret_cast<test_callback_create_fn*>(world_create);
+ world->destroy= reinterpret_cast<test_callback_fn*>(world_destroy);
- world->test.startup= reinterpret_cast<test_callback_fn>(world_test_startup);
- world->test.flush= reinterpret_cast<test_callback_fn>(world_flush);
- world->test.pre_run= reinterpret_cast<test_callback_fn>(world_pre_run);
- world->test.post_run= reinterpret_cast<test_callback_fn>(world_post_run);
- world->test.on_error= reinterpret_cast<test_callback_error_fn>(world_on_error);
+ world->run_startup= reinterpret_cast<test_callback_fn*>(world_test_startup);
+ world->flush= reinterpret_cast<test_callback_fn*>(world_flush);
+ world->pre_run= reinterpret_cast<test_callback_fn*>(world_pre_run);
+ world->post_run= reinterpret_cast<test_callback_fn*>(world_post_run);
+ world->on_error= reinterpret_cast<test_callback_error_fn*>(world_on_error);
- world->collection.startup= reinterpret_cast<test_callback_fn>(world_container_startup);
- world->collection.shutdown= reinterpret_cast<test_callback_fn>(world_container_shutdown);
+ world->collection_startup= reinterpret_cast<test_callback_fn*>(world_container_startup);
+ world->collection_shutdown= reinterpret_cast<test_callback_fn*>(world_container_shutdown);
world->runner= &defualt_libmemcached_runner;
}
+++ /dev/null
-/* LibMemcached
- * Copyright (C) 2006-2009 Brian Aker
- * All rights reserved.
- *
- * Use and distribution licensed under the BSD license. See
- * the COPYING file in the parent directory for full text.
- *
- * Summary:
- *
- */
-
-#include "config.h"
-
-#include <stdio.h>
-#include <string.h>
-#include <libtest/server.h>
-
-int main(void)
-{
- server_startup_st construct;
-
- memset(&construct, 0, sizeof(server_startup_st));
-
- construct.count= 4;
-
- server_startup(&construct);
-
- return EXIT_SUCCESS;
-}
--- /dev/null
+/* LibMemcached
+ * Copyright (C) 2006-2009 Brian Aker
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license. See
+ * the COPYING file in the parent directory for full text.
+ *
+ * Summary:
+ *
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <libtest/server.h>
+
+int main(void)
+{
+ server_startup_st construct;
+
+ memset(&construct, 0, sizeof(server_startup_st));
+
+ construct.count= 4;
+
+ server_startup(&construct);
+
+ return EXIT_SUCCESS;
+}
projects / m6w6 / libmemcached / commitdiff
