}
static std::list<EntityAuth> generate_test_instances() {
std::list<EntityAuth> ls;
- ls.push_back(EntityAuth{});
+ ls.emplace_back();
return ls;
}
};
}
static std::list<AuthCapsInfo> generate_test_instances() {
std::list<AuthCapsInfo> ls;
- ls.push_back(AuthCapsInfo{});
- ls.push_back(AuthCapsInfo{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().allow_all = true;
- ls.push_back(AuthCapsInfo{});
+ ls.emplace_back();
ls.back().caps.append("foo");
ls.back().caps.append("bar");
return ls;
}
static std::list<AuthTicket> generate_test_instances() {
std::list<AuthTicket> ls;
- ls.push_back(AuthTicket{});
- ls.push_back(AuthTicket{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().name.set_id("client.123");
ls.back().global_id = 123;
ls.back().init_timestamps(utime_t(123, 456), 7);
}
static std::list<ExpiringCryptoKey> generate_test_instances() {
std::list<ExpiringCryptoKey> ls;
- ls.push_back(ExpiringCryptoKey{});
- ls.push_back(ExpiringCryptoKey{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().key.set_secret(
CEPH_CRYPTO_AES, bufferptr("1234567890123456", 16), utime_t(123, 456));
return ls;
}
static std::list<RotatingSecrets> generate_test_instances() {
std::list<RotatingSecrets> ls;
- ls.push_back(RotatingSecrets{});
- ls.push_back(RotatingSecrets{});
+ ls.emplace_back();
+ ls.emplace_back();
ExpiringCryptoKey eck{};
ls.back().add(eck);
return ls;
}
static std::list<KeyServerData> generate_test_instances() {
std::list<KeyServerData> ls;
- ls.push_back(KeyServerData{});
- ls.push_back(KeyServerData{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().version = 1;
return ls;
}
}
static std::list<Incremental> generate_test_instances() {
std::list<Incremental> ls;
- ls.push_back(Incremental{});
+ ls.emplace_back();
ls.back().op = AUTH_INC_DEL;
- ls.push_back(Incremental{});
+ ls.emplace_back();
ls.back().op = AUTH_INC_ADD;
- ls.push_back(Incremental{});
+ ls.emplace_back();
ls.back().op = AUTH_INC_SET_ROTATING;
return ls;
}
}
static std::list<CephXServerChallenge> generate_test_instances() {
std::list<CephXServerChallenge> ls;
- ls.push_back(CephXServerChallenge{});
+ ls.emplace_back();
ls.back().server_challenge = 1;
return ls;
}
}
static std::list<CephXRequestHeader> generate_test_instances() {
std::list<CephXRequestHeader> ls;
- ls.push_back(CephXRequestHeader{});
+ ls.emplace_back();
ls.back().request_type = 1;
return ls;
}
}
static std::list<CephXResponseHeader> generate_test_instances() {
std::list<CephXResponseHeader> ls;
- ls.push_back(CephXResponseHeader{});
+ ls.emplace_back();
ls.back().request_type = 1;
ls.back().status = 0;
return ls;
static std::list<CephXTicketBlob> generate_test_instances() {
std::list<CephXTicketBlob> ls;
- ls.push_back(CephXTicketBlob{});
+ ls.emplace_back();
ls.back().secret_id = 123;
ls.back().blob.append(std::string_view("this is a blob"));
return ls;
}
static std::list<CephXAuthenticate> generate_test_instances() {
std::list<CephXAuthenticate> ls;
- ls.push_back(CephXAuthenticate{});
+ ls.emplace_back();
ls.back().client_challenge = 0;
ls.back().key = 0;
- ls.push_back(CephXAuthenticate{});
+ ls.emplace_back();
ls.back().client_challenge = 1;
ls.back().key = 2;
ls.back().old_ticket.secret_id = 3;
}
static std::list<CephXChallengeBlob> generate_test_instances() {
std::list<CephXChallengeBlob> ls;
- ls.push_back(CephXChallengeBlob{});
+ ls.emplace_back();
ls.back().server_challenge = 123;
ls.back().client_challenge = 456;
return ls;
static std::list<CephXServiceTicketRequest> generate_test_instances() {
std::list<CephXServiceTicketRequest> ls;
- ls.push_back(CephXServiceTicketRequest{});
+ ls.emplace_back();
ls.back().keys = 123;
return ls;
}
}
static std::list<CephXAuthorizeReply> generate_test_instances() {
std::list<CephXAuthorizeReply> ls;
- ls.push_back(CephXAuthorizeReply{});
+ ls.emplace_back();
ls.back().nonce_plus_one = 0;
- ls.push_back(CephXAuthorizeReply{});
+ ls.emplace_back();
ls.back().nonce_plus_one = 123;
ls.back().connection_secret = "secret";
return ls;
}
static std::list<CephXServiceTicket> generate_test_instances() {
std::list<CephXServiceTicket> ls;
- ls.push_back(CephXServiceTicket{});
- ls.push_back(CephXServiceTicket{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().session_key.set_secret(
CEPH_CRYPTO_AES, bufferptr("1234567890123456", 16), utime_t(123, 456));
ls.back().validity = utime_t(123, 456);
}
static std::list<CephXServiceTicketInfo> generate_test_instances() {
std::list<CephXServiceTicketInfo> ls;
- ls.push_back(CephXServiceTicketInfo{});
- ls.push_back(CephXServiceTicketInfo{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().ticket.global_id = 1234;
ls.back().ticket.init_timestamps(utime_t(123, 456), utime_t(123, 456));
ls.back().session_key.set_secret(
}
static std::list<CephXAuthorizeChallenge> generate_test_instances() {
std::list<CephXAuthorizeChallenge> ls;
- ls.push_back(CephXAuthorizeChallenge{});
+ ls.emplace_back();
ls.back().server_challenge = 1234;
return ls;
}
}
static std::list<CephXAuthorize> generate_test_instances() {
std::list<CephXAuthorize> ls;
- ls.push_back(CephXAuthorize{});
- ls.push_back(CephXAuthorize{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().nonce = 1234;
ls.back().have_challenge = true;
ls.back().server_challenge_plus_one = 1234;
static std::list<cls_2pc_queue_reserve_op> generate_test_instances() {
std::list<cls_2pc_queue_reserve_op> ls;
- ls.push_back(cls_2pc_queue_reserve_op{});
+ ls.emplace_back();
ls.back().size = 0;
- ls.push_back(cls_2pc_queue_reserve_op{});
+ ls.emplace_back();
ls.back().size = 123;
ls.back().entries = 456;
return ls;
static std::list<cls_2pc_queue_reserve_ret> generate_test_instances() {
std::list<cls_2pc_queue_reserve_ret> ls;
- ls.push_back(cls_2pc_queue_reserve_ret{});
+ ls.emplace_back();
ls.back().id = 123;
return ls;
}
static std::list<cls_2pc_queue_commit_op> generate_test_instances() {
std::list<cls_2pc_queue_commit_op> ls;
- ls.push_back(cls_2pc_queue_commit_op{});
+ ls.emplace_back();
ls.back().id = 123;
ls.back().bl_data_vec.push_back(ceph::buffer::list());
ls.back().bl_data_vec.back().append("foo");
}
static std::list<cls_2pc_queue_abort_op> generate_test_instances() {
std::list<cls_2pc_queue_abort_op> ls;
- ls.push_back(cls_2pc_queue_abort_op{});
+ ls.emplace_back();
ls.back().id = 1;
return ls;
}
}
static std::list<cls_2pc_queue_expire_op> generate_test_instances() {
std::list<cls_2pc_queue_expire_op> ls;
- ls.push_back(cls_2pc_queue_expire_op{});
- ls.push_back(cls_2pc_queue_expire_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().stale_time = ceph::coarse_real_time::min();
return ls;
}
static std::list<cls_2pc_queue_reservations_ret> generate_test_instances() {
std::list<cls_2pc_queue_reservations_ret> ls;
- ls.push_back(cls_2pc_queue_reservations_ret{});
- ls.push_back(cls_2pc_queue_reservations_ret{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().reservations[1] = cls_2pc_reservation();
ls.back().reservations[2] = cls_2pc_reservation();
return ls;
static std::list<cls_2pc_reservation> generate_test_instances() {
std::list<cls_2pc_reservation> ls;
- ls.push_back(cls_2pc_reservation{});
+ ls.emplace_back();
ls.back().size = 0;
- ls.push_back(cls_2pc_reservation{});
+ ls.emplace_back();
ls.back().size = 123;
ls.back().timestamp = ceph::coarse_real_clock::zero();
return ls;
static std::list<cls_2pc_urgent_data> generate_test_instances() {
std::list<cls_2pc_urgent_data> ls;
- ls.push_back(cls_2pc_urgent_data{});
- ls.push_back(cls_2pc_urgent_data{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().reserved_size = 123;
ls.back().last_id = 456;
ls.back().reservations.emplace(789, cls_2pc_reservation(1, ceph::coarse_real_clock::zero(), 2));
}
static std::list<chunk_refs_t> generate_test_instances() {
std::list<chunk_refs_t> ls;
- ls.push_back(chunk_refs_t{});
+ ls.emplace_back();
return ls;
}
};
}
static std::list<chunk_refs_by_object_t> generate_test_instances() {
std::list<chunk_refs_by_object_t> ls;
- ls.push_back(chunk_refs_by_object_t{});
- ls.push_back(chunk_refs_by_object_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().by_object.insert(hobject_t(sobject_t("foo", CEPH_NOSNAP)));
ls.back().by_object.insert(hobject_t(sobject_t("bar", CEPH_NOSNAP)));
return ls;
}
static std::list<chunk_refs_count_t> generate_test_instances() {
std::list<chunk_refs_count_t> o;
- o.push_back(chunk_refs_count_t{});
- o.push_back(chunk_refs_count_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().total = 123;
return o;
}
}
static std::list<cls_cas_chunk_create_or_get_ref_op> generate_test_instances() {
std::list<cls_cas_chunk_create_or_get_ref_op> ls;
- ls.push_back(cls_cas_chunk_create_or_get_ref_op{});
+ ls.emplace_back();
return ls;
}
};
}
static std::list<cls_cas_chunk_get_ref_op> generate_test_instances() {
std::list<cls_cas_chunk_get_ref_op> ls;
- ls.push_back(cls_cas_chunk_get_ref_op{});
+ ls.emplace_back();
return ls;
}
};
}
static std::list<cls_cas_chunk_put_ref_op> generate_test_instances() {
std::list<cls_cas_chunk_put_ref_op> ls;
- ls.push_back(cls_cas_chunk_put_ref_op{});
+ ls.emplace_back();
return ls;
}
};
}
static std::list<entry_header> generate_test_instances() {
std::list<entry_header> ls;
- ls.push_back(entry_header{});
- ls.push_back(entry_header{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().mtime = ceph::real_clock::now();
return ls;
}
}
static std::list<create_meta> generate_test_instances() {
std::list<create_meta> o;
- o.push_back(create_meta{});
- o.push_back(create_meta{});
+ o.emplace_back();
+ o.emplace_back();
o.back().id = "id";
objv v1;
v1.instance = "inst1";
}
static std::list<get_meta> generate_test_instances() {
std::list<get_meta> o;
- o.push_back(get_meta{});
- o.push_back(get_meta{});
+ o.emplace_back();
+ o.emplace_back();
objv v1;
v1.instance = "inst1";
v1.ver = 1;
}
static std::list<get_meta_reply> generate_test_instances() {
std::list<get_meta_reply> o;
- o.push_back(get_meta_reply{});
- o.push_back(get_meta_reply{});
+ o.emplace_back();
+ o.emplace_back();
o.back().info = fifo::info();
o.back().part_header_size = 1024;
o.back().part_entry_overhead = 1024;
}
static std::list<data_params> generate_test_instances() {
std::list<data_params> o;
- o.push_back(data_params{});
- o.push_back(data_params{});
+ o.emplace_back();
+ o.emplace_back();
o.back().max_part_size = 1;
o.back().max_entry_size = 2;
o.back().full_size_threshold = 3;
}
static std::list<info> generate_test_instances() {
std::list<info> o;
- o.push_back(info{});
- o.push_back(info{});
+ o.emplace_back();
+ o.emplace_back();
o.back().id = "myid";
o.back().version = objv();
o.back().oid_prefix = "myprefix";
std::list<ObjectPosition> ObjectPosition::generate_test_instances() {
std::list<ObjectPosition> o;
- o.push_back(ObjectPosition{});
+ o.emplace_back();
o.push_back(ObjectPosition(1, 2, 3));
return o;
}
std::list<ObjectSetPosition> ObjectSetPosition::generate_test_instances() {
std::list<ObjectSetPosition> o;
- o.push_back(ObjectSetPosition{});
+ o.emplace_back();
o.push_back(ObjectSetPosition({{0, 1, 120}, {121, 2, 121}}));
return o;
}
std::list<Tag> Tag::generate_test_instances() {
std::list<Tag> o;
- o.push_back(Tag{});
+ o.emplace_back();
bufferlist data;
data.append(std::string(128, '1'));
i.duration = utime_t(5, 0);
i.flags = LOCK_FLAG_MAY_RENEW;
o.push_back(std::move(i));
- o.push_back(cls_lock_lock_op{});
+ o.emplace_back();
return o;
}
i.name = "name";
i.cookie = "cookie";
o.push_back(std::move(i));
- o.push_back(cls_lock_unlock_op{});
+ o.emplace_back();
return o;
}
i.cookie = "cookie";
i.locker = entity_name_t::CLIENT(1);
o.push_back(std::move(i));
- o.push_back(cls_lock_break_op{});
+ o.emplace_back();
return o;
}
cls_lock_get_info_op i;
i.name = "name";
o.push_back(std::move(i));
- o.push_back(cls_lock_get_info_op{});
+ o.emplace_back();
return o;
}
i.lockers[id2] = locker_info_t(utime_t(20, 0), addr2, "description2");
o.push_back(std::move(i));
- o.push_back(cls_lock_get_info_reply{});
+ o.emplace_back();
return o;
}
i.locks.push_back("lock3");
o.push_back(std::move(i));
- o.push_back(cls_lock_list_locks_reply{});
+ o.emplace_back();
return o;
}
i.cookie = "cookie";
i.tag = "tag";
o.push_back(std::move(i));
- o.push_back(cls_lock_assert_op{});
+ o.emplace_back();
return o;
}
i.tag = "tag";
i.new_cookie = "new cookie";
o.push_back(std::move(i));
- o.push_back(cls_lock_set_cookie_op{});
+ o.emplace_back();
return o;
}
locker_id_t i;
generate_lock_id(i, 1, "cookie");
o.push_back(std::move(i));
- o.push_back(locker_id_t{});
+ o.emplace_back();
return o;
}
generate_test_addr(i.addr, 1, 2);
i.description = "description";
o.push_back(std::move(i));
- o.push_back(locker_info_t{});
+ o.emplace_back();
return o;
}
i.lock_type = ClsLockType::EXCLUSIVE;
i.tag = "tag";
o.push_back(std::move(i));
- o.push_back(lock_info_t{});
+ o.emplace_back();
return o;
}
std::list<add_op> l;
l.emplace_back();
l.emplace_back();
- l.back().entries.push_back(entry{});
- l.back().entries.push_back(entry{});
+ l.back().entries.emplace_back();
+ l.back().entries.emplace_back();
l.back().entries.back().section = "section";
l.back().entries.back().name = "name";
l.back().entries.back().timestamp = ceph::real_time{1s + 2ns};
std::list<list_ret> ls;
ls.emplace_back();
ls.emplace_back();
- ls.back().entries.push_back(entry{});
- ls.back().entries.push_back(entry{});
+ ls.back().entries.emplace_back();
+ ls.back().entries.emplace_back();
ls.back().entries.back().section = "section";
ls.back().entries.back().name = "name";
ls.back().entries.back().timestamp = ceph::real_time{1s + 2ns};
static std::list<cls::log::entry> generate_test_instances() {
std::list<cls::log::entry> l;
- l.push_back(cls::log::entry{});
- l.push_back(cls::log::entry{});
+ l.emplace_back();
+ l.emplace_back();
l.back().id = "test_id";
l.back().section = "test_section";
l.back().name = "test_name";
}
static std::list<header> generate_test_instances() {
std::list<header> o;
- o.push_back(header{});
- o.push_back(header{});
+ o.emplace_back();
+ o.emplace_back();
o.back().max_marker = "test_marker";
o.back().max_time = ceph::real_clock::zero();
return o;
static std::list<cls_queue_init_op> generate_test_instances() {
std::list<cls_queue_init_op> o;
- o.push_back(cls_queue_init_op{});
- o.push_back(cls_queue_init_op{});
+ o.emplace_back();
+ o.emplace_back();
o.back().queue_size = 1024;
o.back().max_urgent_data_size = 1024;
o.back().bl_urgent_data.append(std::string_view("data"));
static std::list<cls_queue_enqueue_op> generate_test_instances() {
std::list<cls_queue_enqueue_op> o;
- o.push_back(cls_queue_enqueue_op{});
- o.push_back(cls_queue_enqueue_op{});
+ o.emplace_back();
+ o.emplace_back();
o.back().bl_data_vec.push_back(ceph::buffer::list());
o.back().bl_data_vec.back().append(std::string_view("data"));
return o;
static std::list<cls_queue_list_op> generate_test_instances() {
std::list<cls_queue_list_op> o;
- o.push_back(cls_queue_list_op{});
- o.push_back(cls_queue_list_op{});
+ o.emplace_back();
+ o.emplace_back();
o.back().max = 123;
o.back().start_marker = "foo";
return o;
static std::list<cls_queue_list_ret> generate_test_instances() {
std::list<cls_queue_list_ret> o;
- o.push_back(cls_queue_list_ret{});
+ o.emplace_back();
o.back().is_truncated = true;
o.back().next_marker = "foo";
o.back().entries.push_back(cls_queue_entry());
}
static std::list<cls_queue_remove_op> generate_test_instances() {
std::list<cls_queue_remove_op> o;
- o.push_back(cls_queue_remove_op{});
- o.push_back(cls_queue_remove_op{});
+ o.emplace_back();
+ o.emplace_back();
o.back().end_marker = "foo";
return o;
}
}
static std::list<cls_queue_get_capacity_ret> generate_test_instances() {
std::list<cls_queue_get_capacity_ret> o;
- o.push_back(cls_queue_get_capacity_ret{});
+ o.emplace_back();
o.back().queue_capacity = 123;
return o;
}
}
static std::list<cls_queue_entry> generate_test_instances() {
std::list<cls_queue_entry> o;
- o.push_back(cls_queue_entry{});
- o.push_back(cls_queue_entry{});
+ o.emplace_back();
+ o.emplace_back();
o.back().data.append(std::string_view("data"));
o.back().marker = "marker";
return o;
}
static std::list<cls_queue_marker> generate_test_instances() {
std::list<cls_queue_marker> o;
- o.push_back(cls_queue_marker{});
- o.push_back(cls_queue_marker{});
+ o.emplace_back();
+ o.emplace_back();
o.back().offset = 1024;
o.back().gen = 0;
return o;
}
static std::list<cls_queue_head> generate_test_instances() {
std::list<cls_queue_head> o;
- o.push_back(cls_queue_head{});
- o.push_back(cls_queue_head{});
+ o.emplace_back();
+ o.emplace_back();
o.back().max_head_size = 1024;
o.back().front.offset = 1024;
o.back().front.gen = 0;
static std::list<cls_rbd_parent> generate_test_instances() {
std::list<cls_rbd_parent> o;
- o.push_back(cls_rbd_parent{});
+ o.emplace_back();
o.push_back(cls_rbd_parent{{1, "", "image id", 234}, {}});
o.push_back(cls_rbd_parent{{1, "", "image id", 234}, {123}});
o.push_back(cls_rbd_parent{{1, "ns", "image id", 234}, {123}});
std::list<ParentImageSpec> ParentImageSpec::generate_test_instances() {
std::list<ParentImageSpec> o;
- o.push_back(ParentImageSpec{});
+ o.emplace_back();
o.push_back(ParentImageSpec{1, "", "foo", 3});
o.push_back(ParentImageSpec{1, "ns", "foo", 3});
return o;
list<cls_refcount_get_op> cls_refcount_get_op::generate_test_instances()
{
list<cls_refcount_get_op> ls;
- ls.push_back(cls_refcount_get_op{});
- ls.push_back(cls_refcount_get_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().tag = "foo";
ls.back().implicit_ref = true;
return ls;
list<cls_refcount_put_op> cls_refcount_put_op::generate_test_instances()
{
list<cls_refcount_put_op> ls;
- ls.push_back(cls_refcount_put_op{});
- ls.push_back(cls_refcount_put_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().tag = "foo";
ls.back().implicit_ref = true;
return ls;
list<cls_refcount_set_op> cls_refcount_set_op::generate_test_instances()
{
list<cls_refcount_set_op> ls;
- ls.push_back(cls_refcount_set_op{});
- ls.push_back(cls_refcount_set_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().refs.push_back("foo");
ls.back().refs.push_back("bar");
return ls;
list<cls_refcount_read_op> cls_refcount_read_op::generate_test_instances()
{
list<cls_refcount_read_op> ls;
- ls.push_back(cls_refcount_read_op{});
- ls.push_back(cls_refcount_read_op{});
+ ls.emplace_back();
+ ls.emplace_back();
return ls;
}
list<cls_refcount_read_ret> cls_refcount_read_ret::generate_test_instances()
{
list<cls_refcount_read_ret> ls;
- ls.push_back(cls_refcount_read_ret{});
- ls.push_back(cls_refcount_read_ret{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().refs.push_back("foo");
ls.back().refs.push_back("bar");
return ls;
list<obj_refcount> obj_refcount::generate_test_instances()
{
list<obj_refcount> ls;
- ls.push_back(obj_refcount{});
+ ls.emplace_back();
ls.back().refs.emplace("foo",true);
ls.back().retired_refs.emplace("bar");
return ls;
list<rgw_cls_tag_timeout_op> rgw_cls_tag_timeout_op::generate_test_instances()
{
list<rgw_cls_tag_timeout_op> ls;
- ls.push_back(rgw_cls_tag_timeout_op{});
- ls.push_back(rgw_cls_tag_timeout_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().tag_timeout = 23323;
return ls;
}
list<cls_rgw_gc_set_entry_op> cls_rgw_gc_set_entry_op::generate_test_instances()
{
list<cls_rgw_gc_set_entry_op> ls;
- ls.push_back(cls_rgw_gc_set_entry_op{});
- ls.push_back(cls_rgw_gc_set_entry_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().expiration_secs = 123;
return ls;
}
list<cls_rgw_gc_defer_entry_op> cls_rgw_gc_defer_entry_op::generate_test_instances()
{
list<cls_rgw_gc_defer_entry_op> ls;
- ls.push_back(cls_rgw_gc_defer_entry_op{});
- ls.push_back(cls_rgw_gc_defer_entry_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().expiration_secs = 123;
ls.back().tag = "footag";
return ls;
list<cls_rgw_gc_list_op> cls_rgw_gc_list_op::generate_test_instances()
{
list<cls_rgw_gc_list_op> ls;
- ls.push_back(cls_rgw_gc_list_op{});
- ls.push_back(cls_rgw_gc_list_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().marker = "mymarker";
ls.back().max = 2312;
return ls;
list<cls_rgw_gc_list_ret> cls_rgw_gc_list_ret::generate_test_instances()
{
list<cls_rgw_gc_list_ret> ls;
- ls.push_back(cls_rgw_gc_list_ret{});
- ls.push_back(cls_rgw_gc_list_ret{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().entries.push_back(cls_rgw_gc_obj_info());
ls.back().truncated = true;
return ls;
list<cls_rgw_gc_remove_op> cls_rgw_gc_remove_op::generate_test_instances()
{
list<cls_rgw_gc_remove_op> ls;
- ls.push_back(cls_rgw_gc_remove_op{});
- ls.push_back(cls_rgw_gc_remove_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().tags.push_back("tag1");
ls.back().tags.push_back("tag2");
return ls;
{
list<cls_rgw_lc_get_entry_ret> ls;
cls_rgw_lc_entry entry("bucket1", 6000, 0);
- ls.push_back(cls_rgw_lc_get_entry_ret{});
+ ls.emplace_back();
ls.back().entry = entry;
return ls;
}
op.tag = "tag";
op.locator = "locator";
o.push_back(std::move(op));
- o.push_back(rgw_cls_obj_prepare_op{});
+ o.emplace_back();
return o;
}
op.meta = *iter;
o.push_back(std::move(op));
- o.push_back(rgw_cls_obj_complete_op{});
+ o.emplace_back();
return o;
}
o.push_back(std::move(op));
- o.push_back(rgw_cls_link_olh_op{});
+ o.emplace_back();
return o;
}
o.push_back(std::move(op));
- o.push_back(rgw_cls_unlink_instance_op{});
+ o.emplace_back();
return o;
}
op.olh_tag = "olh_tag";
o.push_back(std::move(op));
- o.push_back(rgw_cls_read_olh_log_op{});
+ o.emplace_back();
return o;
}
r.log[1].push_back(*iter);
o.push_back(std::move(r));
- o.push_back(rgw_cls_read_olh_log_ret{});
+ o.emplace_back();
return o;
}
op.olh_tag = "olh_tag";
o.push_back(std::move(op));
- o.push_back(rgw_cls_trim_olh_log_op{});
+ o.emplace_back();
return o;
}
op.olh_tag = "olh_tag";
o.push_back(std::move(op));
- o.push_back(rgw_cls_bucket_clear_olh_op{});
+ o.emplace_back();
return o;
}
op.num_entries = 100;
op.filter_prefix = "filter_prefix";
o.push_back(std::move(op));
- o.push_back(rgw_cls_list_op{});
+ o.emplace_back();
return o;
}
o.push_back(std::move(ret));
}
- o.push_back(rgw_cls_list_ret{});
+ o.emplace_back();
return o;
}
r.calculated_header = h.front();
o.push_back(std::move(r));
- o.push_back(rgw_cls_check_index_ret{});
+ o.emplace_back();
return o;
}
dec_s.total_size_rounded = 4096;
dec_s.num_entries = 1;
o.push_back(std::move(r));
- o.push_back(rgw_cls_bucket_update_stats_op{});
+ o.emplace_back();
return o;
}
list<cls_rgw_bi_log_list_op> cls_rgw_bi_log_list_op::generate_test_instances()
{
list<cls_rgw_bi_log_list_op> ls;
- ls.push_back(cls_rgw_bi_log_list_op{});
- ls.push_back(cls_rgw_bi_log_list_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().marker = "mark";
ls.back().max = 123;
return ls;
list<cls_rgw_bi_log_trim_op> cls_rgw_bi_log_trim_op::generate_test_instances()
{
list<cls_rgw_bi_log_trim_op> ls;
- ls.push_back(cls_rgw_bi_log_trim_op{});
- ls.push_back(cls_rgw_bi_log_trim_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().start_marker = "foo";
ls.back().end_marker = "bar";
return ls;
list<cls_rgw_bi_log_list_ret> cls_rgw_bi_log_list_ret::generate_test_instances()
{
list<cls_rgw_bi_log_list_ret> ls;
- ls.push_back(cls_rgw_bi_log_list_ret{});
- ls.push_back(cls_rgw_bi_log_list_ret{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().entries.push_back(rgw_bi_log_entry());
ls.back().truncated = true;
return ls;
std::list<cls_rgw_mp_upload_part_info_update_op> cls_rgw_mp_upload_part_info_update_op::generate_test_instances()
{
std::list<cls_rgw_mp_upload_part_info_update_op> ls;
- ls.push_back(cls_rgw_mp_upload_part_info_update_op{});
+ ls.emplace_back();
ls.back().part_key = "part1";
- ls.push_back(cls_rgw_mp_upload_part_info_update_op{});
+ ls.emplace_back();
ls.back().part_key = "part2";
return ls;
}
list<cls_rgw_reshard_add_op> cls_rgw_reshard_add_op::generate_test_instances()
{
list<cls_rgw_reshard_add_op> ls;
- ls.push_back(cls_rgw_reshard_add_op{});
- ls.push_back(cls_rgw_reshard_add_op{});
+ ls.emplace_back();
+ ls.emplace_back();
list<cls_rgw_reshard_entry> l = cls_rgw_reshard_entry::generate_test_instances();
auto iter = l.begin();
ls.back().entry = *iter;
list<cls_rgw_reshard_list_op> cls_rgw_reshard_list_op::generate_test_instances()
{
list<cls_rgw_reshard_list_op> ls;
- ls.push_back(cls_rgw_reshard_list_op{});
- ls.push_back(cls_rgw_reshard_list_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().max = 1000;
ls.back().marker = "foo";
return ls;
list<cls_rgw_reshard_list_ret> cls_rgw_reshard_list_ret::generate_test_instances()
{
list<cls_rgw_reshard_list_ret> ls;
- ls.push_back(cls_rgw_reshard_list_ret{});
- ls.push_back(cls_rgw_reshard_list_ret{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().entries.push_back(cls_rgw_reshard_entry());
ls.back().is_truncated = true;
return ls;
list<cls_rgw_reshard_get_op> cls_rgw_reshard_get_op::generate_test_instances()
{
list<cls_rgw_reshard_get_op> ls;
- ls.push_back(cls_rgw_reshard_get_op{});
- ls.push_back(cls_rgw_reshard_get_op{});
+ ls.emplace_back();
+ ls.emplace_back();
return ls;
}
list<cls_rgw_reshard_get_ret> cls_rgw_reshard_get_ret::generate_test_instances()
{
list<cls_rgw_reshard_get_ret> ls;
- ls.push_back(cls_rgw_reshard_get_ret{});
- ls.push_back(cls_rgw_reshard_get_ret{});
+ ls.emplace_back();
+ ls.emplace_back();
return ls;
}
list<cls_rgw_reshard_remove_op> cls_rgw_reshard_remove_op::generate_test_instances()
{
list<cls_rgw_reshard_remove_op> ls;
- ls.push_back(cls_rgw_reshard_remove_op{});
- ls.push_back(cls_rgw_reshard_remove_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().bucket_name = "foo";
ls.back().bucket_id = "bucket_id";
return ls;
list<cls_rgw_set_bucket_resharding_op> cls_rgw_set_bucket_resharding_op::generate_test_instances()
{
list<cls_rgw_set_bucket_resharding_op> ls;
- ls.push_back(cls_rgw_set_bucket_resharding_op{});
- ls.push_back(cls_rgw_set_bucket_resharding_op{});
+ ls.emplace_back();
+ ls.emplace_back();
return ls;
}
list<cls_rgw_clear_bucket_resharding_op> cls_rgw_clear_bucket_resharding_op::generate_test_instances()
{
list<cls_rgw_clear_bucket_resharding_op> ls;
- ls.push_back(cls_rgw_clear_bucket_resharding_op{});
- ls.push_back(cls_rgw_clear_bucket_resharding_op{});
+ ls.emplace_back();
+ ls.emplace_back();
return ls;
}
list<cls_rgw_guard_bucket_resharding_op> cls_rgw_guard_bucket_resharding_op::generate_test_instances()
{
list<cls_rgw_guard_bucket_resharding_op> ls;
- ls.push_back(cls_rgw_guard_bucket_resharding_op{});
- ls.push_back(cls_rgw_guard_bucket_resharding_op{});
+ ls.emplace_back();
+ ls.emplace_back();
return ls;
}
list<cls_rgw_get_bucket_resharding_op> cls_rgw_get_bucket_resharding_op::generate_test_instances()
{
list<cls_rgw_get_bucket_resharding_op> ls;
- ls.push_back(cls_rgw_get_bucket_resharding_op{});
- ls.push_back(cls_rgw_get_bucket_resharding_op{});
+ ls.emplace_back();
+ ls.emplace_back();
return ls;
}
static std::list<rgw_cls_obj_remove_op> generate_test_instances() {
std::list<rgw_cls_obj_remove_op> o;
- o.push_back(rgw_cls_obj_remove_op{});
+ o.emplace_back();
o.back().keep_attr_prefixes.push_back("keep_attr_prefixes1");
o.back().keep_attr_prefixes.push_back("keep_attr_prefixes2");
o.back().keep_attr_prefixes.push_back("keep_attr_prefixes3");
static std::list<rgw_cls_obj_store_pg_ver_op> generate_test_instances() {
std::list<rgw_cls_obj_store_pg_ver_op> o;
- o.push_back(rgw_cls_obj_store_pg_ver_op{});
+ o.emplace_back();
o.back().attr = "attr";
return o;
}
static std::list<rgw_cls_obj_check_attrs_prefix> generate_test_instances() {
std::list<rgw_cls_obj_check_attrs_prefix> o;
- o.push_back(rgw_cls_obj_check_attrs_prefix{});
+ o.emplace_back();
o.back().check_prefix = "prefix";
o.back().fail_if_exist = true;
return o;
static std::list<rgw_cls_usage_log_add_op> generate_test_instances() {
std::list<rgw_cls_usage_log_add_op> o;
- o.push_back(rgw_cls_usage_log_add_op{});
+ o.emplace_back();
return o;
}
};
static std::list<rgw_cls_bi_get_op> generate_test_instances() {
std::list<rgw_cls_bi_get_op> o;
- o.push_back(rgw_cls_bi_get_op{});
- o.push_back(rgw_cls_bi_get_op{});
+ o.emplace_back();
+ o.emplace_back();
o.back().key.name = "key";
o.back().key.instance = "instance";
o.back().type = BIIndexType::Plain;
static std::list<rgw_cls_bi_get_ret> generate_test_instances() {
std::list<rgw_cls_bi_get_ret> o;
- o.push_back(rgw_cls_bi_get_ret{});
+ o.emplace_back();
o.back().entry.idx = "entry";
return o;
}
static std::list<rgw_cls_bi_put_op> generate_test_instances() {
std::list<rgw_cls_bi_put_op> o;
- o.push_back(rgw_cls_bi_put_op{});
- o.push_back(rgw_cls_bi_put_op{});
+ o.emplace_back();
+ o.emplace_back();
o.back().entry.idx = "entry";
return o;
}
static std::list<rgw_cls_bi_put_entries_op> generate_test_instances() {
std::list<rgw_cls_bi_put_entries_op> o;
- o.push_back(rgw_cls_bi_put_entries_op{});
- o.push_back(rgw_cls_bi_put_entries_op{});
+ o.emplace_back();
+ o.emplace_back();
o.back().entries.push_back({.idx = "entry"});
o.back().check_existing = true;
return o;
static std::list<rgw_cls_bi_list_op> generate_test_instances() {
std::list<rgw_cls_bi_list_op> o;
- o.push_back(rgw_cls_bi_list_op{});
- o.push_back(rgw_cls_bi_list_op{});
+ o.emplace_back();
+ o.emplace_back();
o.back().max = 100;
o.back().name_filter = "name_filter";
o.back().marker = "marker";
static std::list<rgw_cls_bi_list_ret> generate_test_instances() {
std::list<rgw_cls_bi_list_ret> o;
- o.push_back(rgw_cls_bi_list_ret{});
- o.push_back(rgw_cls_bi_list_ret{});
+ o.emplace_back();
+ o.emplace_back();
o.back().entries.push_back(rgw_cls_bi_entry());
o.back().entries.push_back(rgw_cls_bi_entry());
o.back().entries.back().idx = "entry";
static std::list<rgw_cls_usage_log_read_op> generate_test_instances() {
std::list<rgw_cls_usage_log_read_op> o;
- o.push_back(rgw_cls_usage_log_read_op{});
+ o.emplace_back();
o.back().start_epoch = 1;
o.back().end_epoch = 2;
o.back().owner = "owner";
static std::list<rgw_cls_usage_log_read_ret> generate_test_instances() {
std::list<rgw_cls_usage_log_read_ret> o;
- o.push_back(rgw_cls_usage_log_read_ret{});
+ o.emplace_back();
o.back().next_iter = "123";
o.back().truncated = true;
o.back().usage.clear();
- o.push_back(rgw_cls_usage_log_read_ret{});
+ o.emplace_back();
o.back().usage[rgw_user_bucket("user1", "bucket1")] = rgw_usage_log_entry();
o.back().usage[rgw_user_bucket("user2", "bucket2")] = rgw_usage_log_entry();
o.back().truncated = true;
static std::list<cls_rgw_lc_set_entry_op> generate_test_instances() {
std::list<cls_rgw_lc_set_entry_op> ls;
- ls.push_back(cls_rgw_lc_set_entry_op{});
- ls.push_back(cls_rgw_lc_set_entry_op{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().entry.bucket = "foo";
ls.back().entry.start_time = 123;
ls.back().entry.status = 456;
list<rgw_zone_set> rgw_zone_set::generate_test_instances()
{
list<rgw_zone_set> o;
- o.push_back(rgw_zone_set{});
- o.push_back(rgw_zone_set{});
+ o.emplace_back();
+ o.emplace_back();
std::optional<string> loc_key = "loc_key";
o.back().insert("zone1", loc_key);
o.back().insert("zone2", loc_key);
i.state = CLS_RGW_STATE_COMPLETE;
i.op = CLS_RGW_OP_DEL;
o.push_back(std::move(i));
- o.push_back(rgw_bucket_pending_info{});
+ o.emplace_back();
return o;
}
m.owner_display_name = "display name";
m.content_type = "content/type";
o.push_back(std::move(m));
- o.push_back(rgw_bucket_dir_entry_meta{});
+ o.emplace_back();
return o;
}
o.push_back(std::move(e));
}
- o.push_back(rgw_bucket_dir_entry{});
+ o.emplace_back();
return o;
}
list<rgw_bucket_entry_ver> rgw_bucket_entry_ver::generate_test_instances()
{
list<rgw_bucket_entry_ver> ls;
- ls.push_back(rgw_bucket_entry_ver{});
- ls.push_back(rgw_bucket_entry_ver{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().pool = 123;
ls.back().epoch = 12322;
return ls;
m.idx = "idx";
encode(entry, m.data);
o.push_back(std::move(m));
- o.push_back(rgw_cls_bi_entry{});
+ o.emplace_back();
return o;
}
entry.exists = true;
entry.pending_removal = true;
o.push_back(std::move(entry));
- o.push_back(rgw_bucket_olh_entry{});
+ o.emplace_back();
return o;
}
entry.key.name = "key.name";
entry.key.instance = "key.instance";
o.push_back(std::move(entry));
- o.push_back(rgw_bucket_deleted_entry{});
+ o.emplace_back();
return o;
}
entry.key.instance = "key.instance";
entry.delete_marker = true;
o.push_back(std::move(entry));
- o.push_back(rgw_bucket_olh_log_entry{});
+ o.emplace_back();
return o;
}
list<rgw_bi_log_entry> rgw_bi_log_entry::generate_test_instances()
{
list<rgw_bi_log_entry> ls;
- ls.push_back(rgw_bi_log_entry{});
- ls.push_back(rgw_bi_log_entry{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().id = "midf";
ls.back().object = "obj";
ls.back().timestamp = ceph::real_clock::from_ceph_timespec({ceph_le32(2), ceph_le32(3)});
s.num_entries = 2;
s.actual_size = 1024;
o.push_back(std::move(s));
- o.push_back(rgw_bucket_category_stats{});
+ o.emplace_back();
return o;
}
o.push_back(std::move(h));
}
- o.push_back(rgw_bucket_dir_header{});
+ o.emplace_back();
return o;
}
o.push_back(std::move(d));
}
- o.push_back(rgw_bucket_dir{});
+ o.emplace_back();
return o;
}
s.bytes_processed = 1024;
s.bytes_returned = 512;
o.push_back(std::move(s));
- o.push_back(rgw_s3select_usage_data{});
+ o.emplace_back();
return o;
}
s.ops = 2;
s.successful_ops = 1;
o.push_back(std::move(s));
- o.push_back(rgw_usage_data{});
+ o.emplace_back();
return o;
}
rgw_usage_log_entry r(owner, payer, bucket);
s.entries.push_back(r);
o.push_back(std::move(s));
- o.push_back(rgw_usage_log_info{});
+ o.emplace_back();
return o;
}
s.user = "user";
s.bucket = "bucket";
o.push_back(std::move(s));
- o.push_back(rgw_user_bucket{});
+ o.emplace_back();
return o;
}
entry.usage_map["get_obj"] = usage_data;
entry.s3select_usage = s3select_usage_data;
o.push_back(std::move(entry));
- o.push_back(rgw_usage_log_entry{});
+ o.emplace_back();
return o;
}
list<cls_rgw_reshard_entry> cls_rgw_reshard_entry::generate_test_instances()
{
list<cls_rgw_reshard_entry> ls;
- ls.push_back(cls_rgw_reshard_entry{});
- ls.push_back(cls_rgw_reshard_entry{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().time = ceph::real_clock::from_ceph_timespec({ceph_le32(2), ceph_le32(3)});
ls.back().tenant = "tenant";
ls.back().bucket_name = "bucket1""";
list<cls_rgw_bucket_instance_entry> cls_rgw_bucket_instance_entry::generate_test_instances()
{
list<cls_rgw_bucket_instance_entry> ls;
- ls.push_back(cls_rgw_bucket_instance_entry{});
- ls.push_back(cls_rgw_bucket_instance_entry{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().reshard_status = RESHARD_STATUS::IN_PROGRESS;
return ls;
}
s.start_time = 10;
s.status = 1;
o.push_back(std::move(s));
- o.push_back(cls_rgw_lc_entry{});
+ o.emplace_back();
return o;
}
}
static std::list<cls_rgw_obj> generate_test_instances() {
std::list<cls_rgw_obj> ls;
- ls.push_back(cls_rgw_obj{});
- ls.push_back(cls_rgw_obj{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().pool = "mypool";
ls.back().key.name = "myoid";
ls.back().loc = "mykey";
}
static std::list<cls_rgw_obj_chain> generate_test_instances() {
std::list<cls_rgw_obj_chain> ls;
- ls.push_back(cls_rgw_obj_chain{});
+ ls.emplace_back();
return ls;
}
}
static std::list<cls_rgw_gc_obj_info> generate_test_instances() {
std::list<cls_rgw_gc_obj_info> ls;
- ls.push_back(cls_rgw_gc_obj_info{});
- ls.push_back(cls_rgw_gc_obj_info{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().tag = "footag";
ceph_timespec ts{ceph_le32(21), ceph_le32(32)};
ls.back().time = ceph::real_clock::from_ceph_timespec(ts);
static std::list<cls_rgw_gc_queue_init_op> generate_test_instances() {
std::list<cls_rgw_gc_queue_init_op> o;
- o.push_back(cls_rgw_gc_queue_init_op{});
+ o.emplace_back();
o.back().size = 1024;
o.back().num_deferred_entries = 512;
return o;
}
static std::list<cls_rgw_gc_urgent_data> generate_test_instances() {
std::list<cls_rgw_gc_urgent_data> o;
- o.push_back(cls_rgw_gc_urgent_data{});
- o.push_back(cls_rgw_gc_urgent_data{});
+ o.emplace_back();
+ o.emplace_back();
o.back().num_urgent_data_entries = 1024;
o.back().num_head_urgent_entries = 512;
o.back().num_xattr_urgent_entries = 512;
static std::list<cls_timeindex_list_op> generate_test_instances() {
std::list<cls_timeindex_list_op> o;
- o.push_back(cls_timeindex_list_op{});
- o.push_back(cls_timeindex_list_op{});
+ o.emplace_back();
+ o.emplace_back();
o.back().from_time = utime_t(1, 2);
o.back().marker = "marker";
o.back().to_time = utime_t(3, 4);
static std::list<cls_timeindex_list_ret> generate_test_instances() {
std::list<cls_timeindex_list_ret> o;
- o.push_back(cls_timeindex_list_ret{});
- o.push_back(cls_timeindex_list_ret{});
+ o.emplace_back();
+ o.emplace_back();
o.back().entries.push_back(cls_timeindex_entry());
o.back().entries.back().key_ts = utime_t(1, 2);
o.back().entries.back().key_ext = "key_ext";
bl.append("bar");
i.value = bl;
o.push_back(std::move(i));
- o.push_back(cls_timeindex_entry{});
+ o.emplace_back();
return o;
}
list<cls_user_set_buckets_op> cls_user_set_buckets_op::generate_test_instances()
{
list<cls_user_set_buckets_op> ls;
- ls.push_back(cls_user_set_buckets_op{});
+ ls.emplace_back();
cls_user_set_buckets_op op;
for (int i = 0; i < 3; i++) {
cls_user_bucket_entry e;
list<cls_user_remove_bucket_op> cls_user_remove_bucket_op::generate_test_instances()
{
list<cls_user_remove_bucket_op> ls;
- ls.push_back(cls_user_remove_bucket_op{});
+ ls.emplace_back();
cls_user_remove_bucket_op op;
cls_user_gen_test_bucket(&op.bucket, 0);
ls.push_back(std::move(op));
list<cls_user_list_buckets_op> cls_user_list_buckets_op::generate_test_instances()
{
list<cls_user_list_buckets_op> ls;
- ls.push_back(cls_user_list_buckets_op{});
+ ls.emplace_back();
cls_user_list_buckets_op op;;
op.marker = "marker";
op.max_entries = 1000;
list<cls_user_list_buckets_ret> cls_user_list_buckets_ret::generate_test_instances()
{
list<cls_user_list_buckets_ret> ls;
- ls.push_back(cls_user_list_buckets_ret{});
+ ls.emplace_back();
cls_user_list_buckets_ret ret;;
for (int i = 0; i < 3; i++) {
cls_user_bucket_entry e;
list<cls_user_get_header_op> cls_user_get_header_op::generate_test_instances()
{
list<cls_user_get_header_op> ls;
- ls.push_back(cls_user_get_header_op{});
+ ls.emplace_back();
return ls;
}
list<cls_user_get_header_ret> cls_user_get_header_ret::generate_test_instances()
{
list<cls_user_get_header_ret> ls;
- ls.push_back(cls_user_get_header_ret{});
+ ls.emplace_back();
cls_user_get_header_ret ret;
cls_user_gen_test_header(&ret.header);
ls.push_back(std::move(ret));
list<cls_user_complete_stats_sync_op> cls_user_complete_stats_sync_op::generate_test_instances()
{
list<cls_user_complete_stats_sync_op> ls;
- ls.push_back(cls_user_complete_stats_sync_op{});
+ ls.emplace_back();
cls_user_complete_stats_sync_op op;
op.time = utime_t(12345, 0).to_real_time();
ls.push_back(std::move(op));
std::list<cls_user_account_resource_add_op> cls_user_account_resource_add_op::generate_test_instances()
{
std::list<cls_user_account_resource_add_op> ls;
- ls.push_back(cls_user_account_resource_add_op{});
+ ls.emplace_back();
cls_user_account_resource_add_op op;
cls_user_gen_test_resource(op.entry);
ls.push_back(std::move(op));
std::list<cls_user_account_resource_get_op> cls_user_account_resource_get_op::generate_test_instances()
{
std::list<cls_user_account_resource_get_op> ls;
- ls.push_back(cls_user_account_resource_get_op{});
+ ls.emplace_back();
cls_user_account_resource_get_op op;
op.name = "name";
ls.push_back(std::move(op));
std::list<cls_user_account_resource_get_ret> cls_user_account_resource_get_ret::generate_test_instances()
{
std::list<cls_user_account_resource_get_ret> ls;
- ls.push_back(cls_user_account_resource_get_ret{});
+ ls.emplace_back();
cls_user_account_resource_get_ret ret;
cls_user_gen_test_resource(ret.entry);
ls.push_back(std::move(ret));
std::list<cls_user_account_resource_rm_op> cls_user_account_resource_rm_op::generate_test_instances()
{
std::list<cls_user_account_resource_rm_op> ls;
- ls.push_back(cls_user_account_resource_rm_op{});
+ ls.emplace_back();
cls_user_account_resource_rm_op op;
op.name = "name";
ls.push_back(std::move(op));
std::list<cls_user_account_resource_list_op> cls_user_account_resource_list_op::generate_test_instances()
{
std::list<cls_user_account_resource_list_op> ls;
- ls.push_back(cls_user_account_resource_list_op{});
+ ls.emplace_back();
cls_user_account_resource_list_op op;
op.marker = "marker";
op.path_prefix = "path";
std::list<cls_user_account_resource_list_ret> cls_user_account_resource_list_ret::generate_test_instances()
{
std::list<cls_user_account_resource_list_ret> ls;
- ls.push_back(cls_user_account_resource_list_ret{});
+ ls.emplace_back();
cls_user_account_resource_list_ret ret;
cls_user_gen_test_resource(ret.entries.emplace_back());
ret.truncated = true;
list<cls_user_bucket> cls_user_bucket::generate_test_instances()
{
list<cls_user_bucket> ls;
- ls.push_back(cls_user_bucket{});
+ ls.emplace_back();
cls_user_bucket b;
cls_user_gen_test_bucket(&b, 0);
ls.push_back(std::move(b));
list<cls_user_bucket_entry> cls_user_bucket_entry::generate_test_instances()
{
list<cls_user_bucket_entry> ls;
- ls.push_back(cls_user_bucket_entry{});
+ ls.emplace_back();
cls_user_bucket_entry entry;
cls_user_gen_test_bucket_entry(&entry, 0);
ls.push_back(std::move(entry));
list<cls_user_stats> cls_user_stats::generate_test_instances()
{
list<cls_user_stats> ls;
- ls.push_back(cls_user_stats{});
+ ls.emplace_back();
cls_user_stats s;
cls_user_gen_test_stats(&s);
ls.push_back(std::move(s));
list<cls_user_header> cls_user_header::generate_test_instances()
{
list<cls_user_header> ls;
- ls.push_back(cls_user_header{});
+ ls.emplace_back();
cls_user_header h;
cls_user_gen_test_header(&h);
ls.push_back(std::move(h));
std::list<cls_user_account_header> cls_user_account_header::generate_test_instances()
{
std::list<cls_user_account_header> ls;
- ls.push_back(cls_user_account_header{});
+ ls.emplace_back();
return ls;
}
std::list<cls_user_account_resource> cls_user_account_resource::generate_test_instances()
{
std::list<cls_user_account_resource> ls;
- ls.push_back(cls_user_account_resource{});
+ ls.emplace_back();
cls_user_account_resource p;
cls_user_gen_test_resource(p);
ls.push_back(std::move(p));
static std::list<cls_version_set_op> generate_test_instances() {
std::list<cls_version_set_op> o;
- o.push_back(cls_version_set_op{});
- o.push_back(cls_version_set_op{});
+ o.emplace_back();
+ o.emplace_back();
o.back().objv.ver = 123;
o.back().objv.tag = "foo";
return o;
static std::list<cls_version_inc_op> generate_test_instances() {
std::list<cls_version_inc_op> o;
- o.push_back(cls_version_inc_op{});
- o.push_back(cls_version_inc_op{});
+ o.emplace_back();
+ o.emplace_back();
o.back().objv.ver = 123;
o.back().objv.tag = "foo";
o.back().conds.push_back(obj_version_cond());
static std::list<cls_version_check_op> generate_test_instances() {
std::list<cls_version_check_op> o;
- o.push_back(cls_version_check_op{});
- o.push_back(cls_version_check_op{});
+ o.emplace_back();
+ o.emplace_back();
o.back().objv.ver = 123;
o.back().objv.tag = "foo";
o.back().conds.push_back(obj_version_cond());
static std::list<cls_version_read_ret> generate_test_instances() {
std::list<cls_version_read_ret> o;
- o.push_back(cls_version_read_ret{});
- o.push_back(cls_version_read_ret{});
+ o.emplace_back();
+ o.emplace_back();
o.back().objv.ver = 123;
o.back().objv.tag = "foo";
return o;
static std::list<obj_version_cond> generate_test_instances() {
std::list<obj_version_cond> o;
- o.push_back(obj_version_cond{});
- o.push_back(obj_version_cond{});
+ o.emplace_back();
+ o.emplace_back();
o.back().ver.ver = 1;
o.back().ver.tag = "foo";
o.back().cond = VER_COND_EQ;
std::list<CompatSet> CompatSet::generate_test_instances() {
std::list<CompatSet> o;
- o.push_back(CompatSet{});
- o.push_back(CompatSet{});
+ o.emplace_back();
+ o.emplace_back();
o.back().compat.insert(Feature(1, "one"));
o.back().compat.insert(Feature(2, "two"));
o.back().ro_compat.insert(Feature(4, "four"));
list<LogEntryKey> LogEntryKey::generate_test_instances()
{
list<LogEntryKey> o;
- o.push_back(LogEntryKey{});
+ o.emplace_back();
o.push_back(LogEntryKey(entity_name_t::CLIENT(1234), utime_t(1,2), 34));
return o;
}
list<LogEntry> LogEntry::generate_test_instances()
{
list<LogEntry> o;
- o.push_back(LogEntry{});
+ o.emplace_back();
return o;
}
list<LogSummary> LogSummary::generate_test_instances()
{
list<LogSummary> o;
- o.push_back(LogSummary{});
+ o.emplace_back();
// more!
return o;
}
list<SloppyCRCMap> SloppyCRCMap::generate_test_instances()
{
list<SloppyCRCMap> ls;
- ls.push_back(SloppyCRCMap{});
+ ls.emplace_back();
ls.push_back(SloppyCRCMap(2));
bufferlist bl;
bl.append("some data");
auto BitVector<_b>::generate_test_instances() -> std::list<BitVector> {
std::list<BitVector> o;
- o.push_back(BitVector{});
+ o.emplace_back();
BitVector b;
const uint64_t radix = 1 << b.BIT_COUNT;
}
static std::list<JSONFormattable> generate_test_instances() {
std::list<JSONFormattable> o;
- o.push_back(JSONFormattable{});
- o.push_back(JSONFormattable{});
+ o.emplace_back();
+ o.emplace_back();
o.back().set_type(FMT_VALUE);
o.back().value.str = "foo";
o.back().value.quoted = true;
- o.push_back(JSONFormattable{});
+ o.emplace_back();
o.back().set_type(FMT_VALUE);
o.back().value.str = "foo";
o.back().value.quoted = false;
- o.push_back(JSONFormattable{});
+ o.emplace_back();
o.back().set_type(FMT_ARRAY);
o.back().arr.push_back(JSONFormattable());
o.back().arr.back().set_type(FMT_VALUE);
o.back().arr.back().set_type(FMT_VALUE);
o.back().arr.back().value.str = "bar";
o.back().arr.back().value.quoted = true;
- o.push_back(JSONFormattable{});
+ o.emplace_back();
o.back().set_type(FMT_OBJ);
o.back().obj["foo"] = JSONFormattable();
o.back().obj["foo"].set_type(FMT_VALUE);
std::list<EntityName> EntityName::generate_test_instances() {
std::list<EntityName> ls;
- ls.push_back(EntityName{});
- ls.push_back(EntityName{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().set_type(CEPH_ENTITY_TYPE_OSD);
ls.back().set_id("0");
- ls.push_back(EntityName{});
+ ls.emplace_back();
ls.back().set_type(CEPH_ENTITY_TYPE_MDS);
ls.back().set_id("a");
return ls;
std::list<frag_t> frag_t::generate_test_instances() {
std::list<frag_t> ls;
- ls.push_back(frag_t{});
+ ls.emplace_back();
ls.push_back(frag_t(10, 2));
ls.push_back(frag_t(11, 3));
return ls;
std::list<fragtree_t> fragtree_t::generate_test_instances() {
std::list<fragtree_t> ls;
- ls.push_back(fragtree_t{});
- ls.push_back(fragtree_t{});
+ ls.emplace_back();
+ ls.emplace_back();
return ls;
}
std::list<file_layout_t> file_layout_t::generate_test_instances()
{
std::list<file_layout_t> o;
- o.push_back(file_layout_t{});
- o.push_back(file_layout_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().stripe_unit = 4096;
o.back().stripe_count = 16;
o.back().object_size = 1048576;
std::list<pow2_hist_t> pow2_hist_t::generate_test_instances()
{
std::list<pow2_hist_t> ls;
- ls.push_back(pow2_hist_t{});
- ls.push_back(pow2_hist_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().h.push_back(1);
ls.back().h.push_back(3);
ls.back().h.push_back(0);
list<hobject_t> hobject_t::generate_test_instances()
{
list<hobject_t> o;
- o.push_back(hobject_t{});
- o.push_back(hobject_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().max = true;
o.push_back(hobject_t(object_t("oname"), string(), 1, 234, -1, ""));
o.push_back(hobject_t(object_t("oname2"), string("okey"), CEPH_NOSNAP,
list<ghobject_t> ghobject_t::generate_test_instances()
{
list<ghobject_t> o;
- o.push_back(ghobject_t{});
- o.push_back(ghobject_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().hobj.max = true;
o.push_back(ghobject_t(hobject_t(object_t("oname"), string(), 1, 234, -1, "")));
std::list<SnapRealmInfo> SnapRealmInfo::generate_test_instances()
{
std::list<SnapRealmInfo> o;
- o.push_back(SnapRealmInfo{});
+ o.emplace_back();
o.push_back(SnapRealmInfo(1, 10, 10, 0));
o.push_back(SnapRealmInfo(1, 10, 10, 0));
o.back().my_snaps.push_back(10);
std::list<SnapRealmInfoNew> SnapRealmInfoNew::generate_test_instances()
{
std::list<SnapRealmInfoNew> o;
- o.push_back(SnapRealmInfoNew{});
+ o.emplace_back();
o.push_back(SnapRealmInfoNew(SnapRealmInfo(1, 10, 10, 0), utime_t(), 0));
o.push_back(SnapRealmInfoNew(SnapRealmInfo(1, 10, 10, 0), utime_t(), 1));
o.back().info.my_snaps.push_back(10);
std::list<SnapContext> SnapContext::generate_test_instances()
{
std::list<SnapContext> o;
- o.push_back(SnapContext{});
+ o.emplace_back();
std::vector<snapid_t> v;
o.push_back(SnapContext(10, v));
v.push_back(18);
void dump(ceph::Formatter *f) const;
static std::list<vinodeno_t> generate_test_instances() {
std::list<vinodeno_t> ls;
- ls.push_back(vinodeno_t{});
+ ls.emplace_back();
ls.push_back(vinodeno_t(1, 2));
return ls;
}
auto inode_t<Allocator>::generate_test_instances() -> std::list<inode_t>
{
std::list<inode_t> ls;
- ls.push_back(inode_t<Allocator>{});
- ls.push_back(inode_t<Allocator>{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().ino = 1;
// i am lazy.
return ls;
std::list<filepath> filepath::generate_test_instances() {
std::list<filepath> o;
- o.push_back(filepath{});
+ o.emplace_back();
o.push_back(filepath("/usr/bin", 0));
o.push_back(filepath("/usr/sbin", 1));
o.push_back(filepath("var/log", 1));
std::list<object_t> object_t::generate_test_instances() {
std::list<object_t> o;
- o.push_back(object_t{});
+ o.emplace_back();
o.push_back(object_t{"myobject"});
return o;
}
std::list<sobject_t> sobject_t::generate_test_instances() {
std::list<sobject_t> o;
- o.push_back(sobject_t{});
+ o.emplace_back();
o.push_back(sobject_t{object_t("myobject"), 123});
return o;
}
std::list<client_t> client_t::generate_test_instances() {
std::list<client_t> ls;
- ls.push_back(client_t{});
+ ls.emplace_back();
ls.push_back(client_t(1));
ls.push_back(client_t(123));
return ls;
}
static std::list<sha_digest_t> generate_test_instances() {
std::list<sha_digest_t> ls;
- ls.push_back(sha_digest_t{});
- ls.push_back(sha_digest_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().v[0] = 1;
- ls.push_back(sha_digest_t{});
+ ls.emplace_back();
ls.back().v[0] = 2;
return ls;
}
static std::list<ceph_data_stats> generate_test_instances() {
std::list<ceph_data_stats> ls;
- ls.push_back(ceph_data_stats{});
- ls.push_back(ceph_data_stats{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().byte_total = 1024*1024;
ls.back().byte_used = 512*1024;
ls.back().byte_avail = 512*1024;
std::list<Anchor> Anchor::generate_test_instances()
{
std::list<Anchor> ls;
- ls.push_back(Anchor{});
- ls.push_back(Anchor{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().ino = 1;
ls.back().dirino = 2;
ls.back().d_name = "hello";
std::list<Capability::revoke_info> Capability::revoke_info::generate_test_instances()
{
std::list<Capability::revoke_info> ls;
- ls.push_back(revoke_info{});
- ls.push_back(revoke_info{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().before = 1;
ls.back().seq = 2;
ls.back().last_issue = 3;
std::list<inode_backpointer_t> inode_backpointer_t::generate_test_instances()
{
std::list<inode_backpointer_t> ls;
- ls.push_back(inode_backpointer_t{});
- ls.push_back(inode_backpointer_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().dirino = 1;
ls.back().dname = "foo";
ls.back().version = 123;
std::list<inode_backtrace_t> inode_backtrace_t::generate_test_instances()
{
std::list<inode_backtrace_t> ls;
- ls.push_back(inode_backtrace_t{});
- ls.push_back(inode_backtrace_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().ino = 1;
ls.back().ancestors.push_back(inode_backpointer_t());
ls.back().ancestors.back().dirino = 123;
std::list<frag_info_t> frag_info_t::generate_test_instances()
{
std::list<frag_info_t> ls;
- ls.push_back(frag_info_t{});
- ls.push_back(frag_info_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().version = 1;
ls.back().mtime = utime_t(2, 3);
ls.back().nfiles = 4;
std::list<nest_info_t> nest_info_t::generate_test_instances()
{
std::list<nest_info_t> ls;
- ls.push_back(nest_info_t{});
- ls.push_back(nest_info_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().version = 1;
ls.back().rbytes = 2;
ls.back().rfiles = 3;
std::list<quota_info_t> quota_info_t::generate_test_instances()
{
std::list<quota_info_t> ls;
- ls.push_back(quota_info_t{});
- ls.push_back(quota_info_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().max_bytes = 16;
ls.back().max_files = 16;
return ls;
std::list<client_writeable_range_t> client_writeable_range_t::generate_test_instances()
{
std::list<client_writeable_range_t> ls;
- ls.push_back(client_writeable_range_t{});
- ls.push_back(client_writeable_range_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().range.first = 123;
ls.back().range.last = 456;
ls.back().follows = 12;
std::list<inline_data_t> inline_data_t::generate_test_instances()
{
std::list<inline_data_t> ls;
- ls.push_back(inline_data_t{});
- ls.push_back(inline_data_t{});
+ ls.emplace_back();
+ ls.emplace_back();
bufferlist bl;
bl.append("inline data");
ls.back().set_data(bl);
std::list<fnode_t> fnode_t::generate_test_instances()
{
std::list<fnode_t> ls;
- ls.push_back(fnode_t{});
- ls.push_back(fnode_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().version = 1;
ls.back().snap_purged_thru = 2;
list<frag_info_t> fls = frag_info_t::generate_test_instances();
std::list<session_info_t> session_info_t::generate_test_instances()
{
std::list<session_info_t>ls;
- ls.push_back(session_info_t{});
- ls.push_back(session_info_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().inst = entity_inst_t(entity_name_t::MDS(12), entity_addr_t());
ls.back().completed_requests.insert(make_pair(234, inodeno_t(111222)));
ls.back().completed_requests.insert(make_pair(237, inodeno_t(222333)));
std::list<string_snap_t> string_snap_t::generate_test_instances()
{
std::list<string_snap_t> ls;
- ls.push_back(string_snap_t{});
- ls.push_back(string_snap_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().name = "foo";
ls.back().snapid = 123;
- ls.push_back(string_snap_t{});
+ ls.emplace_back();
ls.back().name = "bar";
ls.back().snapid = 456;
return ls;
std::list<MDSCacheObjectInfo> MDSCacheObjectInfo::generate_test_instances()
{
std::list<MDSCacheObjectInfo> ls;
- ls.push_back(MDSCacheObjectInfo{});
- ls.push_back(MDSCacheObjectInfo{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().ino = 1;
ls.back().dirfrag = dirfrag_t(2, 3);
ls.back().dname = "fooname";
ls.back().snapid = CEPH_NOSNAP;
- ls.push_back(MDSCacheObjectInfo{});
+ ls.emplace_back();
ls.back().ino = 121;
ls.back().dirfrag = dirfrag_t(222, 0);
ls.back().dname = "bar foo";
std::list<mds_table_pending_t> mds_table_pending_t::generate_test_instances()
{
std::list<mds_table_pending_t> ls;
- ls.push_back(mds_table_pending_t{});
- ls.push_back(mds_table_pending_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().reqid = 234;
ls.back().mds = 2;
ls.back().tid = 35434;
std::list<metareqid_t> metareqid_t::generate_test_instances() {
std::list<metareqid_t> ls;
- ls.push_back(metareqid_t{});
+ ls.emplace_back();
ls.push_back(metareqid_t(entity_name_t::CLIENT(123), 456));
return ls;
}
std::list<dirfrag_t> dirfrag_t::generate_test_instances() {
std::list<dirfrag_t> ls;
- ls.push_back(dirfrag_t{});
+ ls.emplace_back();
ls.push_back(dirfrag_t(1, frag_t()));
ls.push_back(dirfrag_t(2, frag_t(3)));
return ls;
std::list<cap_reconnect_t> cap_reconnect_t::generate_test_instances()
{
std::list<cap_reconnect_t> ls;
- ls.push_back(cap_reconnect_t{});
+ ls.emplace_back();
ls.back().path = "/test/path";
ls.back().capinfo.cap_id = 1;
return ls;
std::list<snaprealm_reconnect_t> snaprealm_reconnect_t::generate_test_instances()
{
std::list<snaprealm_reconnect_t> ls;
- ls.push_back(snaprealm_reconnect_t{});
+ ls.emplace_back();
ls.back().realm.ino = 0x10000000001ULL;
ls.back().realm.seq = 2;
ls.back().realm.parent = 1;
auto old_inode_t<Allocator>::generate_test_instances() -> std::list<old_inode_t<Allocator>>
{
std::list<old_inode_t<Allocator>> ls;
- ls.push_back(old_inode_t<Allocator>{});
- ls.push_back(old_inode_t<Allocator>{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().first = 2;
std::list<inode_t<Allocator>> ils = inode_t<Allocator>::generate_test_instances();
ls.back().inode = ils.back();
std::list<SnapInfo> SnapInfo::generate_test_instances()
{
std::list<SnapInfo> ls;
- ls.push_back(SnapInfo{});
- ls.push_back(SnapInfo{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().snapid = 1;
ls.back().ino = 2;
ls.back().stamp = utime_t(3, 4);
std::list<snaplink_t> snaplink_t::generate_test_instances()
{
std::list<snaplink_t> ls;
- ls.push_back(snaplink_t{});
- ls.push_back(snaplink_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().ino = 2;
ls.back().first = 123;
return ls;
std::list<sr_t> sr_t::generate_test_instances()
{
std::list<sr_t> ls;
- ls.push_back(sr_t{});
- ls.push_back(sr_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().seq = 1;
ls.back().created = 2;
ls.back().last_created = 3;
}
static std::list<openc_response_t> generate_test_instances() {
std::list<openc_response_t> ls;
- ls.push_back(openc_response_t{});
- ls.push_back(openc_response_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().created_ino = 1;
ls.back().delegated_inos.insert(1, 10);
return ls;
}
static std::list<SnapPayload> generate_test_instances() {
std::list<SnapPayload> o;
- o.push_back(SnapPayload{});
- o.push_back(SnapPayload{});
+ o.emplace_back();
+ o.emplace_back();
o.back().metadata["key1"] = "val1";
o.back().metadata["key2"] = "val2";
return o;
static std::list<Release> generate_test_instances() {
std::list<Release> ls;
- ls.push_back(Release{});
- ls.push_back(Release{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().item.dname_len = 4;
ls.back().dname = "test";
return ls;
static std::list<MDSHealth> generate_test_instances() {
std::list<MDSHealth> ls;
- ls.push_back(MDSHealth{});
- ls.push_back(MDSHealth{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().metrics.push_back(MDSHealthMetric(MDS_HEALTH_TRIM, HEALTH_WARN,
"MDS is behind on trimming"));
return ls;
}
static std::list<inode_strong> generate_test_instances() {
std::list<inode_strong> ls;
- ls.push_back(inode_strong{});
+ ls.emplace_back();
ls.push_back(inode_strong(1, 2, 3, 4, 5));
return ls;
}
}
static std::list<dirfrag_strong> generate_test_instances() {
std::list<dirfrag_strong> ls;
- ls.push_back(dirfrag_strong{});
+ ls.emplace_back();
ls.push_back(dirfrag_strong(1, 2));
return ls;
}
}
static std::list<dn_strong> generate_test_instances() {
std::list<dn_strong> ls;
- ls.push_back(dn_strong{});
+ ls.emplace_back();
ls.push_back(dn_strong(1, "alternate_name", 2, 3, 4, 5, 6));
return ls;
}
}
static std::list<dn_strong_new> generate_test_instances() {
std::list<dn_strong_new> ls;
- ls.push_back(dn_strong_new{});
+ ls.emplace_back();
ls.push_back(dn_strong_new(1, "alternate_name", 2, 3, 4, 5, 6, 7));
return ls;
}
static std::list<PerfCounterType> generate_test_instances()
{
std::list<PerfCounterType> ls;
- ls.push_back(PerfCounterType{});
- ls.push_back(PerfCounterType{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().path = "mycounter";
ls.back().description = "mycounter description";
ls.back().nick = "mycounter nick";
}
static std::list<MDSPerfMetricReport> generate_test_instances() {
std::list<MDSPerfMetricReport> o;
- o.push_back(MDSPerfMetricReport{});
- o.push_back(MDSPerfMetricReport{});
+ o.emplace_back();
+ o.emplace_back();
o.back().reports.emplace(MDSPerfMetricQuery(), MDSPerfMetrics());
o.back().rank_metrics_delayed.insert(1);
return o;
}
static std::list<MDSConfigPayload> generate_test_instances() {
std::list<MDSConfigPayload> ls;
- ls.push_back(MDSConfigPayload{});
+ ls.emplace_back();
return ls;
}
};
std::list<MgrCap> MgrCap::generate_test_instances() {
std::list<MgrCap> ls;
- ls.push_back(MgrCap{});
- ls.push_back(MgrCap{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().parse("allow *");
- ls.push_back(MgrCap{});
+ ls.emplace_back();
ls.back().parse("allow rwx");
- ls.push_back(MgrCap{});
+ ls.emplace_back();
ls.back().parse("allow service foo x");
- ls.push_back(MgrCap{});
+ ls.emplace_back();
ls.back().parse("allow command bar x");
- ls.push_back(MgrCap{});
+ ls.emplace_back();
ls.back().parse("allow service foo r, allow command bar x");
- ls.push_back(MgrCap{});
+ ls.emplace_back();
ls.back().parse("allow command bar with k1=v1 x");
- ls.push_back(MgrCap{});
+ ls.emplace_back();
ls.back().parse("allow command bar with k1=v1 k2=v2 x");
- ls.push_back(MgrCap{});
+ ls.emplace_back();
ls.back().parse("allow module bar with k1=v1 k2=v2 x");
- ls.push_back(MgrCap{});
+ ls.emplace_back();
ls.back().parse("profile rbd pool=rbd");
return ls;
}
static std::list<OSDPerfMetricReport> generate_test_instances() {
std::list<OSDPerfMetricReport> o;
- o.push_back(OSDPerfMetricReport{});
- o.push_back(OSDPerfMetricReport{});
+ o.emplace_back();
+ o.emplace_back();
o.back().performance_counter_descriptors.push_back(
PerformanceCounterDescriptor(PerformanceCounterType::OPS));
o.back().performance_counter_descriptors.push_back(
auto ServiceMap::Daemon::generate_test_instances() -> std::list<Daemon>
{
std::list<Daemon> ls;
- ls.push_back(Daemon{});
- ls.push_back(Daemon{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().gid = 222;
ls.back().metadata["this"] = "that";
ls.back().task_status["task1"] = "running";
auto ServiceMap::Service::generate_test_instances() -> std::list<Service>
{
std::list<Service> ls;
- ls.push_back(Service{});
- ls.push_back(Service{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().daemons["one"].gid = 1;
ls.back().daemons["two"].gid = 2;
return ls;
std::list<ServiceMap> ServiceMap::generate_test_instances()
{
std::list<ServiceMap> ls;
- ls.push_back(ServiceMap{});
- ls.push_back(ServiceMap{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().epoch = 123;
ls.back().services["rgw"].daemons["one"].gid = 123;
ls.back().services["rgw"].daemons["two"].gid = 344;
}
static std::list<Incremental> generate_test_instances() {
std::list<Incremental> ls;
- ls.push_back(Incremental{});
- ls.push_back(Incremental{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().inc_type = GLOBAL_ID;
ls.back().max_global_id = 1234;
- ls.push_back(Incremental{});
+ ls.emplace_back();
ls.back().inc_type = AUTH_DATA;
ls.back().auth_type = 12;
ls.back().auth_data.append("foo");
std::list<ConnectionReport> ConnectionReport::generate_test_instances()
{
std::list<ConnectionReport> o;
- o.push_back(ConnectionReport{});
- o.push_back(ConnectionReport{});
+ o.emplace_back();
+ o.emplace_back();
o.back().rank = 1;
o.back().epoch = 2;
o.back().epoch_version = 3;
std::list<ConnectionTracker> ConnectionTracker::generate_test_instances()
{
std::list<ConnectionTracker> o;
- o.push_back(ConnectionTracker{});
- o.push_back(ConnectionTracker{});
+ o.emplace_back();
+ o.emplace_back();
ConnectionTracker& e = o.back();
e.rank = 2;
e.epoch = 3;
}
static std::list<pg_create_info> generate_test_instances() {
std::list<pg_create_info> o;
- o.push_back(pg_create_info{});
+ o.emplace_back();
o.back().create_epoch = 10;
- o.push_back(pg_create_info{});
+ o.emplace_back();
o.back().create_epoch = 1;
o.back().create_stamp = utime_t(2, 3);
o.back().up = {1, 2, 3};
static std::list<ModuleOption> generate_test_instances()
{
std::list<ModuleOption> ls;
- ls.push_back(ModuleOption{});
- ls.push_back(ModuleOption{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().name = "name";
ls.back().type = Option::TYPE_STR;
ls.back().level = Option::LEVEL_ADVANCED;
static std::list<ModuleInfo> generate_test_instances()
{
std::list<ModuleInfo> ls;
- ls.push_back(ModuleInfo{});
- ls.push_back(ModuleInfo{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().name = "name";
ls.back().can_run = true;
ls.back().error_string = "error_string";
static std::list<MgrMap> generate_test_instances()
{
std::list<MgrMap> l;
- l.push_back(MgrMap{});
+ l.emplace_back();
return l;
}
list<MonCap> MonCap::generate_test_instances()
{
list<MonCap> ls;
- ls.push_back(MonCap{});
- ls.push_back(MonCap{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().parse("allow *");
- ls.push_back(MonCap{});
+ ls.emplace_back();
ls.back().parse("allow rwx");
- ls.push_back(MonCap{});
+ ls.emplace_back();
ls.back().parse("allow service foo x");
- ls.push_back(MonCap{});
+ ls.emplace_back();
ls.back().parse("allow command bar x");
- ls.push_back(MonCap{});
+ ls.emplace_back();
ls.back().parse("allow service foo r, allow command bar x");
- ls.push_back(MonCap{});
+ ls.emplace_back();
ls.back().parse("allow command bar with k1=v1 x");
- ls.push_back(MonCap{});
+ ls.emplace_back();
ls.back().parse("allow command bar with k1=v1 k2=v2 x");
return ls;
}
static std::list<MonCommand> generate_test_instances() {
std::list<MonCommand> ls;
- ls.push_back(MonCommand{});
- ls.push_back(MonCommand{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().cmdstring = "foo";
ls.back().helpstring = "bar";
ls.back().module = "baz";
list<mon_info_t> mon_info_t::generate_test_instances()
{
list<mon_info_t> ls;
- ls.push_back(mon_info_t{});
- ls.push_back(mon_info_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().name = "noname";
ls.back().public_addrs.parse("v1:1.2.3.4:567/890");
ls.back().priority = 1;
list<MonMap> MonMap::generate_test_instances()
{
list<MonMap> o;
- o.push_back(MonMap{});
- o.push_back(MonMap{});
+ o.emplace_back();
+ o.emplace_back();
o.back().epoch = 1;
o.back().last_changed = utime_t(123, 456);
o.back().created = utime_t(789, 101112);
static std::list<Op> generate_test_instances() {
std::list<Op> ls;
- ls.push_back(Op{});
+ ls.emplace_back();
// we get coverage here from the Transaction instances
return ls;
}
static std::list<Transaction> generate_test_instances() {
std::list<Transaction> ls;
- ls.push_back(Transaction{});
- ls.push_back(Transaction{});
+ ls.emplace_back();
+ ls.emplace_back();
ceph::buffer::list bl;
bl.append("value");
ls.back().put("prefix", "key", bl);
list<PGMapDigest> PGMapDigest::generate_test_instances()
{
list<PGMapDigest> ls;
- ls.push_back(PGMapDigest{});
+ ls.emplace_back();
return ls;
}
list<PGMap::Incremental> PGMap::Incremental::generate_test_instances()
{
list<PGMap::Incremental> o;
- o.push_back(Incremental{});
- o.push_back(Incremental{});
+ o.emplace_back();
+ o.emplace_back();
o.back().version = 1;
o.back().stamp = utime_t(123,345);
- o.push_back(Incremental{});
+ o.emplace_back();
o.back().version = 2;
o.back().pg_stat_updates[pg_t(1,2)] = pg_stat_t();
o.back().osd_stat_updates[5] = osd_stat_t();
- o.push_back(Incremental{});
+ o.emplace_back();
o.back().version = 3;
o.back().osdmap_epoch = 1;
o.back().pg_scan = 2;
list<PGMap> PGMap::generate_test_instances()
{
list<PGMap> o;
- o.push_back(PGMap{});
+ o.emplace_back();
list<Incremental> inc = Incremental::generate_test_instances();
inc.pop_front();
while (!inc.empty()) {
}
static std::list<pg_count> generate_test_instances() {
std::list<pg_count> o;
- o.push_back(pg_count{});
- o.push_back(pg_count{});
+ o.emplace_back();
+ o.emplace_back();
o.back().acting = 1;
o.back().up_not_acting = 2;
o.back().primary = 3;
static std::list<health_check_t> generate_test_instances() {
std::list<health_check_t> ls;
- ls.push_back(health_check_t{});
+ ls.emplace_back();
ls.back().severity = HEALTH_WARN;
- ls.push_back(health_check_t{});
+ ls.emplace_back();
ls.back().severity = HEALTH_ERR;
ls.back().summary = "summarization";
ls.back().detail = {"one", "two", "three"};
static std::list<health_mute_t> generate_test_instances() {
std::list<health_mute_t> ls;
- ls.push_back(health_mute_t{});
- ls.push_back(health_mute_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().code = "OSD_DOWN";
ls.back().ttl = utime_t(1, 2);
ls.back().sticky = true;
static std::list<health_check_map_t> generate_test_instances() {
std::list<health_check_map_t> ls;
- ls.push_back(health_check_map_t{});
- ls.push_back(health_check_map_t{});
+ ls.emplace_back();
+ ls.emplace_back();
{
auto& d = ls.back().add("FOO", HEALTH_WARN, "foo", 2);
d.detail.push_back("a");
static std::list<FeatureMap> generate_test_instances() {
std::list<FeatureMap> ls;
- ls.push_back(FeatureMap{});
- ls.push_back(FeatureMap{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().add(CEPH_ENTITY_TYPE_OSD, CEPH_FEATURE_UID);
ls.back().add(CEPH_ENTITY_TYPE_OSD, CEPH_FEATURE_NOSRCADDR);
ls.back().add(CEPH_ENTITY_TYPE_OSD, CEPH_FEATURE_PGID64);
static std::list<MonitorDBStoreStats> generate_test_instances() {
std::list<MonitorDBStoreStats> ls;
- ls.push_back(MonitorDBStoreStats{});
- ls.push_back(MonitorDBStoreStats{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().bytes_total = 1024*1024;
ls.back().bytes_sst = 512*1024;
ls.back().bytes_log = 256*1024;
}
static std::list<DataStats> generate_test_instances() {
std::list<DataStats> ls;
- ls.push_back(DataStats{});
- ls.push_back(DataStats{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().fs_stats.byte_total = 1024*1024;
ls.back().fs_stats.byte_used = 512*1024;
ls.back().fs_stats.byte_avail = 256*1024;
}
static std::list<ScrubResult> generate_test_instances() {
std::list<ScrubResult> ls;
- ls.push_back(ScrubResult{});
- ls.push_back(ScrubResult{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().prefix_crc["foo"] = 123;
ls.back().prefix_keys["bar"] = 456;
return ls;
static std::list<mon_feature_t> generate_test_instances() {
std::list<mon_feature_t> ls;
- ls.push_back(mon_feature_t{});
- ls.push_back(mon_feature_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().features = 1;
- ls.push_back(mon_feature_t{});
+ ls.emplace_back();
ls.back().features = 2;
return ls;
}
}
static std::list<ProgressEvent> generate_test_instances() {
std::list<ProgressEvent> o;
- o.push_back(ProgressEvent{});
- o.push_back(ProgressEvent{});
+ o.emplace_back();
+ o.emplace_back();
o.back().message = "test message";
o.back().progress = 0.5;
o.back().add_to_ceph_s = true;
static std::list<PoolAvailability> generate_test_instances() {
std::list<PoolAvailability> o;
- o.push_back(PoolAvailability{});
+ o.emplace_back();
o.back().started_at = utime_t(123, 456);
o.back().last_uptime = utime_t(123, 456);
o.back().last_downtime = utime_t(123, 456);
- o.push_back(PoolAvailability{});
+ o.emplace_back();
o.back().pool_name = "foo";
o.back().started_at = utime_t(123, 456);
o.back().uptime = 100;
}
static std::list<SequencerPosition> generate_test_instances() {
std::list<SequencerPosition> o;
- o.push_back(SequencerPosition{});
+ o.emplace_back();
o.push_back(SequencerPosition(1, 2, 3));
o.push_back(SequencerPosition(4, 5, 6));
return o;
{
list<Transaction> o;
- o.push_back(Transaction{});
+ o.emplace_back();
Transaction t;
t.nop();
list<bluefs_extent_t> bluefs_extent_t::generate_test_instances()
{
list<bluefs_extent_t> ls;
- ls.push_back(bluefs_extent_t{});
- ls.push_back(bluefs_extent_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().offset = 1;
ls.back().length = 2;
ls.back().bdev = 1;
list<bluefs_layout_t> bluefs_layout_t::generate_test_instances()
{
list<bluefs_layout_t> ls;
- ls.push_back(bluefs_layout_t{});
- ls.push_back(bluefs_layout_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().shared_bdev = 1;
ls.back().dedicated_db = true;
ls.back().dedicated_wal = true;
list<bluefs_super_t> bluefs_super_t::generate_test_instances()
{
list<bluefs_super_t> ls;
- ls.push_back(bluefs_super_t{});
- ls.push_back(bluefs_super_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().seq = 1;
ls.back().block_size = 4096;
return ls;
list<bluefs_fnode_t> bluefs_fnode_t::generate_test_instances()
{
list<bluefs_fnode_t> ls;
- ls.push_back(bluefs_fnode_t{});
- ls.push_back(bluefs_fnode_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().ino = 123;
ls.back().size = 1048576;
ls.back().mtime = utime_t(123,45);
list<bluefs_transaction_t> bluefs_transaction_t::generate_test_instances()
{
list<bluefs_transaction_t> ls;
- ls.push_back(bluefs_transaction_t{});
- ls.push_back(bluefs_transaction_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().op_init();
ls.back().op_dir_create("dir");
ls.back().op_dir_create("dir2");
list<bluestore_bdev_label_t> bluestore_bdev_label_t::generate_test_instances()
{
list<bluestore_bdev_label_t> o;
- o.push_back(bluestore_bdev_label_t{});
- o.push_back(bluestore_bdev_label_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().size = 123;
o.back().btime = utime_t(4, 5);
o.back().description = "fakey";
list<bluestore_extent_ref_map_t> bluestore_extent_ref_map_t::generate_test_instances()
{
list<bluestore_extent_ref_map_t> o;
- o.push_back(bluestore_extent_ref_map_t{});
- o.push_back(bluestore_extent_ref_map_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().get(10, 10);
o.back().get(18, 22);
o.back().get(20, 20);
list<bluestore_pextent_t> bluestore_pextent_t::generate_test_instances()
{
list<bluestore_pextent_t> ls;
- ls.push_back(bluestore_pextent_t{});
+ ls.emplace_back();
ls.push_back(bluestore_pextent_t(1, 2));
return ls;
}
list<bluestore_blob_t> bluestore_blob_t::generate_test_instances()
{
list<bluestore_blob_t> ls;
- ls.push_back(bluestore_blob_t{});
+ ls.emplace_back();
ls.push_back(bluestore_blob_t(0));
- ls.push_back(bluestore_blob_t{});
+ ls.emplace_back();
ls.back().allocated_test(bluestore_pextent_t(111, 222));
- ls.push_back(bluestore_blob_t{});
+ ls.emplace_back();
ls.back().init_csum(Checksummer::CSUM_XXHASH32, 16, 65536);
ls.back().csum_data = ceph::buffer::claim_malloc(4, strdup("abcd"));
ls.back().add_unused(0, 3);
auto bluestore_onode_t::shard_info::generate_test_instances() -> list<shard_info>
{
list<shard_info> o;
- o.push_back(shard_info{});
- o.push_back(shard_info{});
+ o.emplace_back();
+ o.emplace_back();
o.back().offset = 123;
o.back().bytes = 456;
return o;
list<bluestore_deferred_op_t> bluestore_deferred_op_t::generate_test_instances()
{
list<bluestore_deferred_op_t> o;
- o.push_back(bluestore_deferred_op_t{});
- o.push_back(bluestore_deferred_op_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().op = OP_WRITE;
o.back().extents.push_back(bluestore_pextent_t(1, 2));
o.back().extents.push_back(bluestore_pextent_t(100, 5));
list<bluestore_compression_header_t> bluestore_compression_header_t::generate_test_instances()
{
list<bluestore_compression_header_t> o;
- o.push_back(bluestore_compression_header_t{});
+ o.emplace_back();
o.push_back(bluestore_compression_header_t(1));
o.back().length = 1234;
return o;
}
static std::list<record_t> generate_test_instances() {
std::list<record_t> o;
- o.push_back(record_t{});
+ o.emplace_back();
o.push_back(record_t(123, 456));
return o;
}
list<HitSet> HitSet::generate_test_instances()
{
list<HitSet> o;
- o.push_back(HitSet{});
+ o.emplace_back();
o.push_back(HitSet(new BloomHitSet(10, .1, 1)));
o.back().insert(hobject_t());
o.back().insert(hobject_t("asdf", "", CEPH_NOSNAP, 123, 1, ""));
for (auto& i : kind::Params::generate_test_instances()) \
o.push_back(Params(&i)); \
}
- o.push_back(Params{});
+ o.emplace_back();
o.push_back(Params(new BloomHitSet::Params));
loop_hitset_params(BloomHitSet);
o.push_back(Params(new ExplicitHashHitSet::Params));
}
static std::list<Params> generate_test_instances() {
std::list<Params> o;
- o.push_back(Params{});
+ o.emplace_back();
return o;
}
};
void dump(ceph::Formatter *f) const override;
static std::list<ExplicitHashHitSet> generate_test_instances() {
std::list<ExplicitHashHitSet> o;
- o.push_back(ExplicitHashHitSet{});
- o.push_back(ExplicitHashHitSet{});
+ o.emplace_back();
+ o.emplace_back();
o.back().insert(hobject_t());
o.back().insert(hobject_t("asdf", "", CEPH_NOSNAP, 123, 1, ""));
o.back().insert(hobject_t("qwer", "", CEPH_NOSNAP, 456, 1, ""));
}
static std::list<Params> generate_test_instances() {
std::list<Params> o;
- o.push_back(Params{});
+ o.emplace_back();
return o;
}
};
void dump(ceph::Formatter *f) const override;
static std::list<ExplicitObjectHitSet> generate_test_instances() {
std::list<ExplicitObjectHitSet> o;
- o.push_back(ExplicitObjectHitSet{});
- o.push_back(ExplicitObjectHitSet{});
+ o.emplace_back();
+ o.emplace_back();
o.back().insert(hobject_t());
o.back().insert(hobject_t("asdf", "", CEPH_NOSNAP, 123, 1, ""));
o.back().insert(hobject_t("qwer", "", CEPH_NOSNAP, 456, 1, ""));
}
static std::list<Params> generate_test_instances() {
std::list<Params> o;
- o.push_back(Params{});
- o.push_back(Params{});
+ o.emplace_back();
+ o.emplace_back();
o.back().fpp_micro = 123456;
o.back().target_size = 300;
o.back().seed = 99;
void dump(ceph::Formatter *f) const override;
static std::list<BloomHitSet> generate_test_instances() {
std::list<BloomHitSet> o;
- o.push_back(BloomHitSet{});
+ o.emplace_back();
o.push_back(BloomHitSet(10, .1, 1));
o.back().insert(hobject_t());
o.back().insert(hobject_t("asdf", "", CEPH_NOSNAP, 123, 1, ""));
list<osd_info_t> osd_info_t::generate_test_instances()
{
list<osd_info_t> o;
- o.push_back(osd_info_t{});
- o.push_back(osd_info_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().last_clean_begin = 1;
o.back().last_clean_end = 2;
o.back().up_from = 30;
list<osd_xinfo_t> osd_xinfo_t::generate_test_instances()
{
list<osd_xinfo_t> o;
- o.push_back(osd_xinfo_t{});
- o.push_back(osd_xinfo_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().down_stamp = utime_t(2, 3);
o.back().laggy_probability = .123;
o.back().laggy_interval = 123456;
auto OSDMap::Incremental::generate_test_instances() -> list<Incremental>
{
list<Incremental> o;
- o.push_back(Incremental{});
+ o.emplace_back();
return o;
}
}
static std::list<PGTempMap> generate_test_instances() {
std::list<PGTempMap> o;
- o.push_back(PGTempMap{});
- o.push_back(PGTempMap{});
+ o.emplace_back();
+ o.emplace_back();
o.back().set(pg_t(1, 2), { 3, 4 });
o.back().set(pg_t(2, 3), { 4, 5 });
return o;
auto SnapMapper::object_snaps::generate_test_instances() -> std::list<object_snaps>
{
std::list<object_snaps> o;
- o.push_back(object_snaps{});
- o.push_back(object_snaps{});
+ o.emplace_back();
+ o.emplace_back();
o.back().oid = hobject_t(sobject_t("name", CEPH_NOSNAP));
o.back().snaps.insert(1);
o.back().snaps.insert(2);
}
static std::list<Mapping> generate_test_instances() {
std::list<Mapping> o;
- o.push_back(Mapping{});
- o.push_back(Mapping{});
+ o.emplace_back();
+ o.emplace_back();
o.back().snap = 1;
o.back().hoid = hobject_t(object_t("objname"), "key", 123, 456, 0, "");
return o;
list<osd_reqid_t> osd_reqid_t::generate_test_instances()
{
list<osd_reqid_t> o;
- o.push_back(osd_reqid_t{});
+ o.emplace_back();
o.push_back(osd_reqid_t(entity_name_t::CLIENT(123), 1, 45678));
return o;
}
list<object_locator_t> object_locator_t::generate_test_instances()
{
list<object_locator_t> o;
- o.push_back(object_locator_t{});
+ o.emplace_back();
o.push_back(object_locator_t(123));
o.push_back(object_locator_t(123, 876));
o.push_back(object_locator_t(1, "n2"));
{
std::list<osd_stat_t> o;
- o.push_back(osd_stat_t{});
+ o.emplace_back();
- o.push_back(osd_stat_t{});
+ o.emplace_back();
list<store_statfs_t> ll = store_statfs_t::generate_test_instances();
o.back().statfs = ll.back();
o.back().hb_peers.push_back(7);
list<pg_t> pg_t::generate_test_instances()
{
list<pg_t> o;
- o.push_back(pg_t{});
+ o.emplace_back();
o.push_back(pg_t(1, 2));
o.push_back(pg_t(13123, 3));
o.push_back(pg_t(131223, 4));
list<pool_snap_info_t> pool_snap_info_t::generate_test_instances()
{
list<pool_snap_info_t> o;
- o.push_back(pool_snap_info_t{});
- o.push_back(pool_snap_info_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().snapid = 1;
o.back().stamp = utime_t(1, 2);
o.back().name = "foo";
std::list<pool_opts_t> pool_opts_t::generate_test_instances()
{
std::list<pool_opts_t> o;
- o.push_back(pool_opts_t{});
+ o.emplace_back();
return o;
}
list<pg_history_t> pg_history_t::generate_test_instances()
{
list<pg_history_t> o;
- o.push_back(pg_history_t{});
- o.push_back(pg_history_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().epoch_created = 1;
o.back().epoch_pool_created = 1;
o.back().last_epoch_started = 2;
list<pg_info_t> pg_info_t::generate_test_instances()
{
list<pg_info_t> o;
- o.push_back(pg_info_t{});
- o.push_back(pg_info_t{});
+ o.emplace_back();
+ o.emplace_back();
list<pg_history_t> h = pg_history_t::generate_test_instances();
o.back().history = h.back();
o.back().pgid = spg_t(pg_t(1, 2), shard_id_t::NO_SHARD);
{
list<pg_notify_t> o;
- o.push_back(pg_notify_t{});
+ o.emplace_back();
o.push_back(pg_notify_t(shard_id_t(3), shard_id_t::NO_SHARD, 1, 1,
pg_info_t(spg_t(pg_t(0,10), shard_id_t(-1))), PastIntervals(),
PG_FEATURE_CLASSIC_ALL));
auto PastIntervals::pg_interval_t::generate_test_instances() -> list<pg_interval_t>
{
list<pg_interval_t> o;
- o.push_back(pg_interval_t{});
- o.push_back(pg_interval_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().up.push_back(1);
o.back().acting.push_back(2);
o.back().acting.push_back(3);
list<pg_log_t> pg_log_t::generate_test_instances()
{
list<pg_log_t> o;
- o.push_back(pg_log_t{});
+ o.emplace_back();
// this is nonsensical:
- o.push_back(pg_log_t{});
+ o.emplace_back();
o.back().head = eversion_t(1,2);
o.back().tail = eversion_t(3,4);
for (auto& p : pg_log_entry_t::generate_test_instances()) {
list<object_copy_cursor_t> object_copy_cursor_t::generate_test_instances()
{
list<object_copy_cursor_t> o;
- o.push_back(object_copy_cursor_t{});
- o.push_back(object_copy_cursor_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().attr_complete = true;
o.back().data_offset = 123;
- o.push_back(object_copy_cursor_t{});
+ o.emplace_back();
o.back().attr_complete = true;
o.back().data_complete = true;
o.back().omap_offset = "foo";
- o.push_back(object_copy_cursor_t{});
+ o.emplace_back();
o.back().attr_complete = true;
o.back().data_complete = true;
o.back().omap_complete = true;
list<pg_create_t> pg_create_t::generate_test_instances()
{
list<pg_create_t> o;
- o.push_back(pg_create_t{});
+ o.emplace_back();
o.push_back(pg_create_t(1, pg_t(3, 4), 2));
return o;
}
list<pg_hit_set_info_t> pg_hit_set_info_t::generate_test_instances()
{
list<pg_hit_set_info_t> ls;
- ls.push_back(pg_hit_set_info_t{});
- ls.push_back(pg_hit_set_info_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().begin = utime_t(1, 2);
ls.back().end = utime_t(3, 4);
return ls;
list<pg_hit_set_history_t> pg_hit_set_history_t::generate_test_instances()
{
list<pg_hit_set_history_t> ls;
- ls.push_back(pg_hit_set_history_t{});
- ls.push_back(pg_hit_set_history_t{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().current_last_update = eversion_t(1, 2);
ls.back().history.push_back(pg_hit_set_info_t());
return ls;
list<SnapSet> SnapSet::generate_test_instances()
{
list<SnapSet> o;
- o.push_back(SnapSet{});
- o.push_back(SnapSet{});
+ o.emplace_back();
+ o.emplace_back();
o.back().seq = 123;
- o.push_back(SnapSet{});
+ o.emplace_back();
o.back().seq = 123;
o.back().clones.push_back(12);
o.back().clone_size[12] = 12345;
list<watch_info_t> watch_info_t::generate_test_instances()
{
list<watch_info_t> o;
- o.push_back(watch_info_t{});
- o.push_back(watch_info_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().cookie = 123;
o.back().timeout_seconds = 99;
entity_addr_t ea;
std::list<chunk_info_t> chunk_info_t::generate_test_instances()
{
std::list<chunk_info_t> o;
- o.push_back(chunk_info_t{});
- o.push_back(chunk_info_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().length = 123;
o.back().oid = hobject_t(object_t("foo"), "", 123, 456, -1, "");
o.back().flags = cflag_t::FLAG_DIRTY;
list<ObjectRecoveryProgress> ObjectRecoveryProgress::generate_test_instances()
{
list<ObjectRecoveryProgress> o;
- o.push_back(ObjectRecoveryProgress{});
+ o.emplace_back();
o.back().first = false;
o.back().data_complete = true;
o.back().omap_complete = true;
o.back().data_recovered_to = 100;
- o.push_back(ObjectRecoveryProgress{});
+ o.emplace_back();
o.back().first = true;
o.back().data_complete = false;
o.back().omap_complete = false;
list<ObjectRecoveryInfo> ObjectRecoveryInfo::generate_test_instances()
{
list<ObjectRecoveryInfo> o;
- o.push_back(ObjectRecoveryInfo{});
+ o.emplace_back();
o.back().soid = hobject_t(sobject_t("key", CEPH_NOSNAP));
o.back().version = eversion_t(0,0);
o.back().size = 100;
list<PushReplyOp> PushReplyOp::generate_test_instances()
{
list<PushReplyOp> o;
- o.push_back(PushReplyOp{});
- o.push_back(PushReplyOp{});
+ o.emplace_back();
+ o.emplace_back();
o.back().soid = hobject_t(sobject_t("asdf", 2));
- o.push_back(PushReplyOp{});
+ o.emplace_back();
o.back().soid = hobject_t(sobject_t("asdf", CEPH_NOSNAP));
return o;
}
list<PullOp> PullOp::generate_test_instances()
{
list<PullOp> o;
- o.push_back(PullOp{});
- o.push_back(PullOp{});
+ o.emplace_back();
+ o.emplace_back();
o.back().soid = hobject_t(sobject_t("asdf", 2));
o.back().recovery_info.version = eversion_t(3, 10);
- o.push_back(PullOp{});
+ o.emplace_back();
o.back().soid = hobject_t(sobject_t("asdf", CEPH_NOSNAP));
o.back().recovery_info.version = eversion_t(0, 0);
return o;
list<PushOp> PushOp::generate_test_instances()
{
list<PushOp> o;
- o.push_back(PushOp{});
- o.push_back(PushOp{});
+ o.emplace_back();
+ o.emplace_back();
o.back().soid = hobject_t(sobject_t("asdf", 2));
o.back().version = eversion_t(3, 10);
- o.push_back(PushOp{});
+ o.emplace_back();
o.back().soid = hobject_t(sobject_t("asdf", CEPH_NOSNAP));
o.back().version = eversion_t(0, 0);
return o;
list<ScrubMap> ScrubMap::generate_test_instances()
{
list<ScrubMap> o;
- o.push_back(ScrubMap{});
- o.push_back(ScrubMap{});
+ o.emplace_back();
+ o.emplace_back();
o.back().valid_through = eversion_t(1, 2);
o.back().incr_since = eversion_t(3, 4);
list<object> obj = object::generate_test_instances();
{
list<object> o;
- o.push_back(object{});
- o.push_back(object{});
+ o.emplace_back();
+ o.emplace_back();
o.back().negative = true;
- o.push_back(object{});
+ o.emplace_back();
o.back().size = 123;
{
bufferlist foobl;
}
static std::list<pg_shard_t> generate_test_instances() {
std::list<pg_shard_t> o;
- o.push_back(pg_shard_t{});
+ o.emplace_back();
o.push_back(pg_shard_t(1));
o.push_back(pg_shard_t(1, shard_id_t(2)));
return o;
}
static std::list<spg_t> generate_test_instances() {
std::list<spg_t> o;
- o.push_back(spg_t{});
+ o.emplace_back();
o.push_back(spg_t(pg_t(1, 2), shard_id_t(3)));
return o;
}
}
static std::list<eversion_t> generate_test_instances() {
std::list<eversion_t> o;
- o.push_back(eversion_t{});
+ o.emplace_back();
o.push_back(eversion_t(1, 2));
return o;
}
}
static std::list<pg_merge_meta_t> generate_test_instances() {
std::list<pg_merge_meta_t> o;
- o.push_back(pg_merge_meta_t{});
- o.push_back(pg_merge_meta_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().source_pgid = pg_t(1,2);
o.back().ready_epoch = 1;
o.back().last_epoch_started = 2;
}
static std::list<pg_fast_info_t> generate_test_instances() {
std::list<pg_fast_info_t> o;
- o.push_back(pg_fast_info_t{});
- o.push_back(pg_fast_info_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().last_update = eversion_t(1, 2);
o.back().last_complete = eversion_t(3, 4);
o.back().last_user_version = version_t(5);
}
static std::list<pg_log_op_return_item_t> generate_test_instances() {
std::list<pg_log_op_return_item_t> o;
- o.push_back(pg_log_op_return_item_t{});
+ o.emplace_back();
o.back().rval = 0;
- o.push_back(pg_log_op_return_item_t{});
+ o.emplace_back();
o.back().rval = 1;
o.back().bl.append("asdf");
return o;
}
static std::list<pg_missing_item> generate_test_instances() {
std::list<pg_missing_item> o;
- o.push_back(pg_missing_item{});
- o.push_back(pg_missing_item{});
+ o.emplace_back();
+ o.emplace_back();
o.back().need = eversion_t(1, 2);
o.back().have = eversion_t(1, 1);
- o.push_back(pg_missing_item{});
+ o.emplace_back();
o.back().need = eversion_t(3, 5);
o.back().have = eversion_t(3, 4);
o.back().clean_regions.mark_data_region_dirty(4096, 8192);
}
static std::list<pg_missing_set> generate_test_instances() {
std::list<pg_missing_set> o;
- o.push_back(pg_missing_set{});
+ o.emplace_back();
o.back().may_include_deletes = true;
- o.push_back(pg_missing_set{});
+ o.emplace_back();
o.back().add(
hobject_t(object_t("foo"), "foo", 123, 456, 0, ""),
eversion_t(5, 6), eversion_t(5, 1), false);
o.back().may_include_deletes = true;
- o.push_back(pg_missing_set{});
+ o.emplace_back();
o.back().add(
hobject_t(object_t("foo"), "foo", 123, 456, 0, ""),
eversion_t(5, 6), eversion_t(5, 1), true);
}
static std::list<pg_nls_response_template> generate_test_instances() {
std::list<pg_nls_response_template<T>> o;
- o.push_back(pg_nls_response_template<T>{});
- o.push_back(pg_nls_response_template<T>{});
+ o.emplace_back();
+ o.emplace_back();
o.back().handle = hobject_t(object_t("hi"), "key", 1, 2, -1, "");
o.back().entries.push_back(librados::ListObjectImpl("", "one", ""));
o.back().entries.push_back(librados::ListObjectImpl("", "two", "twokey"));
o.back().entries.push_back(librados::ListObjectImpl("", "three", ""));
- o.push_back(pg_nls_response_template<T>{});
+ o.emplace_back();
o.back().handle = hobject_t(object_t("hi"), "key", 3, 4, -1, "");
o.back().entries.push_back(librados::ListObjectImpl("n1", "n1one", ""));
o.back().entries.push_back(librados::ListObjectImpl("n1", "n1two", "n1twokey"));
o.back().entries.push_back(librados::ListObjectImpl("n1", "n1three", ""));
- o.push_back(pg_nls_response_template<T>{});
+ o.emplace_back();
o.back().handle = hobject_t(object_t("hi"), "key", 5, 6, -1, "");
o.back().entries.push_back(librados::ListObjectImpl("", "one", ""));
o.back().entries.push_back(librados::ListObjectImpl("", "two", "twokey"));
}
static std::list<pg_ls_response_t> generate_test_instances() {
std::list<pg_ls_response_t> o;
- o.push_back(pg_ls_response_t{});
- o.push_back(pg_ls_response_t{});
+ o.emplace_back();
+ o.emplace_back();
o.back().handle = hobject_t(object_t("hi"), "key", 1, 2, -1, "");
o.back().entries.push_back(std::make_pair(object_t("one"), std::string()));
o.back().entries.push_back(std::make_pair(object_t("two"), std::string("twokey")));
static std::list<obj_list_watch_response_t> generate_test_instances() {
std::list<obj_list_watch_response_t> o;
entity_addr_t ea;
- o.push_back(obj_list_watch_response_t{});
- o.push_back(obj_list_watch_response_t{});
+ o.emplace_back();
+ o.emplace_back();
std::list<watch_item_t> test_watchers = watch_item_t::generate_test_instances();
for (auto &e : test_watchers) {
o.back().entries.push_back(e);
}
static std::list<clone_info> generate_test_instances() {
std::list<clone_info> o;
- o.push_back(clone_info{});
- o.push_back(clone_info{});
+ o.emplace_back();
+ o.emplace_back();
o.back().cloneid = 1;
o.back().snaps.push_back(1);
o.back().overlap.push_back(std::pair<uint64_t,uint64_t>(0,4096));
o.back().overlap.push_back(std::pair<uint64_t,uint64_t>(8192,4096));
o.back().size = 16384;
- o.push_back(clone_info{});
+ o.emplace_back();
o.back().cloneid = CEPH_NOSNAP;
o.back().size = 32768;
return o;
}
static std::list<obj_list_snap_response_t> generate_test_instances() {
std::list<obj_list_snap_response_t> o;
- o.push_back(obj_list_snap_response_t{});
- o.push_back(obj_list_snap_response_t{});
+ o.emplace_back();
+ o.emplace_back();
clone_info cl;
cl.cloneid = 1;
cl.snaps.push_back(1);
}
static std::list<pool_pg_num_history_t> generate_test_instances() {
std::list<pool_pg_num_history_t> ls;
- ls.push_back(pool_pg_num_history_t{});
+ ls.emplace_back();
return ls;
}
friend std::ostream& operator<<(std::ostream& out, const pool_pg_num_history_t& h) {
std::list<resource_metadata> resource_metadata::generate_test_instances()
{
std::list<resource_metadata> o;
- o.push_back(resource_metadata{});
+ o.emplace_back();
resource_metadata m;
m.group_id = "id";
o.push_back(std::move(m));
bp.creation_time = ceph::real_clock::from_ceph_timespec({ceph_le32(2), ceph_le32(3)});
o.push_back(std::move(bp));
- o.push_back(RGWBucketEntryPoint{});
+ o.emplace_back();
return o;
}
info.state = rgw_data_sync_info::StateBuildingFullSyncMaps;
info.num_shards = 8;
o.push_back(std::move(info));
- o.push_back(rgw_data_sync_info{});
+ o.emplace_back();
return o;
}
marker.marker = "01234";
marker.pos = 5;
o.push_back(std::move(marker));
- o.push_back(rgw_data_sync_marker{});
+ o.emplace_back();
return o;
}
list<rgw_data_sync_status> rgw_data_sync_status::generate_test_instances()
{
list<rgw_data_sync_status> o;
- o.push_back(rgw_data_sync_status{});
+ o.emplace_back();
return o;
}
std::list<rgw_data_change> rgw_data_change::generate_test_instances() {
std::list<rgw_data_change> l;
- l.push_back(rgw_data_change{});
- l.push_back(rgw_data_change{});
+ l.emplace_back();
+ l.emplace_back();
l.back().entity_type = ENTITY_TYPE_BUCKET;
l.back().key = "bucket_name";
l.back().timestamp = ceph::real_clock::zero();
{
std::list<RGWObjManifestPart> o;
- o.push_back(RGWObjManifestPart{});
+ o.emplace_back();
RGWObjManifestPart p;
rgw_bucket b;
}
m.set_explicit(total_size, objs);
o.push_back(std::move(m));
- o.push_back(RGWObjManifest{});
+ o.emplace_back();
return o;
}
r.stripe_max_size = 512 * 1024 * 1024;
r.override_prefix = "override_prefix";
o.push_back(std::move(r));
- o.push_back(RGWObjManifestRule{});
+ o.emplace_back();
return o;
}
}
t.is_multipart_upload = true;
o.push_back(std::move(t));
- o.push_back(RGWObjTier{});
+ o.emplace_back();
return o;
}
it.bucket_id = "1234";
it.obj_key = rgw_obj_key("obj");
o.push_back(std::move(it));
- o.push_back(objexp_hint_entry{});
+ o.emplace_back();
return o;
}
RGWOLHInfo olh;
olh.removed = false;
o.push_back(olh);
- o.push_back(RGWOLHInfo{});
+ o.emplace_back();
return o;
}
}
static std::list<RGWUID> generate_test_instances() {
std::list<RGWUID> o;
- o.push_back(RGWUID{});
- o.push_back(RGWUID{});
+ o.emplace_back();
+ o.emplace_back();
o.back().id = "test:tester";
return o;
}
std::list<resource_metadata> resource_metadata::generate_test_instances()
{
std::list<resource_metadata> o;
- o.push_back(resource_metadata{});
+ o.emplace_back();
resource_metadata m;
m.role_id = "id";
o.push_back(std::move(m));
std::list<resource_metadata> resource_metadata::generate_test_instances()
{
std::list<resource_metadata> o;
- o.push_back(resource_metadata{});
+ o.emplace_back();
resource_metadata m;;
m.user_id = "uid";
o.push_back(std::move(m));
ACLPermission p;
p.set_permissions(RGW_PERM_WRITE_ACP);
o.push_back(std::move(p));
- o.push_back(ACLPermission{});
+ o.emplace_back();
return o;
}
g1.set_group(ACL_GROUP_AUTHENTICATED_USERS, RGW_PERM_WRITE);
o.push_back(std::move(g2));
- o.push_back(ACLGrant{});
+ o.emplace_back();
return o;
}
{
list<ACLGranteeType> o;
o.push_back(ACLGranteeType(ACL_TYPE_CANON_USER));
- o.push_back(ACLGranteeType{});
+ o.emplace_back();
return o;
}
acl.add_grant(grant);
}
o.push_back(std::move(acl));
- o.push_back(RGWAccessControlList{});
+ o.emplace_back();
return o;
}
owner.id = "rgw";
owner.display_name = "Mr. RGW";
o.push_back(std::move(owner));
- o.push_back(ACLOwner{});
+ o.emplace_back();
return o;
}
o.push_back(std::move(p));
}
- o.push_back(RGWAccessControlPolicy{});
+ o.emplace_back();
return o;
}
rgw_bucket b;
init_bucket(&b, "tenant", "name", "pool", ".index_pool", "marker", "123");
o.push_back(std::move(b));
- o.push_back(rgw_bucket{});
+ o.emplace_back();
return o;
}
rgw_user u("tenant", "user");
o.push_back(u);
- o.push_back(rgw_user{});
+ o.emplace_back();
return o;
}
static std::list<rgw_zone_id> generate_test_instances() {
std::list<rgw_zone_id> o;
- o.push_back(rgw_zone_id{});
+ o.emplace_back();
o.push_back(rgw_zone_id("id"));
return o;
}
ObjectMetaInfo m;
m.size = 1024 * 1024;
o.push_back(std::move(m));
- o.push_back(ObjectMetaInfo{});
+ o.emplace_back();
return o;
}
i.rm_xattrs["r3"] = data;
i.meta.size = 512 * 1024;
o.push_back(std::move(i));
- o.push_back(ObjectCacheInfo{});
+ o.emplace_back();
return o;
}
list<RGWCacheNotifyInfo> RGWCacheNotifyInfo::generate_test_instances()
{
list<RGWCacheNotifyInfo> o;
- o.push_back(RGWCacheNotifyInfo{});
+ o.emplace_back();
return o;
}
list<RGWUserCaps> RGWUserCaps::generate_test_instances()
{
list<RGWUserCaps> o;
- o.push_back(RGWUserCaps{});
+ o.emplace_back();
RGWUserCaps caps;
caps.add_cap("read");
caps.add_cap("write");
e.size_rounded = 4096;
e.count = 1;
o.push_back(std::move(e));
- o.push_back(RGWBucketEnt{});
+ o.emplace_back();
return o;
}
rgw_bucket b;
init_bucket(&b, "tenant", "bucket", "pool", ".index_pool", "marker", "10");
o.push_back(rgw_obj(b, "object"));
- o.push_back(rgw_obj{});
+ o.emplace_back();
return o;
}
i.subusers[u.name] = u;
o.push_back(std::move(i));
- o.push_back(RGWUserInfo{});
+ o.emplace_back();
return o;
}
u.name = "name";
u.perm_mask = 0xf;
o.push_back(std::move(u));
- o.push_back(RGWSubUser{});
+ o.emplace_back();
return o;
}
k.key = "key";
k.subuser = "subuser";
o.push_back(std::move(k));
- o.push_back(RGWAccessKey{});
+ o.emplace_back();
return o;
}
std::list<RGWAccountInfo> RGWAccountInfo::generate_test_instances()
{
std::list<RGWAccountInfo> o;
- o.push_back(RGWAccountInfo{});
+ o.emplace_back();
auto p = RGWAccountInfo{};
p.id = "account1";
p.tenant = "tenant1";
std::list<RGWGroupInfo> RGWGroupInfo::generate_test_instances()
{
std::list<RGWGroupInfo> o;
- o.push_back(RGWGroupInfo{});
+ o.emplace_back();
auto p = RGWGroupInfo{};
p.id = "id";
p.tenant = "tenant";
static std::list<multipart_upload_info> generate_test_instances() {
std::list<multipart_upload_info> o;
- o.push_back(multipart_upload_info{});
- o.push_back(multipart_upload_info{});
+ o.emplace_back();
+ o.emplace_back();
o.back().dest_placement.name = "dest_placement";
o.back().dest_placement.storage_class = "dest_storage_class";
return o;
list<RGWCORSRule> RGWCORSRule::generate_test_instances()
{
list<RGWCORSRule> o;
- o.push_back(RGWCORSRule{});
- o.push_back(RGWCORSRule{});
+ o.emplace_back();
+ o.emplace_back();
o.back().id = "test";
o.back().max_age = 100;
o.back().allowed_methods = RGW_CORS_GET | RGW_CORS_PUT;
v.tag = "tag";
o.push_back(std::move(v));
- o.push_back(obj_version{});
+ o.emplace_back();
return o;
}
bc = RGWBucketEncryptionConfig("AES256");
o.push_back(std::move(bc));
- o.push_back(RGWBucketEncryptionConfig{});
+ o.emplace_back();
return o;
}
list<RGWLifecycleConfiguration> RGWLifecycleConfiguration::generate_test_instances()
{
list<RGWLifecycleConfiguration> o;
- o.push_back(RGWLifecycleConfiguration{});
+ o.emplace_back();
return o;
}
e.account_id = "account_id";
e.role_id = "role_id";
o.push_back(std::move(e));
- o.push_back(rgw_log_entry{});
+ o.emplace_back();
return o;
}
std::list<RGWMetadataLogData> RGWMetadataLogData::generate_test_instances() {
std::list<RGWMetadataLogData> l;
- l.push_back(RGWMetadataLogData{});
- l.push_back(RGWMetadataLogData{});
+ l.emplace_back();
+ l.emplace_back();
l.back().read_version = obj_version();
l.back().read_version.tag = "read_tag";
l.back().write_version = obj_version();
i.size = 10 * 1024 * 1024;
i.etag = "etag";
o.push_back(std::move(i));
- o.push_back(RGWUploadPartInfo{});
+ o.emplace_back();
return o;
}
void decode_json(JSONObj *obj);
static std::list<rgw_obj_index_key> generate_test_instances() {
std::list<rgw_obj_index_key> ls;
- ls.push_back(rgw_obj_index_key{});
- ls.push_back(rgw_obj_index_key{});
+ ls.emplace_back();
+ ls.emplace_back();
ls.back().name = "name";
ls.back().instance = "instance";
return ls;
std::list<ObjectLockRule> ObjectLockRule::generate_test_instances() {
std::list<ObjectLockRule> o;
- o.push_back(ObjectLockRule{});
+ o.emplace_back();
return o;
}
p.client_ids = {"a", "b"};
p.thumbprints = {"c", "d"};
l.push_back(std::move(p));
- l.push_back(RGWOIDCProviderInfo{});
+ l.emplace_back();
return l;
}
static std::list<rgw_placement_rule> generate_test_instances() {
std::list<rgw_placement_rule> o;
- o.push_back(rgw_placement_rule{});
+ o.emplace_back();
o.push_back(rgw_placement_rule("name", "storage_class"));
return o;
}
static std::list<rgw_pool> generate_test_instances() {
std::list<rgw_pool> o;
- o.push_back(rgw_pool{});
+ o.emplace_back();
o.push_back(rgw_pool("pool", "ns"));
return o;
}
std::list<RGWQuotaInfo> RGWQuotaInfo::generate_test_instances()
{
std::list<RGWQuotaInfo> o;
- o.push_back(RGWQuotaInfo{});
- o.push_back(RGWQuotaInfo{});
+ o.emplace_back();
+ o.emplace_back();
o.back().enabled = true;
o.back().check_on_raw = true;
o.back().max_size = 1024;
list<RGWRealm> RGWRealm::generate_test_instances()
{
list<RGWRealm> o;
- o.push_back(RGWRealm{});
- o.push_back(RGWRealm{});
+ o.emplace_back();
+ o.emplace_back();
return o;
}
list<rgw_sync_policy_info> rgw_sync_policy_info::generate_test_instances()
{
list<rgw_sync_policy_info> o;
- o.push_back(rgw_sync_policy_info{});
+ o.emplace_back();
return o;
}
r.add_tag("key1","val1");
r.add_tag("key2","val2");
o.push_back(std::move(r));
- o.push_back(RGWObjTags{});
+ o.emplace_back();
return o;
}
list<RGWZone> RGWZone::generate_test_instances()
{
list<RGWZone> o;
- o.push_back(RGWZone{});
- o.push_back(RGWZone{});
+ o.emplace_back();
+ o.emplace_back();
return o;
}
list<RGWZonePlacementInfo> RGWZonePlacementInfo::generate_test_instances()
{
list<RGWZonePlacementInfo> o;
- o.push_back(RGWZonePlacementInfo{});
- o.push_back(RGWZonePlacementInfo{});
+ o.emplace_back();
+ o.emplace_back();
o.back().index_pool = rgw_pool("rgw.buckets.index");
o.back().data_extra_pool = rgw_pool("rgw.buckets.non-ec");
list<RGWZoneStorageClasses> RGWZoneStorageClasses::generate_test_instances()
{
list<RGWZoneStorageClasses> o;
- o.push_back(RGWZoneStorageClasses{});
+ o.emplace_back();
return o;
}
list<RGWZoneStorageClass> RGWZoneStorageClass::generate_test_instances()
{
list<RGWZoneStorageClass> o;
- o.push_back(RGWZoneStorageClass{});
- o.push_back(RGWZoneStorageClass{});
+ o.emplace_back();
+ o.emplace_back();
o.back().data_pool = rgw_pool("pool1");
o.back().compression_type = "zlib";
return o;
void decode_json(JSONObj *obj);
static std::list<RGWZoneGroupTierS3Glacier> generate_test_instances() {
std::list<RGWZoneGroupTierS3Glacier> o;
- o.push_back(RGWZoneGroupTierS3Glacier{});
+ o.emplace_back();
o.back().glacier_restore_days = 2;
o.back().glacier_restore_tier_type = GlacierRestoreTierType::Expedited;
return o;
void decode_json(JSONObj *obj);
static std::list<RGWZoneGroupPlacementTier> generate_test_instances() {
std::list<RGWZoneGroupPlacementTier> o;
- o.push_back(RGWZoneGroupPlacementTier{});
- o.push_back(RGWZoneGroupPlacementTier{});
+ o.emplace_back();
+ o.emplace_back();
o.back().tier_type = RGWTierType::CLOUD_S3;
o.back().storage_class = RGW_STORAGE_CLASS_STANDARD;
o.back().allow_read_through = false;
void decode_json(JSONObj *obj);
static std::list<RGWZoneGroupPlacementTarget> generate_test_instances() {
std::list<RGWZoneGroupPlacementTarget> o;
- o.push_back(RGWZoneGroupPlacementTarget{});
+ o.emplace_back();
o.back().storage_classes.insert(RGW_STORAGE_CLASS_STANDARD);
- o.push_back(RGWZoneGroupPlacementTarget{});
+ o.emplace_back();
o.back().name = "target";
o.back().tags.insert("tag1");
o.back().tags.insert("tag2");
projects / ceph-ci.git / commitdiff