CASE_TEST(atbus_endpoint, is_child) { atbus::node::conf_t conf; atbus::node::default_conf(&conf); conf.children_mask = 16; { atbus::node::ptr_t node = atbus::node::create(); node->init(0x12345678, &conf); // 0值边界检测 CASE_EXPECT_TRUE(node->is_child_node(0x12340000)); CASE_EXPECT_TRUE(node->is_child_node(0x1234FFFF)); CASE_EXPECT_FALSE(node->is_child_node(0x1233FFFF)); CASE_EXPECT_FALSE(node->is_child_node(0x12350000)); // 自己是自己的子节点 CASE_EXPECT_TRUE(node->is_child_node(node->get_id())); } { conf.children_mask = 0; atbus::node::ptr_t node = atbus::node::create(); node->init(0x12345678, &conf); // 0值判定,无子节点 CASE_EXPECT_TRUE(node->is_child_node(0x12345678)); CASE_EXPECT_FALSE(node->is_child_node(0x12345679)); } }
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); }
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; }
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(atbus_endpoint, is_brother) { uint32_t fake_mask = 24; atbus::node::conf_t conf; atbus::node::default_conf(&conf); conf.children_mask = 16; atbus::node::ptr_t node = atbus::node::create(); node->init(0x12345678, &conf); // 自己不是自己的兄弟节点 CASE_EXPECT_FALSE(node->get_self_endpoint()->is_brother_node(node->get_id(), fake_mask)); /* F F // / \ / \ // [A] B [A] F // / \ // X B // 兄弟节点的子节点仍然是兄弟节点 */ CASE_EXPECT_TRUE(node->get_self_endpoint()->is_brother_node(0x12335678, fake_mask)); /* B // / \ // [A] X // 父节点是兄弟节点 */ CASE_EXPECT_TRUE(node->get_self_endpoint()->is_brother_node(0x12000001, fake_mask)); /* [A] // / \ // B X // 子节点不是兄弟节点 */ CASE_EXPECT_FALSE(node->get_self_endpoint()->is_brother_node(0x12340001, fake_mask)); /* F // / \ // F B // / \ // [A] X // 父节点的兄弟节点不是兄弟节点 */ CASE_EXPECT_FALSE(node->get_self_endpoint()->is_brother_node(0x11345678, fake_mask)); // 0值判定,无父节点 CASE_EXPECT_TRUE(node->get_self_endpoint()->is_brother_node(0x12000001, 0)); CASE_EXPECT_FALSE(node->get_self_endpoint()->is_brother_node(0x12340001, 0)); }
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); }
static void test_this_context_thread_func(copp::coroutine_context_default& co) { test_this_context_get_cotoutine_runner* runner = dynamic_cast<test_this_context_get_cotoutine_runner*>(co.get_runner()); runner->set_co_obj(&co); CASE_EXPECT_FALSE(runner->is_run()); co.start(); CASE_EXPECT_TRUE(runner->is_run()); }
CASE_TEST(coroutine_task, function_action) { { typedef std::shared_ptr< cotask::task<> > task_ptr_type; task_ptr_type co_task = cotask::task<>::create(test_context_task_function_1); 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_EQ(co_task->get_coroutine_context().get_ret_code(), 100); } { typedef std::shared_ptr< cotask::task<> > task_ptr_type; task_ptr_type co_task = cotask::task<>::create(test_context_task_function_2); 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_TEST(atbus_endpoint, is_father) { uint32_t fake_mask = 24; atbus::node::conf_t conf; atbus::node::default_conf(&conf); conf.children_mask = 16; atbus::node::ptr_t node = atbus::node::create(); node->init(0x12345678, &conf); CASE_EXPECT_TRUE(node->get_self_endpoint()->is_parent_node(0x12000001, 0x12000001, fake_mask)); CASE_EXPECT_FALSE(node->get_self_endpoint()->is_parent_node(0x12000002, 0x12000001, fake_mask)); }
CASE_TEST(this_context, yield) { typedef copp::coroutine_context_default co_type; co_type co; co.create(new test_this_context_yield_runner(), 32 * 1024); co.start(); test_this_context_yield_runner* runner = dynamic_cast<test_this_context_yield_runner*>(co.get_runner()); CASE_EXPECT_TRUE(runner->is_run()); CASE_EXPECT_FALSE(runner->is_finished()); assert(co.get_runner()); delete runner; }
static void recv_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 (status < 0) { CASE_EXPECT_EQ(NULL, input); CASE_EXPECT_EQ(0, s); CASE_EXPECT_TRUE(UV_EOF == channel->error_code || UV_ECONNRESET == channel->error_code); return; } CASE_EXPECT_NE(NULL, input); CASE_EXPECT_EQ(0, status); CASE_EXPECT_EQ(0, channel->error_code); CASE_EXPECT_FALSE(g_check_buff_sequence.empty()); if (g_check_buff_sequence.empty()) { return; } ++ g_recv_rec.first; g_recv_rec.second += s; CASE_EXPECT_EQ(s, g_check_buff_sequence.front().second); char* buff = get_test_buffer(); char* input_buff = reinterpret_cast<char*>(input); for (size_t i = 0; i < g_check_buff_sequence.front().second; ++ i) { CASE_EXPECT_EQ(buff[i + g_check_buff_sequence.front().first], input_buff[i]); if (buff[i + g_check_buff_sequence.front().first] != input_buff[i]) { break; } } g_check_buff_sequence.pop_front(); ++g_check_flag; }
CASE_TEST(coroutine_task, coroutine_context_yield) { typedef std::shared_ptr< cotask::task<> > task_ptr_type; task_ptr_type co_task = cotask::task<>::create(test_context_task_function_3); 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(cotask::EN_TS_WAITING, co_task->get_status()); 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(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); }
static void connect_failed_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_EQ(NULL, connection); CASE_EXPECT_TRUE(EN_ATBUS_ERR_SOCK_CONNECT_FAILED == status || EN_ATBUS_ERR_DNS_GETADDR_FAILED == status); if (EN_ATBUS_ERR_SOCK_CONNECT_FAILED == status) { CASE_EXPECT_EQ(UV_ECONNREFUSED, channel->error_code); } else { CASE_EXPECT_EQ(UV_EAI_NONAME, channel->error_code); } if (0 != channel->error_code) { CASE_MSG_INFO() << uv_err_name(channel->error_code) << ":" << uv_strerror(channel->error_code) << std::endl; } ++g_check_flag; }
// 注册到父节点失败导致下线的流程测试 // 注册到子节点失败不会导致下线的流程测试 CASE_TEST(atbus_node_reg, conflict) { 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; // 只有发生冲突才会注册不成功,否则会无限重试注册父节点,直到其上线 { atbus::node::ptr_t node_parent = atbus::node::create(); atbus::node::ptr_t node_child = atbus::node::create(); atbus::node::ptr_t node_child_fail = atbus::node::create(); node_parent->on_debug = node_reg_test_on_debug; node_child->on_debug = node_reg_test_on_debug; node_child_fail->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); // 子域冲突,注册失败 node_child_fail->init(0x12346780, &conf); node_child->set_on_shutdown_handle(node_test_on_shutdown); node_child_fail->set_on_shutdown_handle(node_test_on_shutdown); g_node_test_on_shutdown_check_reason = EN_ATBUS_ERR_ATNODE_INVALID_ID; 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_child_fail->listen("ipv4://127.0.0.1:16389")); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, node_parent->start()); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, node_child->start()); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, node_child_fail->start()); time_t proc_t = time(NULL) + 1; // 必然有一个失败的 while (atbus::node::state_t::CREATED != node_child->get_state() && atbus::node::state_t::CREATED != node_child_fail->get_state()) { node_parent->proc(proc_t, 0); node_child->proc(proc_t, 0); node_child_fail->proc(proc_t, 0); CASE_THREAD_SLEEP_MS(8); uv_run(&ev_loop, UV_RUN_NOWAIT); proc_t += conf.retry_interval; } for (int i = 0; i < 64; ++i) { CASE_THREAD_SLEEP_MS(8); uv_run(&ev_loop, UV_RUN_NOWAIT); } // 注册到子节点失败不会导致下线的流程测试 CASE_EXPECT_TRUE(atbus::node::state_t::RUNNING == node_child->get_state() || atbus::node::state_t::RUNNING == node_child_fail->get_state()); CASE_EXPECT_EQ(atbus::node::state_t::RUNNING, node_parent->get_state()); } node_reg_test_setup_exit(&ev_loop); }
// 对父节点重连失败不会导致下线的流程测试 // 对父节点断线重连的流程测试 CASE_TEST(atbus_node_reg, reconnect_father_failed) { 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; // 只有发生冲突才会注册不成功,否则会无限重试注册父节点,直到其上线 { 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); node_child->set_on_shutdown_handle(node_test_on_shutdown); g_node_test_on_shutdown_check_reason = EN_ATBUS_ERR_ATNODE_INVALID_ID; 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()); time_t proc_t = time(NULL) + 1; // 先等连接成功 while (atbus::node::state_t::RUNNING != node_child->get_state()) { node_parent->proc(proc_t, 0); node_child->proc(proc_t, 0); CASE_THREAD_SLEEP_MS(8); uv_run(&ev_loop, UV_RUN_NOWAIT); ++ proc_t; } // 关闭父节点 node_parent->reset(); // 重连父节点,但是连接不成功也不会导致下线 // 连接过程中的转态变化 size_t retry_times = 0; while (atbus::node::state_t::RUNNING == node_child->get_state() || retry_times < 16) { proc_t += conf.retry_interval + 1; // node_parent->proc(proc_t, 0); node_child->proc(proc_t, 0); if (atbus::node::state_t::RUNNING != node_child->get_state()) { ++ retry_times; CASE_EXPECT_TRUE(atbus::node::state_t::LOST_PARENT == node_child->get_state() || atbus::node::state_t::CONNECTING_PARENT == node_child->get_state()); CASE_EXPECT_NE(atbus::node::state_t::CREATED, node_child->get_state()); CASE_EXPECT_NE(atbus::node::state_t::INITED, node_child->get_state()); } CASE_THREAD_SLEEP_MS(8); uv_run(&ev_loop, UV_RUN_NOWAIT); uv_run(&ev_loop, UV_RUN_NOWAIT); uv_run(&ev_loop, UV_RUN_NOWAIT); } // 父节点断线重连测试 // 子节点断线后重新注册测试 conf.children_mask = 16; conf.father_address = ""; node_parent->init(0x12345678, &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_parent->start()); while (atbus::node::state_t::RUNNING != node_child->get_state()) { proc_t += conf.retry_interval; node_parent->proc(proc_t, 0); node_child->proc(proc_t, 0); CASE_THREAD_SLEEP_MS(8); uv_run(&ev_loop, UV_RUN_NOWAIT); } { atbus::endpoint* ep1 = node_child->get_endpoint(node_parent->get_id()); atbus::endpoint* ep2 = node_parent->get_endpoint(node_child->get_id()); CASE_EXPECT_NE(NULL, ep1); CASE_EXPECT_NE(NULL, ep2); CASE_EXPECT_EQ(atbus::node::state_t::RUNNING, node_child->get_state()); } // 注册到子节点失败不会导致下线的流程测试 CASE_EXPECT_EQ(atbus::node::state_t::RUNNING, node_parent->get_state()); } while (UV_EBUSY == uv_loop_close(&ev_loop)) { uv_run(&ev_loop, UV_RUN_ONCE); } }
CASE_TEST(buffer, static_buffer_manager_fb) { atbus::detail::buffer_manager mgr; CASE_EXPECT_TRUE(mgr.empty()); mgr.set_mode(1023, 10); CASE_EXPECT_FALSE(mgr.set_limit(2048, 10)); CASE_EXPECT_EQ(1023, mgr.limit().limit_size_); CASE_EXPECT_EQ(10, mgr.limit().limit_number_); // size limit void* pointer; void* check_ptr[4]; int res = mgr.push_front(pointer, 256 - atbus::detail::buffer_block::head_size(256)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); res = mgr.push_front(pointer, 256 - atbus::detail::buffer_block::head_size(256)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); res = mgr.push_front(pointer, 256 - atbus::detail::buffer_block::head_size(256)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); res = mgr.push_front(pointer, 256 + 2 * atbus::detail::buffer_block::head_size(256)); CASE_EXPECT_EQ(EN_ATBUS_ERR_BUFF_LIMIT, res); CASE_EXPECT_EQ(NULL, pointer); res = mgr.push_front(pointer, 257 - atbus::detail::buffer_block::head_size(257)); CASE_EXPECT_EQ(EN_ATBUS_ERR_BUFF_LIMIT, res); CASE_EXPECT_EQ(NULL, pointer); res = mgr.push_front(pointer, 255 - atbus::detail::buffer_block::head_size(255) - atbus::detail::buffer_block::padding_size(1)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); CASE_EXPECT_EQ(1023 - atbus::detail::buffer_block::padding_size(1), mgr.limit().cost_size_ + atbus::detail::buffer_block::head_size(255) + 3 * atbus::detail::buffer_block::head_size(256)); CASE_EXPECT_EQ(4, mgr.limit().cost_number_); mgr.reset(); mgr.set_mode(1023, 3); // from empty to full to empty // should has the same result for (int i = 0; i < 3; ++ i) { // number limit res = mgr.push_front(check_ptr[0], 99); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); memset(check_ptr[0], -1, 99); res = mgr.push_front(check_ptr[1], 28); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); memset(check_ptr[1], 0, 28); res = mgr.push_front(check_ptr[2], 17); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); memset(check_ptr[2], -1, 17); res = mgr.push_front(check_ptr[3], 63); CASE_EXPECT_EQ(EN_ATBUS_ERR_BUFF_LIMIT, res); CASE_EXPECT_EQ(144, mgr.limit().cost_size_); CASE_EXPECT_EQ(3, mgr.limit().cost_number_); // pop and remove block size_t s, sr; res = mgr.back(pointer, sr, s); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_EQ(pointer, check_ptr[0]); CASE_EXPECT_EQ(99, s); CASE_EXPECT_EQ(*reinterpret_cast<char*>(pointer), -1); res = mgr.pop_back(128); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_EQ(45, mgr.limit().cost_size_); CASE_EXPECT_EQ(2, mgr.limit().cost_number_); res = mgr.back(pointer, sr, s); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_EQ(pointer, check_ptr[1]); CASE_EXPECT_EQ(28, s); CASE_EXPECT_EQ(*reinterpret_cast<char*>(pointer), 0); res = mgr.pop_back(100); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_EQ(17, mgr.limit().cost_size_); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); res = mgr.back(pointer, sr, s); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_EQ(pointer, check_ptr[2]); CASE_EXPECT_EQ(17, s); CASE_EXPECT_EQ(*reinterpret_cast<char*>(pointer), -1); // pop but not remove block mgr.pop_back(10); CASE_EXPECT_EQ(7, mgr.limit().cost_size_); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); res = mgr.back(pointer, sr, s); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_EQ(pointer, atbus::detail::fn::buffer_next(check_ptr[2], 10)); CASE_EXPECT_EQ(7, s); CASE_EXPECT_EQ(*reinterpret_cast<char*>(pointer), -1); // pop all res = mgr.pop_back(10); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_TRUE(mgr.empty()); CASE_EXPECT_EQ(0, mgr.limit().cost_size_); CASE_EXPECT_EQ(0, mgr.limit().cost_number_); // pop nothing res = mgr.back(pointer, sr, s); CASE_EXPECT_EQ(EN_ATBUS_ERR_NO_DATA, res); CASE_EXPECT_EQ(NULL, pointer); CASE_EXPECT_EQ(0, s); res = mgr.pop_back(10); CASE_EXPECT_EQ(EN_ATBUS_ERR_NO_DATA, res); } }
CASE_TEST(buffer, static_buffer_manager_circle_fb) { atbus::detail::buffer_manager mgr; CASE_EXPECT_TRUE(mgr.empty()); mgr.set_mode(1023, 10); CASE_EXPECT_FALSE(mgr.set_limit(2048, 10)); CASE_EXPECT_EQ(1023, mgr.limit().limit_size_); CASE_EXPECT_EQ(10, mgr.limit().limit_number_); // size limit void* pointer; void* check_ptr[4]; size_t s, sr; int res = mgr.push_front(pointer, s = 256 - atbus::detail::buffer_block::head_size(256)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); memset(pointer, 0, s); res = mgr.push_front(pointer, s = 256 - atbus::detail::buffer_block::head_size(256)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); memset(pointer, -1, s); res = mgr.push_front(pointer, s= 256 - atbus::detail::buffer_block::head_size(256)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); memset(pointer, 0, s); res = mgr.push_front(pointer, 256 + 2 * atbus::detail::buffer_block::head_size(256)); CASE_EXPECT_EQ(EN_ATBUS_ERR_BUFF_LIMIT, res); CASE_EXPECT_EQ(NULL, pointer); res = mgr.push_front(pointer, 257 - atbus::detail::buffer_block::head_size(257)); CASE_EXPECT_EQ(EN_ATBUS_ERR_BUFF_LIMIT, res); CASE_EXPECT_EQ(NULL, pointer); res = mgr.push_front(pointer, s = 255 - atbus::detail::buffer_block::head_size(255) - atbus::detail::buffer_block::padding_size(1)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); memset(pointer, -1, s); CASE_EXPECT_EQ(1023 - atbus::detail::buffer_block::padding_size(1), mgr.limit().cost_size_ + atbus::detail::buffer_block::head_size(255) + 3 * atbus::detail::buffer_block::head_size(256)); CASE_EXPECT_EQ(4, mgr.limit().cost_number_); mgr.pop_back(256, false); CASE_EXPECT_EQ(4, mgr.limit().cost_number_); CHECK_BUFFER(mgr.back()->raw_data(), mgr.back()->raw_size(), 0x00); mgr.pop_back(0); mgr.back(check_ptr[0], s, sr); CASE_EXPECT_EQ(3, mgr.limit().cost_number_); CHECK_BUFFER(mgr.back()->raw_data(), mgr.back()->raw_size(), 0xFF); res = mgr.push_front(pointer, 256); CASE_EXPECT_EQ(EN_ATBUS_ERR_BUFF_LIMIT, res); mgr.pop_back(255 - atbus::detail::buffer_block::head_size(256)); CASE_EXPECT_EQ(3, mgr.limit().cost_number_); res = mgr.push_front(check_ptr[2], 128); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_EQ(4, mgr.limit().cost_number_); res = mgr.push_front(check_ptr[3], 128); CASE_EXPECT_EQ(EN_ATBUS_ERR_BUFF_LIMIT, res); mgr.pop_back(1); CASE_EXPECT_EQ(3, mgr.limit().cost_number_); CHECK_BUFFER(mgr.back()->raw_data(), mgr.back()->raw_size(), 0x00); res = mgr.push_front(check_ptr[3], 384 - atbus::detail::buffer_block::head_size(100) - atbus::detail::buffer_block::head_size(412) - atbus::detail::buffer_block::padding_size(1)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_EQ(4, mgr.limit().cost_number_); mgr.back(check_ptr[1], s, sr); CASE_EXPECT_TRUE(check_ptr[2] > check_ptr[0]); CASE_EXPECT_TRUE(check_ptr[3] >= check_ptr[0]); CASE_EXPECT_TRUE(check_ptr[3] < check_ptr[2]); CASE_EXPECT_TRUE(check_ptr[1] < check_ptr[0]); }
// merge front ============== merge back CASE_TEST(buffer, dynamic_buffer_manager_merge) { // merge back { atbus::detail::buffer_manager mgr; CASE_EXPECT_TRUE(mgr.empty()); mgr.set_limit(255, 10); CASE_EXPECT_EQ(255, mgr.limit().limit_size_); CASE_EXPECT_EQ(10, mgr.limit().limit_number_); // init void* pointer; void* check_ptr[3] = { &pointer, &pointer, &pointer }; size_t s, sr; int res = mgr.push_front(pointer, s = 128 - atbus::detail::buffer_block::head_size(128)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); memset(pointer, 0xef, s); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); res = mgr.merge_back(check_ptr[0], 256 - s); CASE_EXPECT_EQ(EN_ATBUS_ERR_BUFF_LIMIT, res); CASE_EXPECT_EQ(s, mgr.front()->raw_size()); CASE_EXPECT_EQ(NULL, check_ptr[0]); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); res = mgr.merge_back(check_ptr[1], 0); CASE_EXPECT_EQ(0, res); CASE_EXPECT_EQ(NULL, check_ptr[1]); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); CASE_EXPECT_EQ(pointer, mgr.front()->raw_data()); res = mgr.merge_back(check_ptr[2], sr = 255 - s); CASE_EXPECT_EQ(0, res); CASE_EXPECT_EQ(s + sr, mgr.front()->raw_size()); CASE_EXPECT_NE(pointer, mgr.front()->raw_data()); CASE_EXPECT_EQ(check_ptr[2], atbus::detail::fn::buffer_next(mgr.front()->raw_data(), s)); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); CHECK_BUFFER(mgr.front()->raw_data(), s, 0xef); } // merge front { atbus::detail::buffer_manager mgr; CASE_EXPECT_TRUE(mgr.empty()); mgr.set_limit(255, 10); CASE_EXPECT_EQ(255, mgr.limit().limit_size_); CASE_EXPECT_EQ(10, mgr.limit().limit_number_); // init void* pointer; void* check_ptr[3] = { &pointer, &pointer, &pointer }; size_t s, sr; int res = mgr.push_front(pointer, s = 128 - atbus::detail::buffer_block::head_size(128)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); memset(pointer, 0xef, s); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); res = mgr.merge_back(check_ptr[0], 256 - s); CASE_EXPECT_EQ(EN_ATBUS_ERR_BUFF_LIMIT, res); CASE_EXPECT_EQ(s, mgr.front()->raw_size()); CASE_EXPECT_EQ(NULL, check_ptr[0]); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); res = mgr.merge_back(check_ptr[1], 0); CASE_EXPECT_EQ(0, res); CASE_EXPECT_EQ(NULL, check_ptr[1]); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); CASE_EXPECT_EQ(pointer, mgr.front()->raw_data()); res = mgr.merge_back(check_ptr[2], sr = 255 - s); CASE_EXPECT_EQ(0, res); CASE_EXPECT_EQ(s + sr, mgr.front()->raw_size()); CASE_EXPECT_NE(pointer, mgr.front()->raw_data()); CASE_EXPECT_EQ(check_ptr[2], atbus::detail::fn::buffer_next(mgr.front()->raw_data(), s)); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); CHECK_BUFFER(mgr.front()->raw_data(), s, 0xef); } }
CASE_TEST(buffer, static_buffer_manager_merge_back) { // merge back : head NN tail ... => head NN NN tail ... { atbus::detail::buffer_manager mgr; CASE_EXPECT_TRUE(mgr.empty()); mgr.set_mode(255, 3); CASE_EXPECT_EQ(255, mgr.limit().limit_size_); CASE_EXPECT_EQ(3, mgr.limit().limit_number_); // init void* pointer; void* check_ptr[3] = { &pointer, &pointer, &pointer }; size_t s, sr; int res = mgr.push_back(pointer, s = 128 - atbus::detail::buffer_block::head_size(128)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); memset(pointer, 0xec, s); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); res = mgr.merge_back(check_ptr[0], 129); CASE_EXPECT_EQ(EN_ATBUS_ERR_BUFF_LIMIT, res); CASE_EXPECT_EQ(s, mgr.front()->raw_size()); CASE_EXPECT_EQ(NULL, check_ptr[0]); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); res = mgr.merge_back(check_ptr[1], 0); CASE_EXPECT_EQ(0, res); CASE_EXPECT_EQ(NULL, check_ptr[1]); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); CASE_EXPECT_EQ(pointer, mgr.front()->raw_data()); res = mgr.merge_back(check_ptr[2], sr = 128); CASE_EXPECT_EQ(0, res); CASE_EXPECT_EQ(s + sr, mgr.front()->raw_size()); CASE_EXPECT_EQ(pointer, mgr.front()->raw_data()); CASE_EXPECT_EQ(check_ptr[2], atbus::detail::fn::buffer_next(mgr.front()->raw_data(), s)); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); CHECK_BUFFER(mgr.front()->raw_data(), s, 0xec); } // merge back : ... head NN tail ... => NN tail ... head NN ... { atbus::detail::buffer_manager mgr; CASE_EXPECT_TRUE(mgr.empty()); mgr.set_mode(255, 3); CASE_EXPECT_EQ(255, mgr.limit().limit_size_); CASE_EXPECT_EQ(3, mgr.limit().limit_number_); // init void* pointer; void* check_ptr[2] = { &pointer, &pointer }; size_t s, sr; mgr.push_back(pointer, s = 136 - atbus::detail::buffer_block::head_size(136)); int res = mgr.push_back(pointer, sr = 64 - atbus::detail::buffer_block::head_size(64)); mgr.pop_front(s); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); memset(pointer, 0xeb, sr); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); res = mgr.merge_back(check_ptr[0], 69); CASE_EXPECT_EQ(EN_ATBUS_ERR_BUFF_LIMIT, res); CASE_EXPECT_EQ(sr, mgr.front()->raw_size()); CASE_EXPECT_EQ(NULL, check_ptr[0]); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); res = mgr.merge_back(check_ptr[1], 64); CASE_EXPECT_EQ(0, res); CASE_EXPECT_EQ(64 + sr, mgr.front()->raw_size()); CASE_EXPECT_NE(pointer, mgr.front()->raw_data()); CASE_EXPECT_EQ(check_ptr[1], atbus::detail::fn::buffer_next(mgr.front()->raw_data(), sr)); CASE_EXPECT_EQ(1, mgr.limit().cost_number_); CASE_EXPECT_GT(pointer, mgr.front()->raw_data()); CHECK_BUFFER(mgr.front()->raw_data(), sr, 0xeb); } // merge back : NN tail ... head NN => NN NN tail ... head NN { atbus::detail::buffer_manager mgr; CASE_EXPECT_TRUE(mgr.empty()); mgr.set_mode(255, 3); CASE_EXPECT_EQ(255, mgr.limit().limit_size_); CASE_EXPECT_EQ(3, mgr.limit().limit_number_); // init void* pointer; void* check_ptr[2] = { &pointer, &pointer }; size_t s, sr; mgr.push_back(pointer, s = 136 - atbus::detail::buffer_block::head_size(136)); mgr.push_back(pointer, 72 - atbus::detail::buffer_block::head_size(72)); mgr.pop_front(s); int res = mgr.push_back(pointer, sr = 64 - atbus::detail::buffer_block::head_size(64)); CASE_EXPECT_EQ(EN_ATBUS_ERR_SUCCESS, res); CASE_EXPECT_NE(NULL, pointer); memset(pointer, 0xec, sr); CASE_EXPECT_EQ(2, mgr.limit().cost_number_); res = mgr.merge_back(check_ptr[0], 69); CASE_EXPECT_EQ(EN_ATBUS_ERR_BUFF_LIMIT, res); CASE_EXPECT_EQ(sr, mgr.back()->raw_size()); CASE_EXPECT_EQ(NULL, check_ptr[0]); CASE_EXPECT_EQ(2, mgr.limit().cost_number_); res = mgr.merge_back(check_ptr[1], 64); CASE_EXPECT_EQ(0, res); CASE_EXPECT_EQ(64 + sr, mgr.back()->raw_size()); CASE_EXPECT_EQ(pointer, mgr.back()->raw_data()); CASE_EXPECT_EQ(check_ptr[1], atbus::detail::fn::buffer_next(mgr.back()->raw_data(), sr)); CASE_EXPECT_EQ(2, mgr.limit().cost_number_); CASE_EXPECT_GT(mgr.front()->raw_data(), check_ptr[1]); CHECK_BUFFER(mgr.back()->raw_data(), sr, 0xec); } }