Loop *loop = Loop::New();

LogDbg("%d", 123);

ThreadPool *tp = new ThreadPool(loop);

ASSERT_TRUE(tp->initialize(2,5));

for (int i = 0; i < 12; ++i) {

ASSERT_NE(tp->execute(std::bind(backend_func, i)), null_task_token);

}

LogDbg("run in main");

loop->exitLoop(std::chrono::seconds(4));

loop->runLoop();

tp->cleanup();

delete tp;

delete loop;

Loop *loop = Loop::New();

ThreadPool *tp = new ThreadPool(loop);

ASSERT_TRUE(tp->initialize(0,5));

for (int i = 0; i < 12; ++i) {

ASSERT_NE(tp->execute(std::bind(backend_func, i)), null_task_token);

}

LogDbg("run in main");

loop->exitLoop(std::chrono::seconds(4));

loop->runLoop();

tp->cleanup();

delete tp;

delete loop;

Loop *loop = Loop::New();

LogDbg("%d", 123);

ThreadPool *tp = new ThreadPool(loop);

ASSERT_TRUE(tp->initialize(1,1));

for (int i = 0; i < 3; ++i) {

ASSERT_NE(tp->execute(std::bind(backend_func, i)), null_task_token);

}

LogDbg("run in main");

loop->exitLoop(std::chrono::seconds(1));

loop->runLoop();

tp->cleanup();

delete tp;

delete loop;

Loop *loop = Loop::New();

LogDbg("%d", 123);

ThreadPool *tp = new ThreadPool(loop);

ASSERT_TRUE(tp->initialize(1,1));

vector<ThreadPool::TaskToken> task_ids;

for (int i = 0; i < 3; ++i) {

auto token = tp->execute(std::bind(backend_func, i));

task_ids.push_back(token);

}

std::this_thread::sleep_for(std::chrono::milliseconds(1500));

EXPECT_EQ(tp->cancel(task_ids[0]), 1); //! 第一个任务已完成

EXPECT_EQ(tp->cancel(task_ids[1]), 2); //! 第二个任务正在执行

EXPECT_EQ(tp->cancel(task_ids[2]), 0); //! 第三个任务可正常取消

ThreadPool::TaskToken invalid_token(100, 1);

EXPECT_EQ(tp->cancel(invalid_token), 1); //! 任务不存在

loop->exitLoop(std::chrono::seconds(4));

loop->runLoop();

tp->cleanup();

delete tp;

delete loop;

Loop *loop = Loop::New();

LogDbg("%d", 123);

ThreadPool *tp = new ThreadPool(loop);

ASSERT_TRUE(tp->initialize(1,1));

vector<int> task_ids;

auto backend_func = \

[&task_ids](int id) {

std::this_thread::sleep_for(std::chrono::milliseconds(10));

LogDbg("task id: %d", id);

task_ids.push_back(id);

};

tp->execute([] { std::this_thread::sleep_for(std::chrono::seconds(1)); });

for (int i = 0; i < 5; ++i)

tp->execute(std::bind(backend_func, i), 2-i);

loop->exitLoop(std::chrono::seconds(2));

loop->runLoop();

ASSERT_EQ(task_ids.size(), 5);

EXPECT_EQ(task_ids[0], 4);

EXPECT_EQ(task_ids[1], 3);

EXPECT_EQ(task_ids[2], 2);

EXPECT_EQ(task_ids[3], 1);

EXPECT_EQ(task_ids[4], 0);

tp->cleanup();

delete tp;

delete loop;

Loop *loop = Loop::New();

ThreadPool *tp = new ThreadPool(loop);

ASSERT_TRUE(tp->initialize(1,1));

auto task1 = tp->execute([] { std::this_thread::sleep_for(std::chrono::milliseconds(100)); });

auto task2 = tp->execute([] { std::this_thread::sleep_for(std::chrono::milliseconds(100)); });

auto t1 = loop->newTimerEvent();

t1->initialize(chrono::milliseconds(50), Event::Mode::kOneshot);

t1->enable();

t1->setCallback(

[&] {

EXPECT_EQ(tp->getTaskStatus(task1), ThreadPool::TaskStatus::kExecuting);

EXPECT_EQ(tp->getTaskStatus(task2), ThreadPool::TaskStatus::kWaiting);

}

);

auto t2 = loop->newTimerEvent();

t2->initialize(chrono::milliseconds(150), Event::Mode::kOneshot);

t2->enable();

t2->setCallback(

[&] {

EXPECT_EQ(tp->getTaskStatus(task1), ThreadPool::TaskStatus::kNotFound);

EXPECT_EQ(tp->getTaskStatus(task2), ThreadPool::TaskStatus::kExecuting);

}

);

auto t3 = loop->newTimerEvent();

t3->initialize(chrono::milliseconds(250), Event::Mode::kOneshot);

t3->enable();

t3->setCallback(

[&] {

EXPECT_EQ(tp->getTaskStatus(task1), ThreadPool::TaskStatus::kNotFound);

EXPECT_EQ(tp->getTaskStatus(task2), ThreadPool::TaskStatus::kNotFound);

}

);

loop->exitLoop(std::chrono::milliseconds(300));

loop->runLoop();

tp->cleanup();

delete t3;

delete t2;

delete t1;

delete tp;

delete loop;