virtual void* run()
{
bool ret;
acl::redis_client* conn;
acl::redis_key redis;
for (int i = 0; i < n_; i++)
{
conn = (acl::redis_client*) pool_.peek();
if (conn == NULL)
{
printf("peek redis_client failed\r\n");
break;
}
redis.set_client(conn);
if (cmd_ == "del")
ret = test_del(redis, i);
else if (cmd_ == "expire")
ret = test_expire(redis, i);
else if (cmd_ == "ttl")
ret = test_ttl(redis, i);
else if (cmd_ == "exists")
ret = test_exists(redis, i);
else if (cmd_ == "type")
ret = test_type(redis, i);
else if (cmd_ == "all")
{
if (test_expire(redis, i) == false
|| test_ttl(redis, i) == false
|| test_exists(redis, i) == false
|| test_type(redis, i) == false
|| test_del(redis, i) == false)
{
ret = false;
}
else
ret = true;
}
else
{
printf("unknown cmd: %s\r\n", cmd_.c_str());
break;
}
pool_.put(conn, ret);
if (ret == false)
break;
}
return NULL;
}
int main(int argc, char *argv[])
{
int opt;
if((opt = getopt(argc, argv, "ar")) != -1)
{
switch(opt)
{
case 'a':
test_add();
break;
case 'r':
test_read();
break;
#if 0 case 'd':
test_del();
break;
case 't':
test_alter();
break;
#endif
case '?':
printf("unknown option: %c\n", optopt);
break;
}
}
return(0);
}
void test_all()
{
test_new();
test_del();
test_push();
test_pop();
test_peek();
}
void test_list(void) {
test_init();
add_setup();
test_add();
add_teardown();
del_setup();
test_del();
del_teardown();
}
int main(int argc, char **argv)
{
test_ins();
test_has();
test_del();
test_seq();
test_union();
test_intersection();
test_diff();
test_subset();
puts("Success");
}
int main()
{
int choice;
char *menu[] = {
"1---get by id.\n",
"2---del by id.\n",
"3---add user.\n",
"4---alter user.\n",
"0---quit.\n",
NULL
};
show_menu(menu);
printf("please choice: ");
scanf("%d", &choice);
while(1)
{
switch(choice)
{
case 1:
test_get();
break;
case 2:
test_del();
break;
case 3:
test_add();
break;
case 4:
test_alter();
break;
case 0:
exit(0);
default:
break;
}
printf("---------------------------------\n");
printf("please choice: ");
scanf("%d", &choice);
}
return 0;
}
virtual void* run()
{
bool ret;
acl::redis cmd;
cmd.set_cluster(&cluster_, max_conns_);
for (int i = 0; i < n_; i++)
{
if (cmd_ == "set")
ret = test_set(cmd, i);
else if (cmd_ == "get")
ret = test_get(cmd, i);
else if (cmd_ == "del")
ret = test_del(cmd, i);
else if (cmd_ == "expire")
ret = test_expire(cmd, i);
else if (cmd_ == "ttl")
ret = test_ttl(cmd, i);
else if (cmd_ == "exists")
ret = test_exists(cmd, i);
else if (cmd_ == "type")
ret = test_type(cmd, i);
else if (cmd_ == "all")
{
if (test_set(cmd, i) == false
|| test_get(cmd, i) == false
|| test_exists(cmd, i) == false
|| test_type(cmd, i) == false
|| test_expire(cmd, i) == false
|| test_ttl(cmd, i) == false
|| test_del(cmd, i) == false)
{
ret = false;
}
else
ret = true;
}
else
{
printf("unknown cmd: %s\r\n", cmd_.c_str());
break;
}
if (ret == false)
{
printf("cmd: %s error, tid: %lu\r\n",
cmd_.c_str(), thread_self());
break;
}
if (i > 0 && i % 1000 == 0)
{
char tmp[128];
acl::safe_snprintf(tmp, sizeof(tmp), "%d", i);
acl::meter_time(__FILE__, __LINE__, tmp);
}
}
locker_.lock();
__threads_exit++;
locker_.unlock();
return NULL;
}
virtual void* run()
{
bool ret;
acl::redis_client* conn;
acl::redis_zset redis;
acl::redis_key key_redis;
acl::string key;
for (int i = 0; i < n_; i++)
{
// 从全局线程池中获取一个 redis 连接对象
conn = (acl::redis_client*) pool_.peek();
if (conn == NULL)
{
printf("peek redis_client failed\r\n");
break;
}
// 每个线程一个 ID 号，做为键值组成部分
key.format("%s_%d_%d", __keypre.c_str(), id_, i);
redis.clear();
// 将 redis 连接对象与 redis 命令操作类对象进行绑定关联
redis.set_client(conn);
if (cmd_ == "zadd")
ret = test_zadd(redis, i, key.c_str(),
__big_data, __big_data_length,
__base_length);
else if (cmd_ == "zcard")
ret = test_zcard(redis, i, key);
else if (cmd_ == "zrange")
ret = test_zrange(redis, i, key, __hmac);
else if (cmd_ == "del")
{
key_redis.set_client(conn);
ret = test_del(key_redis, i, key);
}
else if (cmd_ != "all")
{
printf("unknown cmd: %s\r\n", cmd_.c_str());
ret = false;
}
else if (test_zadd(redis, i, key.c_str(),
__big_data, __big_data_length,
__base_length) == false
|| test_zcard(redis, i, key) == false
|| test_zrange(redis, i, key, __hmac) == false)
{
ret = false;
}
else
ret = true;
// 将 redis 连接对象归还给连接池，是否保持该连接，
// 通过判断该连接是否断开决定
pool_.put(conn, !conn->eof());
if (ret == false)
break;
}
return NULL;
}
virtual void* run()
{
bool ret;
acl::redis_client_pool* pool;
acl::redis_client* conn;
acl::redis_key option;
for (int i = 0; i < n_; i++)
{
pool = (acl::redis_client_pool*) manager_.peek();
if (pool == NULL)
{
printf("peek connection pool failed\r\n");
break;
}
conn = (acl::redis_client*) pool->peek();
if (conn == NULL)
{
printf("peek redis_client failed\r\n");
break;
}
option.set_client(conn);
if (cmd_ == "del")
ret = test_del(option, i);
else if (cmd_ == "expire")
ret = test_expire(option, i);
else if (cmd_ == "ttl")
ret = test_ttl(option, i);
else if (cmd_ == "exists")
ret = test_exists(option, i);
else if (cmd_ == "type")
ret = test_type(option, i);
else if (cmd_ == "all")
{
if (test_expire(option, i) == false
|| test_ttl(option, i) == false
|| test_exists(option, i) == false
|| test_type(option, i) == false
|| test_del(option, i) == false)
{
ret = false;
}
else
ret = true;
}
else
{
printf("unknown cmd: %s\r\n", cmd_.c_str());
break;
}
pool->put(conn, ret);
if (ret == false)
break;
}
return NULL;
}
int main(int argc , char ** argv) {
int_vector_type * int_vector = int_vector_alloc( 0 , 99);
test_abort();
test_assert_int_equal( -1 , int_vector_index(int_vector , 100));
test_assert_int_equal( -1 , int_vector_index_sorted(int_vector , 100));
test_assert_true( int_vector_is_instance( int_vector ));
test_assert_false( double_vector_is_instance( int_vector ));
int_vector_iset( int_vector , 2 , 0);
int_vector_insert( int_vector , 2 , 77 );
int_vector_iset( int_vector , 5 , -10);
assert_equal( int_vector_iget(int_vector , 0 ) == 99 );
assert_equal( int_vector_iget(int_vector , 1 ) == 99 );
assert_equal( int_vector_iget(int_vector , 2 ) == 77 );
assert_equal( int_vector_iget(int_vector , 3 ) == 00 );
assert_equal( int_vector_iget(int_vector , 4 ) == 99 );
assert_equal( int_vector_iget(int_vector , 5 ) == -10 );
{
int N1 = 100000;
int N2 = 10*N1;
int_vector_type * v1 = int_vector_alloc( N1 , 0 );
int_vector_type * v2;
int * data1 = int_vector_get_ptr( v1 );
int_vector_iset( v1 , N1 - 1, 99);
int_vector_free_container( v1 );
v2 = int_vector_alloc( N2 , 0 );
int_vector_iset(v2 , N2 - 1, 77 );
test_assert_int_equal( data1[N1-1] , 99);
int_vector_free( v2 );
free( data1 );
}
test_assert_true( int_vector_init_range( int_vector , 100 , 1000 , 115 ) );
test_assert_int_equal( int_vector_iget( int_vector , 0 ) , 100);
test_assert_int_equal( int_vector_iget( int_vector , 1 ) , 215);
test_assert_int_equal( int_vector_iget( int_vector , 2 ) , 330);
test_assert_int_equal( int_vector_iget( int_vector , 3 ) , 445);
test_assert_int_equal( int_vector_get_last( int_vector ) , 1000);
test_assert_false( int_vector_init_range( int_vector , 100 , -1000 , 115 ) );
test_assert_int_equal( int_vector_iget( int_vector , 0 ) , 100);
test_assert_int_equal( int_vector_iget( int_vector , 1 ) , 215);
test_assert_int_equal( int_vector_iget( int_vector , 2 ) , 330);
test_assert_int_equal( int_vector_iget( int_vector , 3 ) , 445);
test_assert_int_equal( int_vector_get_last( int_vector ) , 1000);
{
int_vector_type * v1 = int_vector_alloc(0,0);
int_vector_type * v2 = int_vector_alloc(0,0);
int_vector_append(v1 , 10);
int_vector_append(v1 , 15);
int_vector_append(v1 , 20);
int_vector_append(v2 , 1);
int_vector_append(v2 , 2);
int_vector_append(v2 , 3);
int_vector_append_vector( v1 , v2 );
test_assert_int_equal( int_vector_size( v1 ) , 6 );
test_assert_int_equal( int_vector_iget (v1 , 0 ), 10 );
test_assert_int_equal( int_vector_iget (v1 , 1 ), 15 );
test_assert_int_equal( int_vector_iget (v1 , 2 ), 20 );
test_assert_int_equal( int_vector_iget (v1 , 3 ), 1 );
test_assert_int_equal( int_vector_iget (v1 , 4 ), 2 );
test_assert_int_equal( int_vector_iget (v1 , 5 ), 3 );
int_vector_free( v1 );
int_vector_free( v2 );
}
test_contains();
test_contains_sorted();
test_shift();
test_alloc();
test_div();
test_memcpy_from_data();
test_idel_insert();
test_del();
test_range_fill();
test_iset_block();
test_resize();
test_empty();
test_insert_double();
exit(0);
}
int main(int argc, char* argv[])
{
int ch, n = 1, conn_timeout = 10, rw_timeout = 10;
acl::string addr("127.0.0.1:6379"), cmd;
while ((ch = getopt(argc, argv, "hs:n:C:T:a:")) > 0)
{
switch (ch)
{
case 'h':
usage(argv[0]);
return 0;
case 's':
addr = optarg;
break;
case 'n':
n = atoi(optarg);
break;
case 'C':
conn_timeout = atoi(optarg);
break;
case 'T':
rw_timeout = atoi(optarg);
break;
case 'a':
cmd = optarg;
break;
default:
break;
}
}
acl::acl_cpp_init();
acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
acl::redis_key redis(&client);
bool ret;
if (cmd == "del")
ret = test_del(redis, n);
else if (cmd == "expire")
ret = test_expire(redis, n);
else if (cmd == "ttl")
ret = test_ttl(redis, n);
else if (cmd == "exists")
ret = test_exists(redis, n);
else if (cmd == "type")
ret = test_type(redis, n);
else if (cmd == "all")
{
ret = test_expire(redis, n)
&& test_ttl(redis, n)
&& test_exists(redis, n)
&& test_type(redis, n)
&& test_del(redis, n);
}
else
{
ret = false;
printf("unknown cmd: %s\r\n", cmd.c_str());
}
if (ret == true)
printf("test OK!\r\n");
else
printf("test failed!\r\n");
#ifdef WIN32
printf("enter any key to exit\r\n");
getchar();
#endif
return 0;
}
