static void recv_size_err_callback_check_fn(
atbus::channel::io_stream_channel* channel, // 事件触发的channel
atbus::channel::io_stream_connection* connection, // 事件触发的连接
int status, // libuv传入的转态码
void* input, // 额外参数(不同事件不同含义)
size_t s // 额外参数长度
) {
CASE_EXPECT_NE(NULL, channel);
CASE_EXPECT_NE(NULL, connection);
if (EN_ATBUS_ERR_INVALID_SIZE == status) {
CASE_EXPECT_NE(NULL, input);
CASE_EXPECT_EQ(EN_ATBUS_ERR_INVALID_SIZE, status);
CASE_EXPECT_EQ(0, channel->error_code);
} else if (EN_ATBUS_ERR_READ_FAILED == status) {
CASE_EXPECT_EQ(NULL, input);
CASE_EXPECT_EQ(EN_ATBUS_ERR_READ_FAILED, status);
CASE_EXPECT_TRUE(UV_ECONNRESET == channel->error_code || UV_EOF == channel->error_code);
} else {
CASE_EXPECT_TRUE(EN_ATBUS_ERR_INVALID_SIZE == status || EN_ATBUS_ERR_READ_FAILED == status);
}
++g_check_flag;
}
int operator()() {
CASE_EXPECT_EQ(g_test_coroutine_task_status, check_);
g_test_coroutine_task_status = set_;
CASE_EXPECT_EQ(copp::COPP_EC_IS_RUNNING, cotask::this_task::get_task()->start());
return 0;
}
CASE_TEST(coroutine, context_base)
{
char* stack_buff = new char[64 * 1024];
g_test_coroutine_base_status = 0;
++ g_test_coroutine_base_status;
CASE_EXPECT_EQ(g_test_coroutine_base_status, 1);
test_context_base_coroutine_context_test_type co;
test_context_base_foo_runner runner;
runner.call_times = 0;
co.get_allocator().attach(stack_buff, 64 * 1024);
co.create(&runner, 64 * 1024);
int res = co.create(&runner, 64 * 1024); // can not be created muli times
CASE_EXPECT_EQ(res, copp::COPP_EC_ALREADY_INITED);
co.start();
++ g_test_coroutine_base_status;
CASE_EXPECT_EQ(g_test_coroutine_base_status, 3);
co.resume();
++ g_test_coroutine_base_status;
CASE_EXPECT_EQ(g_test_coroutine_base_status, 5);
delete []stack_buff;
}
CASE_TEST(coroutine, shared_runner)
{
const int stack_len = 16 * 1024;
char* stack_buff = new char[4 * stack_len];
g_test_coroutine_base_status = 0;
++ g_test_coroutine_base_status;
CASE_EXPECT_EQ(g_test_coroutine_base_status, 1);
test_context_base_coroutine_context_test_type co[4];
test_context_base_foo_runner runner;
runner.call_times = 0;
for (int i = 0; i < 4; ++ i) {
co[i].get_allocator().attach(stack_buff + i * stack_len, stack_len);
co[i].create(&runner, stack_len);
co[i].start();
}
CASE_EXPECT_EQ(g_test_coroutine_base_status, 5);
for (int i = 0; i < 4; ++ i)
co[i].resume();
CASE_EXPECT_EQ(g_test_coroutine_base_status, 9);
CASE_EXPECT_EQ(runner.call_times, 4);
delete []stack_buff;
}
CASE_TEST(coroutine_task, auto_finish)
{
typedef std::shared_ptr< cotask::task<> > task_ptr_type;
{
test_context_task_mem_function obj;
task_ptr_type co_task = cotask::task<>::create(&test_context_task_mem_function::real_run, &obj);
g_test_coroutine_task_status = 0;
obj.task_id_ = co_task->get_id();
}
CASE_EXPECT_EQ(0, g_test_coroutine_task_status);
{
test_context_task_mem_function obj;
task_ptr_type co_task = cotask::task<>::create(&test_context_task_mem_function::real_run, &obj);
g_test_coroutine_task_status = 0;
obj.task_id_ = co_task->get_id();
CASE_EXPECT_EQ(0, co_task->start());
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 2);
CASE_EXPECT_FALSE(co_task->is_completed());
}
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 4);
}
CASE_TEST(coroutine_task, custom_action)
{
typedef std::shared_ptr< cotask::task<> > task_ptr_type;
cotask::task<>::action_ptr_t action = cotask::task<>::action_ptr_t(new test_context_task_action());
task_ptr_type co_task = cotask::task<>::create(action);
task_ptr_type co_another_task = cotask::task<>::create(action); // share action
g_test_coroutine_task_status = 0;
CASE_EXPECT_EQ(0, co_task->start());
CASE_EXPECT_EQ(g_test_coroutine_task_status, 1);
CASE_EXPECT_FALSE(co_task->is_completed());
CASE_EXPECT_EQ(0, co_another_task->start());
CASE_EXPECT_EQ(g_test_coroutine_task_status, 2);
CASE_EXPECT_EQ(0, co_task->resume());
CASE_EXPECT_EQ(g_test_coroutine_task_status, 3);
CASE_EXPECT_EQ(0, co_another_task->resume());
CASE_EXPECT_EQ(g_test_coroutine_task_status, 4);
CASE_EXPECT_TRUE(co_task->is_completed());
CASE_EXPECT_TRUE(co_another_task->is_completed());
CASE_EXPECT_GT(0, co_another_task->resume());
CASE_EXPECT_EQ(g_test_coroutine_task_status, 4);
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 5);
CASE_EXPECT_NE(co_task->get_id(), 0);
}
CASE_TEST(atbus_endpoint, get_children_min_max)
{
atbus::endpoint::bus_id_t tested = atbus::endpoint::get_children_max_id(0x12345678, 16);
CASE_EXPECT_EQ(tested, 0x1234FFFF);
tested = atbus::endpoint::get_children_min_id(0x12345678, 16);
CASE_EXPECT_EQ(tested, 0x12340000);
}
static void test_context_task_function_2() {
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 1);
cotask::this_task::get_task()->yield();
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 3);
}
CASE_TEST(crypto_cipher, aes_cfb_nopadding_encrypt) {
#if defined(CRYPTO_USE_OPENSSL) || defined(CRYPTO_USE_LIBRESSL) || defined(CRYPTO_USE_BORINGSSL)
if (!openssl_test_inited) {
openssl_test_inited = std::make_shared<openssl_test_init_wrapper>();
}
#endif
{
util::crypto::cipher ci;
CASE_EXPECT_EQ(0, ci.init("AES-256-CFB", ::util::crypto::cipher::mode_t::EN_CMODE_ENCRYPT));
// CASE_EXPECT_EQ(16, ci.get_iv_size());
// CASE_EXPECT_EQ(0, ci.set_iv(aes_test_cfb128_iv, 16));
CASE_EXPECT_EQ(256, ci.get_key_bits());
CASE_EXPECT_EQ(0, ci.set_key(aes_test_cfb128_key[2], 256));
const size_t buffer_len = 29;
for (int i = 0; i < 3; ++i) {
unsigned char buf_in[64] = {0}, buf_out[128] = {0};
size_t olen = sizeof(buf_out);
memcpy(buf_in, aes_test_cfb128_nopadding_pt[i], buffer_len);
CASE_EXPECT_EQ(0, ci.encrypt(buf_in, buffer_len, buf_out, &olen));
CASE_EXPECT_EQ(0, memcmp(buf_out, aes_test_cfb128_nopadding_ct[i], buffer_len));
CASE_MSG_INFO() << "AES-256-CFB => txt: " << aes_test_cfb128_nopadding_pt[i] << std::endl;
CASE_MSG_INFO() << "AES-256-CFB => enc: ";
util::string::dumphex(buf_out, olen, std::cout);
std::cout << std::endl;
}
}
{
util::crypto::cipher ci;
CASE_EXPECT_EQ(0, ci.init("AES-256-CFB", ::util::crypto::cipher::mode_t::EN_CMODE_DECRYPT));
// CASE_EXPECT_EQ(16, ci.get_iv_size());
// CASE_EXPECT_EQ(0, ci.set_iv(aes_test_cfb128_iv, 16));
CASE_EXPECT_EQ(256, ci.get_key_bits());
CASE_EXPECT_EQ(0, ci.set_key(aes_test_cfb128_key[2], 256));
const size_t buffer_len = 29;
for (int i = 0; i < 3; ++i) {
unsigned char buf_in[64] = {0}, buf_out[128] = {0};
size_t olen = sizeof(buf_out);
memcpy(buf_in, aes_test_cfb128_nopadding_ct[i], buffer_len);
CASE_EXPECT_EQ(0, ci.decrypt(buf_in, buffer_len, buf_out, &olen));
CASE_EXPECT_EQ(0, memcmp(buf_out, aes_test_cfb128_nopadding_pt[i], buffer_len));
CASE_MSG_INFO() << "AES-256-CFB => dec: ";
util::string::dumphex(buf_in, buffer_len, std::cout);
std::cout << std::endl;
CASE_MSG_INFO() << "AES-256-CFB => txt: " << ((unsigned char *)buf_out) << std::endl;
}
}
}
static int test_context_task_function_1() {
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 1);
cotask::this_task::get_task()->yield();
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 3);
return 100;
}
int operator()() const {
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 1);
cotask::this_task::get_task()->yield();
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 3);
return 0;
}
int operator()() {
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(cotask::EN_TS_RUNNING, cotask::this_task::get_task()->get_status());
cotask::this_task::get_task()->yield();
CASE_EXPECT_EQ(cotask::EN_TS_RUNNING, cotask::this_task::get_task()->get_status());
++ g_test_coroutine_task_status;
return 0;
}
int real_run() {
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 1);
CASE_EXPECT_EQ(task_id_, cotask::task<>::this_task()->get_id());
cotask::task<>::this_task()->yield();
CASE_EXPECT_EQ(task_id_, cotask::task<>::this_task()->get_id());
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 3);
return -1;
}
// task start and coroutine context yield
static void test_context_task_function_3() {
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 1);
CASE_EXPECT_EQ(cotask::EN_TS_RUNNING, cotask::this_task::get_task()->get_status());
copp::this_coroutine::yield();
CASE_EXPECT_EQ(cotask::EN_TS_RUNNING, cotask::this_task::get< cotask::task<> >()->get_status());
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 3);
}
CASE_TEST(atbus_endpoint, get_connection)
{
atbus::node::conf_t conf;
atbus::node::default_conf(&conf);
conf.children_mask = 16;
uv_loop_t ev_loop;
uv_loop_init(&ev_loop);
conf.ev_loop = &ev_loop;
conf.recv_buffer_size = 64 * 1024;
char* buffer = new char[conf.recv_buffer_size];
memset(buffer, -1, sizeof(conf.recv_buffer_size)); // init it and then valgrind will now report uninitialised used
char addr[32] = { 0 };
UTIL_STRFUNC_SNPRINTF(addr, sizeof(addr), "mem://0x%p", buffer);
if (addr[8] == '0' && addr[9] == 'x') {
memset(addr, 0, sizeof(addr));
UTIL_STRFUNC_SNPRINTF(addr, sizeof(addr), "mem://%p", buffer);
}
// 排除未完成连接
{
atbus::node::ptr_t node = atbus::node::create();
node->init(0x12345678, &conf);
atbus::connection::ptr_t conn1 = atbus::connection::create(node.get());
CASE_EXPECT_EQ(0, conn1->connect(addr));
atbus::connection::ptr_t conn2 = atbus::connection::create(node.get());
conn2->connect("ipv4://127.0.0.1:80");
atbus::endpoint::ptr_t ep = atbus::endpoint::create(node.get(), 0x12345679, 8, node->get_pid(), node->get_hostname());
CASE_EXPECT_TRUE(ep->add_connection(conn1.get(), false));
CASE_EXPECT_TRUE(ep->add_connection(conn2.get(), false));
CASE_EXPECT_EQ(0, node->add_endpoint(ep));
atbus::connection* conn3 = node->get_self_endpoint()->get_data_connection(ep.get());
CASE_EXPECT_EQ(conn3, conn1.get());
}
while (UV_EBUSY == uv_loop_close(&ev_loop)) {
uv_run(&ev_loop, UV_RUN_ONCE);
}
delete []buffer;
}
CASE_TEST(ac_automation, skip) {
util::string::ac_automation<> actree;
actree.insert_keyword("艹");
actree.insert_keyword("操你妈逼");
actree.insert_keyword("你妈逼");
actree.insert_keyword("艹你妈");
actree.set_skip(' ');
actree.set_skip('\t');
actree.set_skip('\r');
actree.set_skip('\n');
std::string input = "小册老艹，我干死你操 你妈操 你妈\r\n逼艹 你妈";
util::string::ac_automation<>::value_type res = actree.match(input);
// CI may not support this encoding
#ifndef _MSC_VER
CASE_EXPECT_EQ(3, res.size());
#endif
std::stringstream ss;
size_t in_idx = 0;
for (size_t i = 0; i < res.size(); ++i) {
ss.write(&input[in_idx], res[i].start - in_idx);
ss << "**";
in_idx = res[i].start + res[i].length;
}
if (in_idx < input.size()) {
ss.write(&input[in_idx], input.size() - in_idx);
}
CASE_MSG_INFO() << "filter resault: " << ss.str() << std::endl;
}
static void listen_callback_test_fn(
atbus::channel::io_stream_channel* channel, // 事件触发的channel
atbus::channel::io_stream_connection* connection, // 事件触发的连接
int status, // libuv传入的转态码
void*, // 额外参数(不同事件不同含义)
size_t s // 额外参数长度
) {
CASE_EXPECT_NE(NULL, channel);
CASE_EXPECT_NE(NULL, connection);
CASE_EXPECT_EQ(0, status);
CASE_EXPECT_EQ(0, channel->error_code);
// listen accepted event
connection->evt.callbacks[atbus::channel::io_stream_callback_evt_t::EN_FN_ACCEPTED] = accepted_callback_test_fn;
++g_check_flag;
}
CASE_TEST(coroutine_task, next)
{
typedef std::shared_ptr< cotask::task<> > task_ptr_type;
task_ptr_type co_task = cotask::task<>::create(test_context_task_next_action(15, 0));
co_task->next(test_context_task_next_action(7, 15))
->next(test_context_task_next_action(99, 7))
->next(test_context_task_next_action(1023, 99))
->next(test_context_task_next_action(5, 1023));
g_test_coroutine_task_status = 0;
CASE_EXPECT_EQ(0, co_task->start());
CASE_EXPECT_EQ(g_test_coroutine_task_status, 5);
CASE_EXPECT_EQ(copp::COPP_EC_ALREADY_FINISHED, co_task->start());
}
CASE_TEST(ac_automation, prefix) {
util::string::ac_automation<> actree;
actree.insert_keyword("cb");
actree.insert_keyword("abc");
actree.insert_keyword("bc");
actree.set_skip(' ');
actree.set_skip('\n');
util::string::ac_automation<>::value_type res = actree.match("ca b\ncd");
CASE_EXPECT_EQ(1, res.size());
if (!res.empty()) {
CASE_EXPECT_EQ(1, res[0].start);
CASE_EXPECT_EQ(5, res[0].length);
}
}
CASE_TEST(ac_automation, match_char) {
util::string::ac_automation<> actree;
actree.insert_keyword("a");
util::string::ac_automation<>::value_type res = actree.match(" aaa");
CASE_EXPECT_EQ(3, res.size());
res = actree.match("a");
CASE_EXPECT_EQ(1, res.size());
res = actree.match("b");
CASE_EXPECT_EQ(0, res.size());
res = actree.match("");
CASE_EXPECT_EQ(0, res.size());
}
static int node_test_on_shutdown(const atbus::node& n, int reason) {
if (0 == g_node_test_on_shutdown_check_reason) {
++ g_node_test_on_shutdown_check_reason;
} else {
CASE_EXPECT_EQ(reason, g_node_test_on_shutdown_check_reason);
g_node_test_on_shutdown_check_reason = 0;
}
return 0;
}
// reset by peer(client)
CASE_TEST(channel, io_stream_tcp_reset_by_client)
{
atbus::channel::io_stream_channel svr, cli;
atbus::channel::io_stream_init(&svr, NULL, NULL);
atbus::channel::io_stream_init(&cli, NULL, NULL);
svr.evt.callbacks[atbus::channel::io_stream_callback_evt_t::EN_FN_DISCONNECTED] = disconnected_callback_test_fn;
int check_flag = g_check_flag = 0;
int inited_fds = 0;
inited_fds += setup_channel(svr, "ipv6://:::16387", NULL);
CASE_EXPECT_EQ(1, g_check_flag);
CASE_EXPECT_NE(NULL, svr.ev_loop);
if (0 == inited_fds) {
return;
}
inited_fds = 0;
inited_fds += setup_channel(cli, NULL, "ipv4://127.0.0.1:16387");
inited_fds += setup_channel(cli, NULL, "dns://localhost:16387");
inited_fds += setup_channel(cli, NULL, "ipv6://::1:16387");
while (g_check_flag - check_flag < 2 * inited_fds + 1) {
atbus::channel::io_stream_run(&svr, atbus::adapter::RUN_NOWAIT);
atbus::channel::io_stream_run(&cli, atbus::adapter::RUN_NOWAIT);
CASE_THREAD_SLEEP_MS(8);
}
CASE_EXPECT_NE(0, cli.conn_pool.size());
check_flag = g_check_flag;
atbus::channel::io_stream_close(&cli);
CASE_EXPECT_EQ(0, cli.conn_pool.size());
while (g_check_flag - check_flag < inited_fds) {
atbus::channel::io_stream_run(&svr, atbus::adapter::RUN_NOWAIT);
CASE_THREAD_SLEEP_MS(8);
}
CASE_EXPECT_EQ(1, svr.conn_pool.size());
atbus::channel::io_stream_close(&svr);
CASE_EXPECT_EQ(0, svr.conn_pool.size());
}
CASE_TEST(coroutine_task, functor_drived_action)
{
typedef std::shared_ptr< cotask::task<> > task_ptr_type;
task_ptr_type co_task = cotask::task<>::create_with<test_context_task_functor_drived>(
cotask::task<>::stack_allocator_t::default_stacksize(),
1,
3
);
CASE_EXPECT_EQ(0, co_task->start());
}
static void connected_callback_test_fn(
atbus::channel::io_stream_channel* channel, // 事件触发的channel
atbus::channel::io_stream_connection* connection, // 事件触发的连接
int status, // libuv传入的转态码
void*, // 额外参数(不同事件不同含义)
size_t s // 额外参数长度
) {
CASE_EXPECT_NE(NULL, channel);
CASE_EXPECT_NE(NULL, connection);
CASE_EXPECT_EQ(0, status);
CASE_EXPECT_EQ(0, channel->error_code);
if (0 != status) {
CASE_MSG_INFO() << uv_err_name(channel->error_code) << ":"<< uv_strerror(channel->error_code) << std::endl;
} else {
CASE_MSG_INFO() << "connect to " << connection->addr.address<< " success" << std::endl;
}
++g_check_flag;
}
CASE_TEST(coroutine_task, functor_action)
{
typedef std::shared_ptr< cotask::task<> > task_ptr_type;
task_ptr_type co_task = cotask::task<>::create(test_context_task_functor());
g_test_coroutine_task_status = 0;
CASE_EXPECT_EQ(0, co_task->start());
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 2);
CASE_EXPECT_FALSE(co_task->is_completed());
CASE_EXPECT_EQ(0, co_task->resume());
CASE_EXPECT_TRUE(co_task->is_completed());
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 4);
CASE_EXPECT_NE(co_task->get_id(), 0);
}
CASE_TEST(owent_foreach, Array) {
//数组
const int arr[] = {1, 7, 3, 9, 5, 6, 2, 8, 4};
int sum1 = 0, sum2 = 0;
owent_foreach(const int &v, arr) { sum1 += v; }
for (int i = 0; i < 9; ++i) {
sum2 += arr[i];
}
CASE_EXPECT_EQ(sum1, sum2);
}
CASE_TEST(ac_automation, failed) {
util::string::ac_automation<> actree;
actree.insert_keyword("acd");
actree.insert_keyword("aceb");
actree.insert_keyword("bef");
actree.insert_keyword("cef");
actree.insert_keyword("ef");
util::string::ac_automation<>::value_type res = actree.match("lolololnmmnmuiyt");
CASE_EXPECT_EQ(0, res.size());
}
// 注册成功流程测试
CASE_TEST(atbus_node_reg, reg_success)
{
atbus::node::conf_t conf;
atbus::node::default_conf(&conf);
conf.children_mask = 16;
uv_loop_t ev_loop;
uv_loop_init(&ev_loop);
conf.ev_loop = &ev_loop;
int check_ep_rm = recv_msg_history.remove_endpoint_count;
{
atbus::node::ptr_t node_parent = atbus::node::create();
atbus::node::ptr_t node_child = atbus::node::create();
node_parent->on_debug = node_reg_test_on_debug;
node_child->on_debug = node_reg_test_on_debug;
node_parent->init(0x12345678, &conf);
conf.children_mask = 8;
conf.father_address = "ipv4://127.0.0.1:16387";
node_child->init(0x12346789, &conf);
CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, node_parent->listen("ipv4://127.0.0.1:16387"));
CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, node_child->listen("ipv4://127.0.0.1:16388"));
CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, node_parent->start());
CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, node_child->start());
// 父子节点注册回调测试
int check_ep_count = recv_msg_history.add_endpoint_count;
node_parent->set_on_add_endpoint_handle(node_reg_test_add_endpoint_fn);
node_parent->set_on_remove_endpoint_handle(node_reg_test_remove_endpoint_fn);
node_child->set_on_add_endpoint_handle(node_reg_test_add_endpoint_fn);
node_child->set_on_remove_endpoint_handle(node_reg_test_remove_endpoint_fn);
time_t proc_t = time(NULL);
node_parent->proc(proc_t + 1, 0);
node_child->proc(proc_t + 1, 0);
// 注册成功自动会有可用的端点
for (int i = 0; i < 512; ++i) {
atbus::endpoint* ep1 = node_child->get_endpoint(node_parent->get_id());
atbus::endpoint* ep2 = node_parent->get_endpoint(node_child->get_id());
if (NULL != ep1 && NULL != ep2 && NULL != ep1->get_data_connection(ep2) && NULL != ep2->get_data_connection(ep1)) {
break;
}
uv_run(conf.ev_loop, UV_RUN_ONCE);
}
CASE_EXPECT_EQ(check_ep_count + 2, recv_msg_history.add_endpoint_count);
}
node_reg_test_setup_exit(&ev_loop);
CASE_EXPECT_EQ(check_ep_rm + 2, recv_msg_history.remove_endpoint_count);
}
CASE_TEST(happ_connection, basic)
{
AutoPtr<hiredis::happ::connection> conn1(new hiredis::happ::connection());
AutoPtr<hiredis::happ::connection> conn2(new hiredis::happ::connection());
CASE_EXPECT_EQ(conn1->get_sequence() + 1, conn2->get_sequence());
hiredis::happ::holder_t h;
redisAsyncContext vir_context;
conn1->init(h, "127.0.0.2", 1234);
conn2->init(h, "127.0.0.3", 1234);
CASE_EXPECT_TRUE("127.0.0.2" == conn1->get_key().ip);
CASE_EXPECT_TRUE(1234 == conn1->get_key().port);
CASE_EXPECT_TRUE("127.0.0.2:1234" == conn1->get_key().name);
CASE_EXPECT_EQ(hiredis::happ::connection::status::DISCONNECTED, conn1->conn_status);
hiredis::happ::cmd_exec* cmd = hiredis::happ::cmd_exec::create(h, NULL, &vir_context, 0);
int res = conn1->redis_cmd(cmd, NULL);
CASE_EXPECT_EQ(hiredis::happ::error_code::REDIS_HAPP_CREATE, res);
conn1->set_connecting(&vir_context);
CASE_EXPECT_EQ(conn1->get_context(), &vir_context);
CASE_EXPECT_EQ(hiredis::happ::connection::status::CONNECTING, conn1->conn_status);
conn1->set_connected();
CASE_EXPECT_EQ(hiredis::happ::connection::status::CONNECTED, conn1->conn_status);
CASE_EXPECT_EQ(conn1->get_context(), &vir_context);
cmd->pri_data = conn2.get();
conn2->set_connecting(&vir_context);
conn1->release(false);
conn2->release(false);
CASE_EXPECT_EQ(conn1->get_context(), NULL);
CASE_EXPECT_EQ(conn2->get_context(), NULL);
hiredis::happ::cmd_exec::destroy(cmd);
}
CASE_TEST(coroutine_task, mem_function_action)
{
typedef std::shared_ptr< cotask::task<> > task_ptr_type;
test_context_task_mem_function obj;
task_ptr_type co_task = cotask::task<>::create(&test_context_task_mem_function::real_run, &obj);
g_test_coroutine_task_status = 0;
obj.task_id_ = co_task->get_id();
CASE_EXPECT_EQ(0, co_task->start());
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 2);
CASE_EXPECT_FALSE(co_task->is_completed());
CASE_EXPECT_EQ(0, co_task->resume());
CASE_EXPECT_TRUE(co_task->is_completed());
++ g_test_coroutine_task_status;
CASE_EXPECT_EQ(g_test_coroutine_task_status, 4);
CASE_EXPECT_NE(co_task->get_coroutine_context().get_ret_code(), -1);
}
