namespace cache {
namespace pwl {
+using namespace std;
+
struct TestLogEntry {
uint64_t image_offset_bytes;
uint64_t write_bytes;
#include "librbd/deep_copy/ImageCopyRequest.cc"
template class librbd::deep_copy::ImageCopyRequest<librbd::MockTestImageCtx>;
+using namespace std::chrono_literals;
+
namespace librbd {
namespace deep_copy {
}
bool wait_for_entries_available(librbd::ImageCtx *ictx) {
+ using namespace std::chrono_literals;
std::unique_lock locker{m_replay_handler.lock};
while (!m_replay_handler.entries_available) {
if (m_replay_handler.cond.wait_for(locker, 10s) == std::cv_status::timeout) {
MockUnlinkPeerRequest mock_unlink_peer_request;
auto it = mock_image_ctx.snap_info.rbegin();
auto snap_id = it->first;
- std::list<string> peer_uuids = {"uuid"};
+ std::list<std::string> peer_uuids = {"uuid"};
expect_unlink_peer(mock_image_ctx, mock_unlink_peer_request, snap_id, "uuid",
false, 0);
MOCK_CONST_METHOD1(get_parent_info, const ParentImageInfo*(librados::snap_t));
MOCK_CONST_METHOD2(get_parent_overlap, int(librados::snap_t in_snap_id,
uint64_t *overlap));
- MOCK_CONST_METHOD2(prune_parent_extents, uint64_t(vector<pair<uint64_t,uint64_t> >& ,
+ MOCK_CONST_METHOD2(prune_parent_extents, uint64_t(std::vector<std::pair<uint64_t,uint64_t> >& ,
uint64_t));
MOCK_CONST_METHOD2(is_snap_protected, int(librados::snap_t in_snap_id,
}
void compare() {
- vector<librbd::snap_info_t> src_snaps, dst_snaps;
+ std::vector<librbd::snap_info_t> src_snaps, dst_snaps;
EXPECT_EQ(m_src_ictx->size, m_dst_ictx->size);
EXPECT_EQ(0, librbd::api::Snapshot<>::list(m_src_ictx, src_snaps));
librbd::RBD rbd;
ASSERT_EQ(0, rbd.group_create(ioctx, "mygroup"));
- vector<string> groups;
+ std::vector<std::string> groups;
ASSERT_EQ(0, rbd.group_list(ioctx, &groups));
ASSERT_EQ(1U, groups.size());
ASSERT_EQ("mygroup", groups[0]);
ASSERT_TRUE((op_features & RBD_OPERATION_FEATURE_GROUP) ==
RBD_OPERATION_FEATURE_GROUP);
- vector<librbd::group_image_info_t> images;
+ std::vector<librbd::group_image_info_t> images;
ASSERT_EQ(0, rbd.group_image_list(ioctx, group_name, &images,
sizeof(librbd::group_image_info_t)));
ASSERT_EQ(1U, images.size());
#include <sstream>
#include <vector>
+using namespace std::chrono_literals;
using namespace ceph;
using namespace boost::assign;
using namespace librbd::watch_notify;
}
void compare(const std::string &description = "") {
- vector<librbd::snap_info_t> src_snaps, dst_snaps;
+ std::vector<librbd::snap_info_t> src_snaps, dst_snaps;
EXPECT_EQ(m_ref_ictx->size, m_ictx->size);
EXPECT_EQ(0, librbd::api::Snapshot<>::list(m_ref_ictx, src_snaps));
migration_prepare(m_ioctx, m_image_name);
migration_status(RBD_IMAGE_MIGRATION_STATE_PREPARED);
- thread user([this]() {
+ std::thread user([this]() {
test_stress("user", 'a');
for (int i = 0; i < 5; i++) {
uint64_t off = (i + 1) * m_ictx->size / 10;
ASSERT_TRUE(flags_set);
}
+namespace chrono = std::chrono;
+
TEST_F(TestObjectMap, DISABLED_StressTest) {
REQUIRE_FEATURE(RBD_FEATURE_OBJECT_MAP);
#include <utility>
#include <vector>
+using namespace std;
+
void register_test_internal() {
}
#include <utility>
#include <vector>
+using namespace std;
+
void register_test_mirroring() {
}
#include "gtest/gtest.h"
#include <list>
+using namespace std;
+
namespace librbd {
struct MockManagedLockImageCtx : public MockImageCtx {
}
bool wait_for_watch(MockImageCtx &mock_image_ctx, size_t count) {
+ using namespace std::chrono_literals;
std::unique_lock locker{m_lock};
while (m_watch_count < count) {
if (m_cond.wait_for(locker, 10s) == std::cv_status::timeout) {