auto loop = event::Loop::New();

SetScopeExitAction([loop] { delete loop; });

class TestAction : public Action {

public:

explicit TestAction(event::Loop &loop) : Action(loop, "Test") { }

virtual bool isReady() const override { return true; }

virtual void onStart() override { finish(true, 100); }

};

TestAction action(*loop);

bool is_callback = false;

action.setFinishCallback(

[&, loop] (bool is_succ, const Action::Reason &r, const Action::Trace &t) {

EXPECT_TRUE(is_succ);

EXPECT_EQ(r.code, 100);

ASSERT_EQ(t.size(), 1);

EXPECT_EQ(t[0].type, "Test");

is_callback = true;

}

);

action.start();

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

loop->runLoop();

EXPECT_TRUE(is_callback);

auto loop = event::Loop::New();

SetScopeExitAction([loop] { delete loop; });

class TestAction : public Action {

public:

explicit TestAction(event::Loop &loop) : Action(loop, "Test") { }

virtual bool isReady() const override { return true; }

virtual void onStart() override {

Action::onStart();

block(Action::Reason(100, "block_on_start"));

}

};

bool is_block = false;

TestAction action(*loop);

action.setBlockCallback(

[&](const Action::Reason &r, const Action::Trace &t) {

EXPECT_EQ(r.code, 100);

EXPECT_EQ(r.message, "block_on_start");

ASSERT_EQ(t.size(), 1);

EXPECT_EQ(t[0].type, "Test");

is_block = true;

}

);

action.start();

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

loop->runLoop();

EXPECT_TRUE(is_block);

EXPECT_EQ(action.state(), Action::State::kPause);

action.stop();

EXPECT_EQ(action.state(), Action::State::kStoped);

auto loop = event::Loop::New();

SetScopeExitAction([loop] { delete loop; });

class TestAction : public Action {

public:

explicit TestAction(event::Loop &loop) : Action(loop, "Test") { }

virtual bool isReady() const override { return true; }

};

TestAction action(*loop);

action.setTimeout(std::chrono::milliseconds(50));

bool is_callback = false;

std::chrono::steady_clock::time_point ts_start;

std::chrono::steady_clock::time_point ts_timeout;

action.setFinishCallback(

[&, loop] (bool is_succ, const Action::Reason &r, const Action::Trace &t) {

EXPECT_FALSE(is_succ);

EXPECT_EQ(r.code, ACTION_REASON_ACTION_TIMEOUT);

EXPECT_EQ(r.message, "ActionTimeout");

ASSERT_EQ(t.size(), 1);

EXPECT_EQ(t[0].type, "Test");

is_callback = true;

ts_timeout = std::chrono::steady_clock::now();

loop->exitLoop();

}

);

action.start();

ts_start = std::chrono::steady_clock::now();

loop->runLoop();

EXPECT_TRUE(is_callback);

auto cout_50 = std::chrono::duration_cast<std::chrono::milliseconds>(ts_timeout - ts_start).count();

EXPECT_LE(cout_50, 51);

EXPECT_GE(cout_50, 49);