From: Jason Dillaman Date: Thu, 3 Mar 2016 21:43:15 +0000 (-0500) Subject: test: librbd template specializations leaking between translation units X-Git-Tag: v10.1.0~216^2^2~2 X-Git-Url: http://git.apps.os.sepia.ceph.com/?a=commitdiff_plain;h=0357d875921e2efabbe4788e3c2c2680773b0b37;p=ceph.git test: librbd template specializations leaking between translation units A CMake build with optimizations disabled can result in a template specialization for one test being reused by another test in a different translation unit. Signed-off-by: Jason Dillaman --- diff --git a/src/test/librbd/image/test_mock_RefreshRequest.cc b/src/test/librbd/image/test_mock_RefreshRequest.cc index dd8090b07aa5c..f5ee743d1c572 100644 --- a/src/test/librbd/image/test_mock_RefreshRequest.cc +++ b/src/test/librbd/image/test_mock_RefreshRequest.cc @@ -20,19 +20,29 @@ #include namespace librbd { + +namespace { + +struct MockRefreshImageCtx : public MockImageCtx { + MockRefreshImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace + namespace image { template <> -struct RefreshParentRequest { +struct RefreshParentRequest { static RefreshParentRequest* s_instance; - static RefreshParentRequest* create(MockImageCtx &mock_image_ctx, + static RefreshParentRequest* create(MockRefreshImageCtx &mock_image_ctx, const parent_info& parent_md, Context *on_finish) { assert(s_instance != nullptr); s_instance->on_finish = on_finish; return s_instance; } - static bool is_refresh_required(MockImageCtx &mock_image_ctx, + static bool is_refresh_required(MockRefreshImageCtx &mock_image_ctx, const parent_info& parent_md) { assert(s_instance != nullptr); return s_instance->is_refresh_required(); @@ -50,14 +60,14 @@ struct RefreshParentRequest { MOCK_METHOD1(finalize, void(Context *)); }; -RefreshParentRequest* RefreshParentRequest::s_instance = nullptr; +RefreshParentRequest* RefreshParentRequest::s_instance = nullptr; } // namespace image } // namespace librbd // template definitions #include "librbd/image/RefreshRequest.cc" -template class librbd::image::RefreshRequest; +template class librbd::image::RefreshRequest; ACTION_P(TestFeatures, image_ctx) { return ((image_ctx->features & arg0) != 0); @@ -81,18 +91,18 @@ using ::testing::WithArg; class TestMockImageRefreshRequest : public TestMockFixture { public: - typedef RefreshRequest MockRefreshRequest; - typedef RefreshParentRequest MockRefreshParentRequest; + typedef RefreshRequest MockRefreshRequest; + typedef RefreshParentRequest MockRefreshParentRequest; - void expect_set_require_lock_on_read(MockImageCtx &mock_image_ctx) { + void expect_set_require_lock_on_read(MockRefreshImageCtx &mock_image_ctx) { EXPECT_CALL(*mock_image_ctx.aio_work_queue, set_require_lock_on_read()); } - void expect_clear_require_lock_on_read(MockImageCtx &mock_image_ctx) { + void expect_clear_require_lock_on_read(MockRefreshImageCtx &mock_image_ctx) { EXPECT_CALL(*mock_image_ctx.aio_work_queue, clear_require_lock_on_read()); } - void expect_v1_read_header(MockImageCtx &mock_image_ctx, int r) { + void expect_v1_read_header(MockRefreshImageCtx &mock_image_ctx, int r) { auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx), read(mock_image_ctx.header_oid, _, _, _)); if (r < 0) { @@ -102,7 +112,7 @@ public: } } - void expect_v1_get_snapshots(MockImageCtx &mock_image_ctx, int r) { + void expect_v1_get_snapshots(MockRefreshImageCtx &mock_image_ctx, int r) { auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx), exec(mock_image_ctx.header_oid, _, "rbd", "snap_list", _, _, _)); if (r < 0) { @@ -112,7 +122,7 @@ public: } } - void expect_v1_get_locks(MockImageCtx &mock_image_ctx, int r) { + void expect_v1_get_locks(MockRefreshImageCtx &mock_image_ctx, int r) { auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx), exec(mock_image_ctx.header_oid, _, "lock", "get_info", _, _, _)); if (r < 0) { @@ -122,7 +132,7 @@ public: } } - void expect_get_mutable_metadata(MockImageCtx &mock_image_ctx, int r) { + void expect_get_mutable_metadata(MockRefreshImageCtx &mock_image_ctx, int r) { auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx), exec(mock_image_ctx.header_oid, _, "rbd", "get_size", _, _, _)); if (r < 0) { @@ -144,7 +154,7 @@ public: } } - void expect_get_flags(MockImageCtx &mock_image_ctx, int r) { + void expect_get_flags(MockRefreshImageCtx &mock_image_ctx, int r) { auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx), exec(mock_image_ctx.header_oid, _, "rbd", "get_flags", _, _, _)); if (r < 0) { @@ -154,7 +164,7 @@ public: } } - void expect_get_snapshots(MockImageCtx &mock_image_ctx, int r) { + void expect_get_snapshots(MockRefreshImageCtx &mock_image_ctx, int r) { auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx), exec(mock_image_ctx.header_oid, _, "rbd", "get_snapshot_name", _, _, _)); if (r < 0) { @@ -173,12 +183,12 @@ public: } } - void expect_add_snap(MockImageCtx &mock_image_ctx, + void expect_add_snap(MockRefreshImageCtx &mock_image_ctx, const std::string &snap_name, uint64_t snap_id) { EXPECT_CALL(mock_image_ctx, add_snap(snap_name, snap_id, _, _, _, _)); } - void expect_init_exclusive_lock(MockImageCtx &mock_image_ctx, + void expect_init_exclusive_lock(MockRefreshImageCtx &mock_image_ctx, MockExclusiveLock &mock_exclusive_lock, int r) { EXPECT_CALL(mock_image_ctx, create_exclusive_lock()) @@ -187,7 +197,7 @@ public: .WillOnce(WithArg<1>(CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue))); } - void expect_shut_down_exclusive_lock(MockImageCtx &mock_image_ctx, + void expect_shut_down_exclusive_lock(MockRefreshImageCtx &mock_image_ctx, MockExclusiveLock &mock_exclusive_lock, int r) { EXPECT_CALL(mock_exclusive_lock, shut_down(_)) @@ -195,11 +205,11 @@ public: CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue))); } - void expect_init_layout(MockImageCtx &mock_image_ctx) { + void expect_init_layout(MockRefreshImageCtx &mock_image_ctx) { EXPECT_CALL(mock_image_ctx, init_layout()); } - void expect_test_features(MockImageCtx &mock_image_ctx) { + void expect_test_features(MockRefreshImageCtx &mock_image_ctx) { EXPECT_CALL(mock_image_ctx, test_features(_, _)) .WillRepeatedly(TestFeatures(&mock_image_ctx)); } @@ -210,7 +220,7 @@ public: .WillRepeatedly(Return(required)); } - void expect_refresh_parent_send(MockImageCtx &mock_image_ctx, + void expect_refresh_parent_send(MockRefreshImageCtx &mock_image_ctx, MockRefreshParentRequest &mock_refresh_parent_request, int r) { EXPECT_CALL(mock_refresh_parent_request, send()) @@ -222,7 +232,7 @@ public: EXPECT_CALL(mock_refresh_parent_request, apply()); } - void expect_refresh_parent_finalize(MockImageCtx &mock_image_ctx, + void expect_refresh_parent_finalize(MockRefreshImageCtx &mock_image_ctx, MockRefreshParentRequest &mock_refresh_parent_request, int r) { EXPECT_CALL(mock_refresh_parent_request, finalize(_)) @@ -234,7 +244,7 @@ public: EXPECT_CALL(mock_exclusive_lock, is_lock_owner()).WillOnce(Return(is_owner)); } - void expect_open_journal(MockImageCtx &mock_image_ctx, + void expect_open_journal(MockRefreshImageCtx &mock_image_ctx, MockJournal &mock_journal, int r) { EXPECT_CALL(mock_image_ctx, create_journal()) .WillOnce(Return(&mock_journal)); @@ -242,13 +252,13 @@ public: .WillOnce(CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue)); } - void expect_close_journal(MockImageCtx &mock_image_ctx, + void expect_close_journal(MockRefreshImageCtx &mock_image_ctx, MockJournal &mock_journal, int r) { EXPECT_CALL(mock_journal, close(_)) .WillOnce(CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue)); } - void expect_open_object_map(MockImageCtx &mock_image_ctx, + void expect_open_object_map(MockRefreshImageCtx &mock_image_ctx, MockObjectMap &mock_object_map, int r) { EXPECT_CALL(mock_image_ctx, create_object_map(_)) .WillOnce(Return(&mock_object_map)); @@ -256,13 +266,13 @@ public: .WillOnce(CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue)); } - void expect_close_object_map(MockImageCtx &mock_image_ctx, + void expect_close_object_map(MockRefreshImageCtx &mock_image_ctx, MockObjectMap &mock_object_map, int r) { EXPECT_CALL(mock_object_map, close(_)) .WillOnce(CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue)); } - void expect_get_snap_id(MockImageCtx &mock_image_ctx, + void expect_get_snap_id(MockRefreshImageCtx &mock_image_ctx, const std::string &snap_name, uint64_t snap_id) { EXPECT_CALL(mock_image_ctx, get_snap_id(snap_name)).WillOnce(Return(snap_id)); } @@ -274,7 +284,7 @@ TEST_F(TestMockImageRefreshRequest, SuccessV1) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockRefreshImageCtx mock_image_ctx(*ictx); expect_op_work_queue(mock_image_ctx); expect_test_features(mock_image_ctx); @@ -299,7 +309,7 @@ TEST_F(TestMockImageRefreshRequest, SuccessSnapshotV1) { ASSERT_EQ(0, snap_create(*ictx, "snap")); ASSERT_EQ(0, ictx->state->refresh()); - MockImageCtx mock_image_ctx(*ictx); + MockRefreshImageCtx mock_image_ctx(*ictx); expect_op_work_queue(mock_image_ctx); expect_test_features(mock_image_ctx); @@ -323,7 +333,7 @@ TEST_F(TestMockImageRefreshRequest, SuccessV2) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockRefreshImageCtx mock_image_ctx(*ictx); MockRefreshParentRequest mock_refresh_parent_request; MockExclusiveLock mock_exclusive_lock; expect_op_work_queue(mock_image_ctx); @@ -351,7 +361,7 @@ TEST_F(TestMockImageRefreshRequest, SuccessSnapshotV2) { ASSERT_EQ(0, open_image(m_image_name, &ictx)); ASSERT_EQ(0, snap_create(*ictx, "snap")); - MockImageCtx mock_image_ctx(*ictx); + MockRefreshImageCtx mock_image_ctx(*ictx); MockRefreshParentRequest mock_refresh_parent_request; MockExclusiveLock mock_exclusive_lock; expect_op_work_queue(mock_image_ctx); @@ -383,7 +393,7 @@ TEST_F(TestMockImageRefreshRequest, SuccessSetSnapshotV2) { ASSERT_EQ(0, snap_create(*ictx, "snap")); ASSERT_EQ(0, librbd::snap_set(ictx, "snap")); - MockImageCtx mock_image_ctx(*ictx); + MockRefreshImageCtx mock_image_ctx(*ictx); MockRefreshParentRequest mock_refresh_parent_request; MockObjectMap mock_object_map; expect_op_work_queue(mock_image_ctx); @@ -434,7 +444,7 @@ TEST_F(TestMockImageRefreshRequest, SuccessChild) { ASSERT_EQ(0, open_image(clone_name, &ictx2)); - MockImageCtx mock_image_ctx(*ictx2); + MockRefreshImageCtx mock_image_ctx(*ictx2); MockRefreshParentRequest *mock_refresh_parent_request = new MockRefreshParentRequest(); MockExclusiveLock mock_exclusive_lock; expect_op_work_queue(mock_image_ctx); @@ -464,7 +474,7 @@ TEST_F(TestMockImageRefreshRequest, DisableExclusiveLock) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockRefreshImageCtx mock_image_ctx(*ictx); MockRefreshParentRequest mock_refresh_parent_request; MockExclusiveLock *mock_exclusive_lock = new MockExclusiveLock(); @@ -514,7 +524,7 @@ TEST_F(TestMockImageRefreshRequest, EnableJournalWithExclusiveLock) { RBD_FEATURE_OBJECT_MAP | RBD_FEATURE_FAST_DIFF, false)); - MockImageCtx mock_image_ctx(*ictx); + MockRefreshImageCtx mock_image_ctx(*ictx); MockRefreshParentRequest mock_refresh_parent_request; MockExclusiveLock mock_exclusive_lock; @@ -550,7 +560,7 @@ TEST_F(TestMockImageRefreshRequest, EnableJournalWithoutExclusiveLock) { RBD_FEATURE_OBJECT_MAP | RBD_FEATURE_FAST_DIFF, false)); - MockImageCtx mock_image_ctx(*ictx); + MockRefreshImageCtx mock_image_ctx(*ictx); MockRefreshParentRequest mock_refresh_parent_request; MockExclusiveLock mock_exclusive_lock; @@ -580,7 +590,7 @@ TEST_F(TestMockImageRefreshRequest, DisableJournal) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockRefreshImageCtx mock_image_ctx(*ictx); MockRefreshParentRequest mock_refresh_parent_request; MockExclusiveLock mock_exclusive_lock; @@ -622,7 +632,7 @@ TEST_F(TestMockImageRefreshRequest, EnableObjectMapWithExclusiveLock) { ASSERT_EQ(0, update_features(ictx, RBD_FEATURE_JOURNALING, false)); - MockImageCtx mock_image_ctx(*ictx); + MockRefreshImageCtx mock_image_ctx(*ictx); MockRefreshParentRequest mock_refresh_parent_request; MockExclusiveLock mock_exclusive_lock; @@ -656,7 +666,7 @@ TEST_F(TestMockImageRefreshRequest, EnableObjectMapWithoutExclusiveLock) { ASSERT_EQ(0, update_features(ictx, RBD_FEATURE_JOURNALING, false)); - MockImageCtx mock_image_ctx(*ictx); + MockRefreshImageCtx mock_image_ctx(*ictx); MockRefreshParentRequest mock_refresh_parent_request; MockExclusiveLock mock_exclusive_lock; @@ -685,7 +695,7 @@ TEST_F(TestMockImageRefreshRequest, DisableObjectMap) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockRefreshImageCtx mock_image_ctx(*ictx); MockRefreshParentRequest mock_refresh_parent_request; MockExclusiveLock mock_exclusive_lock; diff --git a/src/test/librbd/journal/test_mock_Replay.cc b/src/test/librbd/journal/test_mock_Replay.cc index ea3d0467b8905..539599538cf72 100644 --- a/src/test/librbd/journal/test_mock_Replay.cc +++ b/src/test/librbd/journal/test_mock_Replay.cc @@ -13,27 +13,36 @@ namespace librbd { +namespace { + +struct MockReplayImageCtx : public MockImageCtx { + MockReplayImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace + template <> -struct AioImageRequest { +struct AioImageRequest { static AioImageRequest *s_instance; MOCK_METHOD5(aio_write, void(AioCompletion *c, uint64_t off, size_t len, const char *buf, int op_flags)); - static void aio_write(MockImageCtx *ictx, AioCompletion *c, uint64_t off, + static void aio_write(MockReplayImageCtx *ictx, AioCompletion *c, uint64_t off, size_t len, const char *buf, int op_flags) { assert(s_instance != nullptr); s_instance->aio_write(c, off, len, buf, op_flags); } MOCK_METHOD3(aio_discard, void(AioCompletion *c, uint64_t off, uint64_t len)); - static void aio_discard(MockImageCtx *ictx, AioCompletion *c, uint64_t off, + static void aio_discard(MockReplayImageCtx *ictx, AioCompletion *c, uint64_t off, uint64_t len) { assert(s_instance != nullptr); s_instance->aio_discard(c, off, len); } MOCK_METHOD1(aio_flush, void(AioCompletion *c)); - static void aio_flush(MockImageCtx *ictx, AioCompletion *c) { + static void aio_flush(MockReplayImageCtx *ictx, AioCompletion *c) { assert(s_instance != nullptr); s_instance->aio_flush(c); } @@ -43,13 +52,13 @@ struct AioImageRequest { } }; -AioImageRequest *AioImageRequest::s_instance = nullptr; +AioImageRequest *AioImageRequest::s_instance = nullptr; } // template definitions #include "librbd/journal/Replay.cc" -template class librbd::journal::Replay; +template class librbd::journal::Replay; using ::testing::_; using ::testing::DoAll; @@ -81,8 +90,8 @@ namespace journal { class TestMockJournalReplay : public TestMockFixture { public: - typedef AioImageRequest MockAioImageRequest; - typedef Replay MockJournalReplay; + typedef AioImageRequest MockAioImageRequest; + typedef Replay MockJournalReplay; TestMockJournalReplay() : m_invoke_lock("m_invoke_lock") { } @@ -100,7 +109,7 @@ public: .WillOnce(SaveArg<0>(aio_comp)); } - void expect_aio_flush(MockImageCtx &mock_image_ctx, + void expect_aio_flush(MockReplayImageCtx &mock_image_ctx, MockAioImageRequest &mock_aio_image_request, int r) { EXPECT_CALL(mock_aio_image_request, aio_flush(_)) .WillOnce(CompleteAioCompletion(r, mock_image_ctx.image_ctx)); @@ -114,27 +123,27 @@ public: .WillOnce(SaveArg<0>(aio_comp)); } - void expect_flatten(MockImageCtx &mock_image_ctx, Context **on_finish) { + void expect_flatten(MockReplayImageCtx &mock_image_ctx, Context **on_finish) { EXPECT_CALL(*mock_image_ctx.operations, flatten(_, _)) .WillOnce(DoAll(SaveArg<1>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } - void expect_rename(MockImageCtx &mock_image_ctx, Context **on_finish, + void expect_rename(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *image_name) { EXPECT_CALL(*mock_image_ctx.operations, rename(CStrEq(image_name), _)) .WillOnce(DoAll(SaveArg<1>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } - void expect_resize(MockImageCtx &mock_image_ctx, Context **on_finish, + void expect_resize(MockReplayImageCtx &mock_image_ctx, Context **on_finish, uint64_t size, uint64_t op_tid) { EXPECT_CALL(*mock_image_ctx.operations, resize(size, _, _, op_tid)) .WillOnce(DoAll(SaveArg<2>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } - void expect_snap_create(MockImageCtx &mock_image_ctx, + void expect_snap_create(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name, uint64_t op_tid) { EXPECT_CALL(*mock_image_ctx.operations, snap_create(CStrEq(snap_name), _, @@ -143,14 +152,14 @@ public: NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } - void expect_snap_remove(MockImageCtx &mock_image_ctx, + void expect_snap_remove(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name) { EXPECT_CALL(*mock_image_ctx.operations, snap_remove(CStrEq(snap_name), _)) .WillOnce(DoAll(SaveArg<1>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } - void expect_snap_rename(MockImageCtx &mock_image_ctx, + void expect_snap_rename(MockReplayImageCtx &mock_image_ctx, Context **on_finish, uint64_t snap_id, const char *snap_name) { EXPECT_CALL(*mock_image_ctx.operations, snap_rename(snap_id, CStrEq(snap_name), _)) @@ -158,21 +167,21 @@ public: NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } - void expect_snap_protect(MockImageCtx &mock_image_ctx, + void expect_snap_protect(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name) { EXPECT_CALL(*mock_image_ctx.operations, snap_protect(CStrEq(snap_name), _)) .WillOnce(DoAll(SaveArg<1>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } - void expect_snap_unprotect(MockImageCtx &mock_image_ctx, + void expect_snap_unprotect(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name) { EXPECT_CALL(*mock_image_ctx.operations, snap_unprotect(CStrEq(snap_name), _)) .WillOnce(DoAll(SaveArg<1>(on_finish), NotifyInvoke(&m_invoke_lock, &m_invoke_cond))); } - void expect_snap_rollback(MockImageCtx &mock_image_ctx, + void expect_snap_rollback(MockReplayImageCtx &mock_image_ctx, Context **on_finish, const char *snap_name) { EXPECT_CALL(*mock_image_ctx.operations, snap_rollback(CStrEq(snap_name), _, _)) .WillOnce(DoAll(SaveArg<2>(on_finish), @@ -195,7 +204,7 @@ public: mock_journal_replay.process(it, on_ready, on_safe); } - void when_complete(MockImageCtx &mock_image_ctx, AioCompletion *aio_comp, + void when_complete(MockReplayImageCtx &mock_image_ctx, AioCompletion *aio_comp, int r) { aio_comp->get(); aio_comp->set_request_count(mock_image_ctx.cct, 1); @@ -245,7 +254,7 @@ TEST_F(TestMockJournalReplay, AioDiscard) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); MockAioImageRequest mock_aio_image_request; expect_op_work_queue(mock_image_ctx); @@ -273,7 +282,7 @@ TEST_F(TestMockJournalReplay, AioWrite) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); MockAioImageRequest mock_aio_image_request; expect_op_work_queue(mock_image_ctx); @@ -301,7 +310,7 @@ TEST_F(TestMockJournalReplay, AioFlush) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); MockAioImageRequest mock_aio_image_request; expect_op_work_queue(mock_image_ctx); @@ -327,7 +336,7 @@ TEST_F(TestMockJournalReplay, IOError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); MockAioImageRequest mock_aio_image_request; expect_op_work_queue(mock_image_ctx); @@ -355,7 +364,7 @@ TEST_F(TestMockJournalReplay, SoftFlushIO) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); MockAioImageRequest mock_aio_image_request; expect_op_work_queue(mock_image_ctx); @@ -394,7 +403,7 @@ TEST_F(TestMockJournalReplay, PauseIO) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); MockAioImageRequest mock_aio_image_request; expect_op_work_queue(mock_image_ctx); @@ -435,7 +444,7 @@ TEST_F(TestMockJournalReplay, Flush) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); MockAioImageRequest mock_aio_image_request; expect_op_work_queue(mock_image_ctx); @@ -463,7 +472,7 @@ TEST_F(TestMockJournalReplay, OpFinishError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -490,7 +499,7 @@ TEST_F(TestMockJournalReplay, BlockedOpFinishError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -524,7 +533,7 @@ TEST_F(TestMockJournalReplay, MissingOpFinishEvent) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -567,7 +576,7 @@ TEST_F(TestMockJournalReplay, MissingOpFinishEventCancelOps) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -599,7 +608,7 @@ TEST_F(TestMockJournalReplay, UnknownOpFinishEvent) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -619,7 +628,7 @@ TEST_F(TestMockJournalReplay, OpEventError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -650,7 +659,7 @@ TEST_F(TestMockJournalReplay, SnapCreateEvent) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -686,7 +695,7 @@ TEST_F(TestMockJournalReplay, SnapCreateEventExists) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -718,7 +727,7 @@ TEST_F(TestMockJournalReplay, SnapRemoveEvent) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -749,7 +758,7 @@ TEST_F(TestMockJournalReplay, SnapRemoveEventDNE) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -780,7 +789,7 @@ TEST_F(TestMockJournalReplay, SnapRenameEvent) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -812,7 +821,7 @@ TEST_F(TestMockJournalReplay, SnapRenameEventExists) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -844,7 +853,7 @@ TEST_F(TestMockJournalReplay, SnapProtectEvent) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -875,7 +884,7 @@ TEST_F(TestMockJournalReplay, SnapProtectEventBusy) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -906,7 +915,7 @@ TEST_F(TestMockJournalReplay, SnapUnprotectEvent) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -937,7 +946,7 @@ TEST_F(TestMockJournalReplay, SnapUnprotectEventInvalid) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -968,7 +977,7 @@ TEST_F(TestMockJournalReplay, SnapRollbackEvent) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -999,7 +1008,7 @@ TEST_F(TestMockJournalReplay, RenameEvent) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -1030,7 +1039,7 @@ TEST_F(TestMockJournalReplay, RenameEventExists) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -1061,7 +1070,7 @@ TEST_F(TestMockJournalReplay, ResizeEvent) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -1097,7 +1106,7 @@ TEST_F(TestMockJournalReplay, FlattenEvent) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -1128,7 +1137,7 @@ TEST_F(TestMockJournalReplay, FlattenEventInvalid) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -1159,7 +1168,7 @@ TEST_F(TestMockJournalReplay, UnknownEvent) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockReplayImageCtx mock_image_ctx(*ictx); MockJournalReplay mock_journal_replay(mock_image_ctx); expect_op_work_queue(mock_image_ctx); diff --git a/src/test/librbd/object_map/mock/MockInvalidateRequest.h b/src/test/librbd/object_map/mock/MockInvalidateRequest.h index b7d02c6ea55d9..b4fc78b290026 100644 --- a/src/test/librbd/object_map/mock/MockInvalidateRequest.h +++ b/src/test/librbd/object_map/mock/MockInvalidateRequest.h @@ -9,17 +9,17 @@ namespace librbd { namespace object_map { -template <> -struct InvalidateRequest { - static std::list s_requests; +template +struct MockInvalidateRequestBase { + static std::list*> s_requests; uint64_t snap_id; bool force; Context *on_finish; - static InvalidateRequest* create(MockImageCtx &image_ctx, uint64_t snap_id, - bool force, Context *on_finish) { + static InvalidateRequest* create(I &image_ctx, uint64_t snap_id, + bool force, Context *on_finish) { assert(!s_requests.empty()); - InvalidateRequest* req = s_requests.front(); + InvalidateRequest* req = s_requests.front(); req->snap_id = snap_id; req->force = force; req->on_finish = on_finish; @@ -27,16 +27,15 @@ struct InvalidateRequest { return req; } - InvalidateRequest() { - s_requests.push_back(this); + MockInvalidateRequestBase() { + s_requests.push_back(static_cast*>(this)); } MOCK_METHOD0(send, void()); }; -typedef InvalidateRequest MockInvalidateRequest; - -std::list*> InvalidateRequest::s_requests; +template +std::list*> MockInvalidateRequestBase::s_requests; } // namespace object_map } // namespace librbd diff --git a/src/test/librbd/object_map/test_mock_RefreshRequest.cc b/src/test/librbd/object_map/test_mock_RefreshRequest.cc index 2abfd8e273c1b..9daa18c0bfc78 100644 --- a/src/test/librbd/object_map/test_mock_RefreshRequest.cc +++ b/src/test/librbd/object_map/test_mock_RefreshRequest.cc @@ -12,13 +12,23 @@ #include "librbd/object_map/LockRequest.h" namespace librbd { + +namespace { + +struct MockObjectMapImageCtx : public MockImageCtx { + MockObjectMapImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace + namespace object_map { template <> -class LockRequest { +class LockRequest { public: static LockRequest *s_instance; - static LockRequest *create(MockImageCtx &image_ctx, Context *on_finish) { + static LockRequest *create(MockObjectMapImageCtx &image_ctx, Context *on_finish) { assert(s_instance != nullptr); s_instance->on_finish = on_finish; return s_instance; @@ -33,7 +43,12 @@ public: MOCK_METHOD0(send, void()); }; -LockRequest *LockRequest::s_instance = nullptr; +template<> +struct InvalidateRequest : + public MockInvalidateRequestBase { +}; + +LockRequest *LockRequest::s_instance = nullptr; } // namespace object_map } // namespace librbd @@ -56,17 +71,18 @@ class TestMockObjectMapRefreshRequest : public TestMockFixture { public: static const uint64_t TEST_SNAP_ID = 123; - typedef RefreshRequest MockRefreshRequest; - typedef LockRequest MockLockRequest; + typedef RefreshRequest MockRefreshRequest; + typedef LockRequest MockLockRequest; + typedef InvalidateRequest MockInvalidateRequest; - void expect_object_map_lock(MockImageCtx &mock_image_ctx, + void expect_object_map_lock(MockObjectMapImageCtx &mock_image_ctx, MockLockRequest &mock_lock_request) { EXPECT_CALL(mock_lock_request, send()) .WillOnce(FinishRequest(&mock_lock_request, 0, &mock_image_ctx)); } - void expect_object_map_load(MockImageCtx &mock_image_ctx, + void expect_object_map_load(MockObjectMapImageCtx &mock_image_ctx, ceph::BitVector<2> *object_map, uint64_t snap_id, int r) { std::string oid(ObjectMap::object_map_name(mock_image_ctx.id, snap_id)); @@ -86,26 +102,26 @@ public: } } - void expect_get_image_size(MockImageCtx &mock_image_ctx, uint64_t snap_id, + void expect_get_image_size(MockObjectMapImageCtx &mock_image_ctx, uint64_t snap_id, uint64_t size) { EXPECT_CALL(mock_image_ctx, get_image_size(snap_id)) .WillOnce(Return(size)); } - void expect_invalidate_request(MockImageCtx &mock_image_ctx, + void expect_invalidate_request(MockObjectMapImageCtx &mock_image_ctx, MockInvalidateRequest &invalidate_request) { EXPECT_CALL(invalidate_request, send()) .WillOnce(FinishRequest(&invalidate_request, 0, &mock_image_ctx)); } - void expect_truncate_request(MockImageCtx &mock_image_ctx) { + void expect_truncate_request(MockObjectMapImageCtx &mock_image_ctx) { std::string oid(ObjectMap::object_map_name(mock_image_ctx.id, TEST_SNAP_ID)); EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx), truncate(oid, 0, _)) .WillOnce(Return(0)); } - void expect_object_map_resize(MockImageCtx &mock_image_ctx, + void expect_object_map_resize(MockObjectMapImageCtx &mock_image_ctx, uint64_t num_objects, int r) { std::string oid(ObjectMap::object_map_name(mock_image_ctx.id, TEST_SNAP_ID)); auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx), @@ -113,7 +129,7 @@ public: expect.WillOnce(Return(r)); } - void init_object_map(MockImageCtx &mock_image_ctx, + void init_object_map(MockObjectMapImageCtx &mock_image_ctx, ceph::BitVector<2> *object_map) { uint64_t num_objs = Striper::get_num_objects( mock_image_ctx.layout, mock_image_ctx.image_ctx->size); @@ -128,7 +144,7 @@ TEST_F(TestMockObjectMapRefreshRequest, SuccessHead) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockObjectMapImageCtx mock_image_ctx(*ictx); ceph::BitVector<2> on_disk_object_map; init_object_map(mock_image_ctx, &on_disk_object_map); @@ -156,7 +172,7 @@ TEST_F(TestMockObjectMapRefreshRequest, SuccessSnapshot) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockObjectMapImageCtx mock_image_ctx(*ictx); ceph::BitVector<2> on_disk_object_map; init_object_map(mock_image_ctx, &on_disk_object_map); @@ -182,7 +198,7 @@ TEST_F(TestMockObjectMapRefreshRequest, LoadError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockObjectMapImageCtx mock_image_ctx(*ictx); ceph::BitVector<2> on_disk_object_map; init_object_map(mock_image_ctx, &on_disk_object_map); @@ -210,7 +226,7 @@ TEST_F(TestMockObjectMapRefreshRequest, LoadCorrupt) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockObjectMapImageCtx mock_image_ctx(*ictx); ceph::BitVector<2> on_disk_object_map; init_object_map(mock_image_ctx, &on_disk_object_map); @@ -240,7 +256,7 @@ TEST_F(TestMockObjectMapRefreshRequest, TooSmall) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockObjectMapImageCtx mock_image_ctx(*ictx); ceph::BitVector<2> on_disk_object_map; init_object_map(mock_image_ctx, &on_disk_object_map); @@ -271,7 +287,7 @@ TEST_F(TestMockObjectMapRefreshRequest, TooLarge) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockObjectMapImageCtx mock_image_ctx(*ictx); ceph::BitVector<2> on_disk_object_map; init_object_map(mock_image_ctx, &on_disk_object_map); @@ -298,7 +314,7 @@ TEST_F(TestMockObjectMapRefreshRequest, ResizeError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockObjectMapImageCtx mock_image_ctx(*ictx); ceph::BitVector<2> on_disk_object_map; init_object_map(mock_image_ctx, &on_disk_object_map); diff --git a/src/test/librbd/operation/test_mock_SnapshotRollbackRequest.cc b/src/test/librbd/operation/test_mock_SnapshotRollbackRequest.cc index dab341874faa0..617333676e6f9 100644 --- a/src/test/librbd/operation/test_mock_SnapshotRollbackRequest.cc +++ b/src/test/librbd/operation/test_mock_SnapshotRollbackRequest.cc @@ -14,14 +14,24 @@ #include "gtest/gtest.h" namespace librbd { + +namespace { + +struct MockOperationImageCtx : public MockImageCtx { + MockOperationImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace + namespace operation { template <> -struct ResizeRequest { +struct ResizeRequest { static ResizeRequest *s_instance; Context *on_finish = nullptr; - static ResizeRequest* create(MockImageCtx &image_ctx, Context *on_finish, + static ResizeRequest* create(MockOperationImageCtx &image_ctx, Context *on_finish, uint64_t new_size, ProgressContext &prog_ctx, uint64_t journal_op_tid, bool disable_journal) { assert(s_instance != nullptr); @@ -38,14 +48,31 @@ struct ResizeRequest { MOCK_METHOD0(send, void()); }; -ResizeRequest *ResizeRequest::s_instance = nullptr; +ResizeRequest *ResizeRequest::s_instance = nullptr; } // namespace operation + +template <> +struct AsyncRequest : public AsyncRequest { + MockOperationImageCtx &m_image_ctx; + + AsyncRequest(MockOperationImageCtx &image_ctx, Context *on_finish) + : AsyncRequest(image_ctx, on_finish), m_image_ctx(image_ctx) { + } +}; + } // namespace librbd // template definitions +#include "librbd/AsyncRequest.cc" +#include "librbd/AsyncObjectThrottle.cc" +#include "librbd/operation/Request.cc" #include "librbd/operation/SnapshotRollbackRequest.cc" +template class librbd::AsyncRequest; +template class librbd::AsyncObjectThrottle; +template class librbd::operation::Request; + namespace librbd { namespace operation { @@ -56,26 +83,26 @@ using ::testing::WithArg; class TestMockOperationSnapshotRollbackRequest : public TestMockFixture { public: - typedef SnapshotRollbackRequest MockSnapshotRollbackRequest; - typedef ResizeRequest MockResizeRequest; + typedef SnapshotRollbackRequest MockSnapshotRollbackRequest; + typedef ResizeRequest MockResizeRequest; - void expect_block_writes(MockImageCtx &mock_image_ctx, int r) { + void expect_block_writes(MockOperationImageCtx &mock_image_ctx, int r) { EXPECT_CALL(*mock_image_ctx.aio_work_queue, block_writes(_)) .WillOnce(CompleteContext(r, mock_image_ctx.image_ctx->op_work_queue)); } - void expect_unblock_writes(MockImageCtx &mock_image_ctx) { + void expect_unblock_writes(MockOperationImageCtx &mock_image_ctx) { EXPECT_CALL(*mock_image_ctx.aio_work_queue, unblock_writes()) .Times(1); } - void expect_get_image_size(MockImageCtx &mock_image_ctx, + void expect_get_image_size(MockOperationImageCtx &mock_image_ctx, uint64_t size) { EXPECT_CALL(mock_image_ctx, get_image_size(CEPH_NOSNAP)) .WillOnce(Return(size)); } - void expect_resize(MockImageCtx &mock_image_ctx, + void expect_resize(MockOperationImageCtx &mock_image_ctx, MockResizeRequest &mock_resize_request, int r) { expect_get_image_size(mock_image_ctx, 123); EXPECT_CALL(mock_resize_request, send()) @@ -83,7 +110,7 @@ public: &mock_image_ctx)); } - void expect_rollback_object_map(MockImageCtx &mock_image_ctx, + void expect_rollback_object_map(MockOperationImageCtx &mock_image_ctx, MockObjectMap &mock_object_map) { if (mock_image_ctx.object_map != nullptr) { EXPECT_CALL(mock_object_map, rollback(_, _)) @@ -91,43 +118,43 @@ public: } } - void expect_get_object_name(MockImageCtx &mock_image_ctx, + void expect_get_object_name(MockOperationImageCtx &mock_image_ctx, uint64_t object_num) { EXPECT_CALL(mock_image_ctx, get_object_name(object_num)) .WillOnce(Return("object-name-" + stringify(object_num))); } - void expect_get_current_size(MockImageCtx &mock_image_ctx, uint64_t size) { + void expect_get_current_size(MockOperationImageCtx &mock_image_ctx, uint64_t size) { EXPECT_CALL(mock_image_ctx, get_current_size()) .WillOnce(Return(size)); } - void expect_rollback_snap_id(MockImageCtx &mock_image_ctx, + void expect_rollback_snap_id(MockOperationImageCtx &mock_image_ctx, const std::string &oid, int r) { EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.data_ctx), selfmanaged_snap_rollback(oid, _)) .WillOnce(Return(r)); } - void expect_rollback(MockImageCtx &mock_image_ctx, int r) { + void expect_rollback(MockOperationImageCtx &mock_image_ctx, int r) { expect_get_current_size(mock_image_ctx, 1); expect_get_object_name(mock_image_ctx, 0); expect_rollback_snap_id(mock_image_ctx, "object-name-0", r); } - void expect_create_object_map(MockImageCtx &mock_image_ctx, + void expect_create_object_map(MockOperationImageCtx &mock_image_ctx, MockObjectMap *mock_object_map) { EXPECT_CALL(mock_image_ctx, create_object_map(_)) .WillOnce(Return(mock_object_map)); } - void expect_open_object_map(MockImageCtx &mock_image_ctx, + void expect_open_object_map(MockOperationImageCtx &mock_image_ctx, MockObjectMap &mock_object_map) { EXPECT_CALL(mock_object_map, open(_)) .WillOnce(CompleteContext(0, mock_image_ctx.image_ctx->op_work_queue)); } - void expect_refresh_object_map(MockImageCtx &mock_image_ctx, + void expect_refresh_object_map(MockOperationImageCtx &mock_image_ctx, MockObjectMap &mock_object_map) { if (mock_image_ctx.object_map != nullptr) { expect_create_object_map(mock_image_ctx, &mock_object_map); @@ -135,14 +162,14 @@ public: } } - void expect_invalidate_cache(MockImageCtx &mock_image_ctx, int r) { + void expect_invalidate_cache(MockOperationImageCtx &mock_image_ctx, int r) { if (mock_image_ctx.object_cacher != nullptr) { EXPECT_CALL(mock_image_ctx, invalidate_cache(_)) .WillOnce(CompleteContext(r, NULL)); } } - int when_snap_rollback(MockImageCtx &mock_image_ctx, + int when_snap_rollback(MockOperationImageCtx &mock_image_ctx, const std::string &snap_name, uint64_t snap_id, uint64_t snap_size) { C_SaferCond cond_ctx; @@ -161,7 +188,7 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, Success) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockOperationImageCtx mock_image_ctx(*ictx); MockExclusiveLock mock_exclusive_lock; MockJournal mock_journal; MockObjectMap *mock_object_map = new MockObjectMap(); @@ -187,7 +214,7 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, BlockWritesError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockOperationImageCtx mock_image_ctx(*ictx); MockExclusiveLock mock_exclusive_lock; MockJournal mock_journal; MockObjectMap mock_object_map; @@ -207,7 +234,7 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, SkipResize) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockOperationImageCtx mock_image_ctx(*ictx); MockExclusiveLock mock_exclusive_lock; MockJournal mock_journal; MockObjectMap *mock_object_map = new MockObjectMap(); @@ -232,7 +259,7 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, ResizeError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockOperationImageCtx mock_image_ctx(*ictx); MockExclusiveLock mock_exclusive_lock; MockJournal mock_journal; MockObjectMap mock_object_map; @@ -254,7 +281,7 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, RollbackObjectsError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockOperationImageCtx mock_image_ctx(*ictx); MockExclusiveLock mock_exclusive_lock; MockJournal mock_journal; MockObjectMap mock_object_map; @@ -278,7 +305,7 @@ TEST_F(TestMockOperationSnapshotRollbackRequest, InvalidateCacheError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockOperationImageCtx mock_image_ctx(*ictx); MockExclusiveLock mock_exclusive_lock; MockJournal mock_journal; MockObjectMap *mock_object_map = new MockObjectMap(); diff --git a/src/test/librbd/test_mock_ExclusiveLock.cc b/src/test/librbd/test_mock_ExclusiveLock.cc index 34d1e5e06e2e7..775767598c706 100644 --- a/src/test/librbd/test_mock_ExclusiveLock.cc +++ b/src/test/librbd/test_mock_ExclusiveLock.cc @@ -12,6 +12,16 @@ #include namespace librbd { + +namespace { + +struct MockExclusiveLockImageCtx : public MockImageCtx { + MockExclusiveLockImageCtx(ImageCtx &image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace + namespace exclusive_lock { template @@ -20,7 +30,7 @@ struct BaseRequest { Context *on_lock_unlock = nullptr; Context *on_finish = nullptr; - static T* create(MockImageCtx &image_ctx, const std::string &cookie, + static T* create(MockExclusiveLockImageCtx &image_ctx, const std::string &cookie, Context *on_lock_unlock, Context *on_finish) { assert(!s_requests.empty()); T* req = s_requests.front(); @@ -39,12 +49,12 @@ template std::list BaseRequest::s_requests; template <> -struct AcquireRequest : public BaseRequest > { +struct AcquireRequest : public BaseRequest > { MOCK_METHOD0(send, void()); }; template <> -struct ReleaseRequest : public BaseRequest > { +struct ReleaseRequest : public BaseRequest > { MOCK_METHOD0(send, void()); }; @@ -53,7 +63,7 @@ struct ReleaseRequest : public BaseRequest; +template class librbd::ExclusiveLock; ACTION_P(FinishLockUnlock, request) { if (request->on_lock_unlock != nullptr) { @@ -71,24 +81,24 @@ using ::testing::Return; class TestMockExclusiveLock : public TestMockFixture { public: - typedef ExclusiveLock MockExclusiveLock; - typedef exclusive_lock::AcquireRequest MockAcquireRequest; - typedef exclusive_lock::ReleaseRequest MockReleaseRequest; + typedef ExclusiveLock MockExclusiveLock; + typedef exclusive_lock::AcquireRequest MockAcquireRequest; + typedef exclusive_lock::ReleaseRequest MockReleaseRequest; - void expect_get_watch_handle(MockImageCtx &mock_image_ctx) { + void expect_get_watch_handle(MockExclusiveLockImageCtx &mock_image_ctx) { EXPECT_CALL(*mock_image_ctx.image_watcher, get_watch_handle()) .WillRepeatedly(Return(1234567890)); } - void expect_set_require_lock_on_read(MockImageCtx &mock_image_ctx) { + void expect_set_require_lock_on_read(MockExclusiveLockImageCtx &mock_image_ctx) { EXPECT_CALL(*mock_image_ctx.aio_work_queue, set_require_lock_on_read()); } - void expect_clear_require_lock_on_read(MockImageCtx &mock_image_ctx) { + void expect_clear_require_lock_on_read(MockExclusiveLockImageCtx &mock_image_ctx) { EXPECT_CALL(*mock_image_ctx.aio_work_queue, clear_require_lock_on_read()); } - void expect_block_writes(MockImageCtx &mock_image_ctx) { + void expect_block_writes(MockExclusiveLockImageCtx &mock_image_ctx) { EXPECT_CALL(*mock_image_ctx.aio_work_queue, block_writes(_)) .WillOnce(CompleteContext(0, mock_image_ctx.image_ctx->op_work_queue)); if ((mock_image_ctx.features & RBD_FEATURE_JOURNALING) != 0) { @@ -96,12 +106,12 @@ public: } } - void expect_unblock_writes(MockImageCtx &mock_image_ctx) { + void expect_unblock_writes(MockExclusiveLockImageCtx &mock_image_ctx) { expect_clear_require_lock_on_read(mock_image_ctx); EXPECT_CALL(*mock_image_ctx.aio_work_queue, unblock_writes()); } - void expect_acquire_lock(MockImageCtx &mock_image_ctx, + void expect_acquire_lock(MockExclusiveLockImageCtx &mock_image_ctx, MockAcquireRequest &acquire_request, int r) { expect_get_watch_handle(mock_image_ctx); EXPECT_CALL(acquire_request, send()) @@ -113,7 +123,7 @@ public: } } - void expect_release_lock(MockImageCtx &mock_image_ctx, + void expect_release_lock(MockExclusiveLockImageCtx &mock_image_ctx, MockReleaseRequest &release_request, int r, bool shutting_down = false) { EXPECT_CALL(release_request, send()) @@ -128,34 +138,34 @@ public: } } - void expect_notify_request_lock(MockImageCtx &mock_image_ctx, + void expect_notify_request_lock(MockExclusiveLockImageCtx &mock_image_ctx, MockExclusiveLock &mock_exclusive_lock) { EXPECT_CALL(*mock_image_ctx.image_watcher, notify_request_lock()) .WillRepeatedly(Invoke(&mock_exclusive_lock, &MockExclusiveLock::handle_lock_released)); } - void expect_notify_acquired_lock(MockImageCtx &mock_image_ctx) { + void expect_notify_acquired_lock(MockExclusiveLockImageCtx &mock_image_ctx) { EXPECT_CALL(*mock_image_ctx.image_watcher, notify_acquired_lock()) .Times(1); } - void expect_notify_released_lock(MockImageCtx &mock_image_ctx) { + void expect_notify_released_lock(MockExclusiveLockImageCtx &mock_image_ctx) { EXPECT_CALL(*mock_image_ctx.image_watcher, notify_released_lock()) .Times(1); } - void expect_is_lock_request_needed(MockImageCtx &mock_image_ctx, bool ret) { + void expect_is_lock_request_needed(MockExclusiveLockImageCtx &mock_image_ctx, bool ret) { EXPECT_CALL(*mock_image_ctx.aio_work_queue, is_lock_request_needed()) .WillRepeatedly(Return(ret)); } - void expect_flush_notifies(MockImageCtx &mock_image_ctx) { + void expect_flush_notifies(MockExclusiveLockImageCtx &mock_image_ctx) { EXPECT_CALL(*mock_image_ctx.image_watcher, flush(_)) .WillOnce(CompleteContext(0, mock_image_ctx.image_ctx->op_work_queue)); } - int when_init(MockImageCtx &mock_image_ctx, + int when_init(MockExclusiveLockImageCtx &mock_image_ctx, MockExclusiveLock &exclusive_lock) { C_SaferCond ctx; { @@ -165,7 +175,7 @@ public: return ctx.wait(); } - int when_try_lock(MockImageCtx &mock_image_ctx, + int when_try_lock(MockExclusiveLockImageCtx &mock_image_ctx, MockExclusiveLock &exclusive_lock) { C_SaferCond ctx; { @@ -174,7 +184,7 @@ public: } return ctx.wait(); } - int when_request_lock(MockImageCtx &mock_image_ctx, + int when_request_lock(MockExclusiveLockImageCtx &mock_image_ctx, MockExclusiveLock &exclusive_lock) { C_SaferCond ctx; { @@ -183,7 +193,7 @@ public: } return ctx.wait(); } - int when_release_lock(MockImageCtx &mock_image_ctx, + int when_release_lock(MockExclusiveLockImageCtx &mock_image_ctx, MockExclusiveLock &exclusive_lock) { C_SaferCond ctx; { @@ -192,7 +202,7 @@ public: } return ctx.wait(); } - int when_shut_down(MockImageCtx &mock_image_ctx, + int when_shut_down(MockExclusiveLockImageCtx &mock_image_ctx, MockExclusiveLock &exclusive_lock) { C_SaferCond ctx; { @@ -202,7 +212,7 @@ public: return ctx.wait(); } - bool is_lock_owner(MockImageCtx &mock_image_ctx, + bool is_lock_owner(MockExclusiveLockImageCtx &mock_image_ctx, MockExclusiveLock &exclusive_lock) { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); return exclusive_lock.is_lock_owner(); @@ -215,7 +225,7 @@ TEST_F(TestMockExclusiveLock, StateTransitions) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockExclusiveLockImageCtx mock_image_ctx(*ictx); MockExclusiveLock exclusive_lock(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -250,7 +260,7 @@ TEST_F(TestMockExclusiveLock, TryLockLockedState) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockExclusiveLockImageCtx mock_image_ctx(*ictx); MockExclusiveLock exclusive_lock(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -274,7 +284,7 @@ TEST_F(TestMockExclusiveLock, TryLockAlreadyLocked) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockExclusiveLockImageCtx mock_image_ctx(*ictx); MockExclusiveLock exclusive_lock(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -298,7 +308,7 @@ TEST_F(TestMockExclusiveLock, TryLockBusy) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockExclusiveLockImageCtx mock_image_ctx(*ictx); MockExclusiveLock exclusive_lock(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -322,7 +332,7 @@ TEST_F(TestMockExclusiveLock, TryLockError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockExclusiveLockImageCtx mock_image_ctx(*ictx); MockExclusiveLock exclusive_lock(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -347,7 +357,7 @@ TEST_F(TestMockExclusiveLock, RequestLockLockedState) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockExclusiveLockImageCtx mock_image_ctx(*ictx); MockExclusiveLock exclusive_lock(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -372,7 +382,7 @@ TEST_F(TestMockExclusiveLock, RequestLockBlacklist) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockExclusiveLockImageCtx mock_image_ctx(*ictx); MockExclusiveLock exclusive_lock(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -398,7 +408,7 @@ TEST_F(TestMockExclusiveLock, RequestLockBusy) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockExclusiveLockImageCtx mock_image_ctx(*ictx); MockExclusiveLock exclusive_lock(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -427,7 +437,7 @@ TEST_F(TestMockExclusiveLock, RequestLockError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockExclusiveLockImageCtx mock_image_ctx(*ictx); MockExclusiveLock exclusive_lock(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -456,7 +466,7 @@ TEST_F(TestMockExclusiveLock, ReleaseLockUnlockedState) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockExclusiveLockImageCtx mock_image_ctx(*ictx); MockExclusiveLock exclusive_lock(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -477,7 +487,7 @@ TEST_F(TestMockExclusiveLock, ReleaseLockError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockExclusiveLockImageCtx mock_image_ctx(*ictx); MockExclusiveLock exclusive_lock(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -507,7 +517,7 @@ TEST_F(TestMockExclusiveLock, ConcurrentRequests) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockExclusiveLockImageCtx mock_image_ctx(*ictx); MockExclusiveLock exclusive_lock(mock_image_ctx); expect_op_work_queue(mock_image_ctx); diff --git a/src/test/librbd/test_mock_Journal.cc b/src/test/librbd/test_mock_Journal.cc index a4ded00675fd8..5c506199d570d 100644 --- a/src/test/librbd/test_mock_Journal.cc +++ b/src/test/librbd/test_mock_Journal.cc @@ -183,10 +183,20 @@ MockJournaler *MockJournaler::s_instance = nullptr; } // namespace journal namespace librbd { + +namespace { + +struct MockJournalImageCtx : public MockImageCtx { + MockJournalImageCtx(librbd::ImageCtx& image_ctx) : MockImageCtx(image_ctx) { + } +}; + +} // anonymous namespace + namespace journal { template <> -struct TypeTraits { +struct TypeTraits { typedef ::journal::MockJournalerProxy Journaler; typedef ::journal::MockFutureProxy Future; typedef ::journal::MockReplayEntryProxy ReplayEntry; @@ -209,9 +219,9 @@ struct MockReplay { }; template <> -class Replay { +class Replay { public: - static Replay *create(MockImageCtx &image_ctx) { + static Replay *create(MockJournalImageCtx &image_ctx) { return new Replay(); } @@ -236,7 +246,7 @@ MockReplay *MockReplay::s_instance = nullptr; // template definitions #include "librbd/Journal.cc" -template class librbd::Journal; +template class librbd::Journal; using ::testing::_; using ::testing::DoAll; @@ -260,7 +270,7 @@ namespace librbd { class TestMockJournal : public TestMockFixture { public: typedef journal::MockReplay MockJournalReplay; - typedef Journal MockJournal; + typedef Journal MockJournal; typedef std::function ReplayAction; typedef std::list ReplayActions; @@ -301,7 +311,7 @@ public: } - void expect_start_replay(MockImageCtx &mock_image_ctx, + void expect_start_replay(MockJournalImageCtx &mock_image_ctx, ::journal::MockJournaler &mock_journaler, const ReplayActions &actions) { EXPECT_CALL(mock_journaler, start_replay(_)) @@ -313,7 +323,7 @@ public: EXPECT_CALL(mock_journaler, stop_replay()); } - void expect_shut_down_replay(MockImageCtx &mock_image_ctx, + void expect_shut_down_replay(MockJournalImageCtx &mock_image_ctx, MockJournalReplay &mock_journal_replay, int r, bool cancel_ops = false) { EXPECT_CALL(mock_journal_replay, shut_down(cancel_ops, _)) @@ -394,7 +404,7 @@ public: return ctx.wait(); } - uint64_t when_append_io_event(MockImageCtx &mock_image_ctx, + uint64_t when_append_io_event(MockJournalImageCtx &mock_image_ctx, MockJournal &mock_journal, AioCompletion *aio_comp = nullptr) { RWLock::RLocker owner_locker(mock_image_ctx.owner_lock); @@ -413,7 +423,8 @@ public: m_cond.Signal(); } - void commit_replay(MockImageCtx &mock_image_ctx, Context *on_flush, int r) { + void commit_replay(MockJournalImageCtx &mock_image_ctx, Context *on_flush, + int r) { Contexts commit_contexts; std::swap(commit_contexts, m_commit_contexts); @@ -423,7 +434,8 @@ public: mock_image_ctx.image_ctx->op_work_queue->queue(on_flush, 0); } - void open_journal(MockImageCtx &mock_image_ctx, MockJournal &mock_journal, + void open_journal(MockJournalImageCtx &mock_image_ctx, + MockJournal &mock_journal, ::journal::MockJournaler &mock_journaler) { expect_op_work_queue(mock_image_ctx); @@ -464,7 +476,7 @@ TEST_F(TestMockJournal, StateTransitions) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockJournalImageCtx mock_image_ctx(*ictx); MockJournal mock_journal(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -509,7 +521,7 @@ TEST_F(TestMockJournal, InitError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockJournalImageCtx mock_image_ctx(*ictx); MockJournal mock_journal(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -527,7 +539,7 @@ TEST_F(TestMockJournal, ReplayCompleteError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockJournalImageCtx mock_image_ctx(*ictx); MockJournal mock_journal(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -568,7 +580,7 @@ TEST_F(TestMockJournal, FlushReplayError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockJournalImageCtx mock_image_ctx(*ictx); MockJournal mock_journal(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -614,7 +626,7 @@ TEST_F(TestMockJournal, StopError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockJournalImageCtx mock_image_ctx(*ictx); MockJournal mock_journal(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -644,7 +656,7 @@ TEST_F(TestMockJournal, ReplayOnDiskPreFlushError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockJournalImageCtx mock_image_ctx(*ictx); MockJournal mock_journal(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -717,7 +729,7 @@ TEST_F(TestMockJournal, ReplayOnDiskPostFlushError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockJournalImageCtx mock_image_ctx(*ictx); MockJournal mock_journal(mock_image_ctx); expect_op_work_queue(mock_image_ctx); @@ -791,7 +803,7 @@ TEST_F(TestMockJournal, EventAndIOCommitOrder) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockJournalImageCtx mock_image_ctx(*ictx); MockJournal mock_journal(mock_image_ctx); ::journal::MockJournaler mock_journaler; open_journal(mock_image_ctx, mock_journal, mock_journaler); @@ -831,7 +843,7 @@ TEST_F(TestMockJournal, EventCommitError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockJournalImageCtx mock_image_ctx(*ictx); MockJournal mock_journal(mock_image_ctx); ::journal::MockJournaler mock_journaler; open_journal(mock_image_ctx, mock_journal, mock_journaler); @@ -868,7 +880,7 @@ TEST_F(TestMockJournal, EventCommitErrorWithPendingWriteback) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockJournalImageCtx mock_image_ctx(*ictx); MockJournal mock_journal(mock_image_ctx); ::journal::MockJournaler mock_journaler; open_journal(mock_image_ctx, mock_journal, mock_journaler); @@ -906,7 +918,7 @@ TEST_F(TestMockJournal, IOCommitError) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockJournalImageCtx mock_image_ctx(*ictx); MockJournal mock_journal(mock_image_ctx); ::journal::MockJournaler mock_journaler; open_journal(mock_image_ctx, mock_journal, mock_journaler); @@ -931,7 +943,7 @@ TEST_F(TestMockJournal, FlushCommitPosition) { librbd::ImageCtx *ictx; ASSERT_EQ(0, open_image(m_image_name, &ictx)); - MockImageCtx mock_image_ctx(*ictx); + MockJournalImageCtx mock_image_ctx(*ictx); MockJournal mock_journal(mock_image_ctx); ::journal::MockJournaler mock_journaler; open_journal(mock_image_ctx, mock_journal, mock_journaler); diff --git a/src/test/librbd/test_mock_fixture.cc b/src/test/librbd/test_mock_fixture.cc index cd03ac6f3a8aa..363e7166d5523 100644 --- a/src/test/librbd/test_mock_fixture.cc +++ b/src/test/librbd/test_mock_fixture.cc @@ -9,10 +9,12 @@ // template definitions #include "librbd/AsyncRequest.cc" #include "librbd/AsyncObjectThrottle.cc" +#include "librbd/ExclusiveLock.cc" #include "librbd/operation/Request.cc" template class librbd::AsyncRequest; template class librbd::AsyncObjectThrottle; +template class librbd::ExclusiveLock; template class librbd::operation::Request; using ::testing::_;