1 /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
5 * Copyright (C) 2011 Data Differential, http://datadifferential.com/
6 * Copyright (C) 2006-2009 Brian Aker All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * * Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following disclaimer
17 * in the documentation and/or other materials provided with the
20 * * The names of its contributors may not be used to endorse or
21 * promote products derived from this software without specific prior
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 #include "mem_config.h"
43 #include "libmemcached-1.0/memcached.hpp"
44 #include "libtest/test.hpp"
50 #include <sys/types.h>
59 using namespace memcache
;
60 using namespace libtest
;
62 static void populate_vector(vector
<char> &vec
, const string
&str
)
64 vec
.reserve(str
.length());
65 vec
.assign(str
.begin(), str
.end());
68 static void copy_vec_to_string(vector
<char> &vec
, string
&str
)
73 str
.assign(vec
.begin(), vec
.end());
77 static test_return_t
basic_test(memcached_st
*memc
)
80 const string
value_set("This is some data");
81 std::vector
<char> value
;
82 std::vector
<char> test_value
;
84 populate_vector(value
, value_set
);
86 test_true(foo
.set("mine", value
, 0, 0));
87 test_true(foo
.get("mine", test_value
));
89 test_compare(test_value
.size(), value
.size());
90 test_memcmp(&test_value
[0], &value
[0], test_value
.size());
91 test_false(foo
.set("", value
, 0, 0));
96 static test_return_t
increment_test(memcached_st
*original
)
98 Memcache
mcach(original
);
99 const string
key("blah");
100 const string
inc_value("1");
101 std::vector
<char> inc_val
;
102 vector
<char> ret_value
;
104 uint64_t int_inc_value
;
105 uint64_t int_ret_value
;
107 populate_vector(inc_val
, inc_value
);
109 test_true(mcach
.set(key
, inc_val
, 0, 0));
111 test_true(mcach
.get(key
, ret_value
));
112 test_false(ret_value
.empty());
113 copy_vec_to_string(ret_value
, ret_string
);
115 int_inc_value
= uint64_t(atol(inc_value
.c_str()));
116 int_ret_value
= uint64_t(atol(ret_string
.c_str()));
117 test_compare(int_inc_value
, int_ret_value
);
119 test_true(mcach
.increment(key
, 1, &int_ret_value
));
120 test_compare(uint64_t(2), int_ret_value
);
122 test_true(mcach
.increment(key
, 1, &int_ret_value
));
123 test_compare(uint64_t(3), int_ret_value
);
125 test_true(mcach
.increment(key
, 5, &int_ret_value
));
126 test_compare(uint64_t(8), int_ret_value
);
131 static test_return_t
basic_master_key_test(memcached_st
*original
)
133 Memcache
foo(original
);
134 const string
value_set("Data for server A");
136 vector
<char> test_value
;
137 const string
master_key_a("server-a");
138 const string
master_key_b("server-b");
139 const string
key("xyz");
141 populate_vector(value
, value_set
);
143 test_true(foo
.setByKey(master_key_a
, key
, value
, 0, 0));
144 test_true(foo
.getByKey(master_key_a
, key
, test_value
));
146 test_compare(value
.size(), test_value
.size());
147 test_memcmp(&value
[0], &test_value
[0], value
.size());
152 test_false(foo
.getByKey(master_key_b
, key
, test_value
));
153 test_zero(test_value
.size());
159 static test_return_t
mget_test(memcached_st
*original
)
161 Memcache
memc(original
);
162 memcached_return_t mc_rc
;
164 vector
< vector
<char> *> values
;
166 keys
.push_back("fudge");
167 keys
.push_back("son");
168 keys
.push_back("food");
172 populate_vector(val1
, "fudge");
173 populate_vector(val2
, "son");
174 populate_vector(val3
, "food");
176 values
.push_back(&val1
);
177 values
.push_back(&val2
);
178 values
.push_back(&val3
);
181 vector
<char> return_value
;
183 /* We need to empty the server before we continue the test */
184 bool flush_res
= memc
.flush();
185 if (flush_res
== false)
187 std::string error_string
;
188 ASSERT_TRUE(memc
.error(error_string
));
189 Error
<< error_string
;
191 test_true(memc
.flush());
193 test_true(memc
.mget(keys
));
195 test_compare(MEMCACHED_NOTFOUND
,
196 memc
.fetch(return_key
, return_value
));
198 test_true(memc
.setAll(keys
, values
, 50, 9));
200 test_true(memc
.mget(keys
));
202 while (memcached_success(mc_rc
= memc
.fetch(return_key
, return_value
)))
204 test_compare(return_key
.length(), return_value
.size());
205 test_memcmp(&return_value
[0], return_key
.c_str(), return_value
.size());
208 test_compare(values
.size(), count
);
213 static test_return_t
lp_1010899_TEST(void*)
215 // Check to see everything is setup internally even when no initial hosts are
219 test_false(memc
.increment(__func__
, 0, NULL
));
224 static test_return_t
lp_1010899_with_args_TEST(memcached_st
*original
)
226 // Check to see everything is setup internally even when a host is specified
228 const memcached_instance_st
* instance
= memcached_server_instance_by_position(original
, 0);
229 Memcache
memc(memcached_server_name(instance
), memcached_server_port(instance
));
231 test_false(memc
.increment(__func__
, 0, NULL
));
232 test_true(memc
.set(__func__
, test_literal_param("12"), 0, 0));
233 test_true(memc
.increment(__func__
, 3, NULL
));
235 std::vector
<char> ret_val
;
236 test_true(memc
.get(__func__
, ret_val
));
238 test_strcmp(&ret_val
[0], "15");
243 static test_return_t
basic_behavior(memcached_st
*original
)
245 Memcache
memc(original
);
246 test_true(memc
.setBehavior(MEMCACHED_BEHAVIOR_VERIFY_KEY
, true));
247 test_compare(true, memc
.getBehavior(MEMCACHED_BEHAVIOR_VERIFY_KEY
));
252 static test_return_t
error_test(memcached_st
*)
254 Memcache
memc("--server=localhost:178");
255 std::vector
<char> value
;
257 test_false(memc
.set("key", value
, time_t(0), uint32_t(0)));
259 test_true(memc
.error());
264 static test_return_t
error_std_string_test(memcached_st
*)
266 Memcache
memc("--server=localhost:178");
267 std::vector
<char> value
;
269 test_false(memc
.set("key", value
, time_t(0), uint32_t(0)));
271 std::string error_message
;
272 test_true(memc
.error(error_message
));
273 test_false(error_message
.empty());
278 static test_return_t
error_memcached_return_t_test(memcached_st
*)
280 Memcache
memc("--server=localhost:178");
281 std::vector
<char> value
;
283 test_false(memc
.set("key", value
, time_t(0), uint32_t(0)));
285 memcached_return_t rc
;
286 test_true(memc
.error(rc
));
287 test_compare(MEMCACHED_CONNECTION_FAILURE
, rc
);
292 test_st error_tests
[] ={
293 { "error()", false, reinterpret_cast<test_callback_fn
*>(error_test
) },
294 { "error(std::string&)", false, reinterpret_cast<test_callback_fn
*>(error_std_string_test
) },
295 { "error(memcached_return_t&)", false, reinterpret_cast<test_callback_fn
*>(error_memcached_return_t_test
) },
301 reinterpret_cast<test_callback_fn
*>(basic_test
) },
302 { "basic_master_key", false,
303 reinterpret_cast<test_callback_fn
*>(basic_master_key_test
) },
304 { "increment_test", false,
305 reinterpret_cast<test_callback_fn
*>(increment_test
) },
307 reinterpret_cast<test_callback_fn
*>(mget_test
) },
308 { "basic_behavior", false,
309 reinterpret_cast<test_callback_fn
*>(basic_behavior
) },
313 test_st regression_TESTS
[] ={
314 { "lp:1010899 Memcache()", false, lp_1010899_TEST
},
315 { "lp:1010899 Memcache(localhost, port)", false,
316 reinterpret_cast<test_callback_fn
*>(lp_1010899_with_args_TEST
) },
320 collection_st collection
[] ={
321 {"block", 0, 0, tests
},
322 {"error()", 0, 0, error_tests
},
323 {"regression", 0, 0, regression_TESTS
},
327 #define SERVERS_TO_CREATE 5
329 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
330 #include "tests/libmemcached_world.h"
332 void get_world(libtest::Framework
* world
)
334 world
->collections(collection
);
336 world
->create((test_callback_create_fn
*)world_create
);
337 world
->destroy((test_callback_destroy_fn
*)world_destroy
);
339 world
->set_runner(new LibmemcachedRunner
);