From 93c2ccc47489db4637715083ab32f16d879911cd Mon Sep 17 00:00:00 2001 From: Kefu Chai Date: Sat, 7 Sep 2019 01:30:24 +0800 Subject: [PATCH] test/librados: free AioCompletion using unique_ptr always destroy AioCompletion pointers even if test fails Signed-off-by: Kefu Chai --- src/test/librados/aio_cxx.cc | 883 +++++++++++++---------------------- 1 file changed, 318 insertions(+), 565 deletions(-) diff --git a/src/test/librados/aio_cxx.cc b/src/test/librados/aio_cxx.cc index 293c0a780acff..84ea454e85ccf 100644 --- a/src/test/librados/aio_cxx.cc +++ b/src/test/librados/aio_cxx.cc @@ -74,12 +74,10 @@ TEST(LibRadosAio, TooBigPP) { ASSERT_EQ("", test_data.init()); bufferlist bl; - auto aio_completion = - test_data.m_cluster.aio_create_completion(nullptr, nullptr); - ASSERT_EQ(-E2BIG, test_data.m_ioctx.aio_write("foo", aio_completion, bl, UINT_MAX, 0)); - ASSERT_EQ(-E2BIG, test_data.m_ioctx.aio_append("foo", aio_completion, bl, UINT_MAX)); + auto aio_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_EQ(-E2BIG, test_data.m_ioctx.aio_write("foo", aio_completion.get(), bl, UINT_MAX, 0)); + ASSERT_EQ(-E2BIG, test_data.m_ioctx.aio_append("foo", aio_completion.get(), bl, UINT_MAX)); // ioctx.aio_write_full no way to overflow bl.length() - delete aio_completion; } TEST(LibRadosAio, PoolQuotaPP) { @@ -104,14 +102,12 @@ TEST(LibRadosAio, PoolQuotaPP) { for (n = 0; n < 1024; ++n) { ObjectWriteOperation op; op.write_full(bl); - librados::AioCompletion *completion = - test_data.m_cluster.aio_create_completion(); - ASSERT_EQ(0, ioctx.aio_operate( - "foo" + stringify(n), completion, &op, - librados::OPERATION_FULL_TRY)); + auto completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_EQ(0, ioctx.aio_operate("foo" + stringify(n), + completion.get(), &op, + librados::OPERATION_FULL_TRY)); completion->wait_for_complete(); int r = completion->get_return_value(); - completion->release(); if (r == -EDQUOT) break; ASSERT_EQ(0, r); @@ -126,12 +122,10 @@ TEST(LibRadosAio, PoolQuotaPP) { { ObjectWriteOperation op; op.write_full(bl); - librados::AioCompletion *completion = - test_data.m_cluster.aio_create_completion(); - ASSERT_EQ(0, ioctx.aio_operate("bar", completion, &op, 0)); + auto completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_EQ(0, ioctx.aio_operate("bar", completion.get(), &op, 0)); sleep(5); ASSERT_FALSE(completion->is_complete()); - completion->release(); } ioctx.close(); @@ -146,80 +140,69 @@ TEST(LibRadosAio, SimpleWritePP) { { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - auto my_completion = - test_data.m_cluster.aio_create_completion(nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", - my_completion, bl1, sizeof(buf), 0)); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), + bl1, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); } ASSERT_EQ(0, my_completion->get_return_value()); - delete my_completion; } { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); test_data.m_ioctx.set_namespace("nspace"); - auto my_completion = - test_data.m_cluster.aio_create_completion(nullptr, nullptr); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", - my_completion, bl1, sizeof(buf), 0)); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), + bl1, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); } ASSERT_EQ(0, my_completion->get_return_value()); - delete my_completion; } } TEST(LibRadosAio, WaitForSafePP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = - test_data.m_cluster.aio_create_completion(nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", - my_completion, bl1, sizeof(buf), 0)); + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), + bl1, sizeof(buf), 0)); TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); ASSERT_EQ(0, my_completion->get_return_value()); - delete my_completion; } TEST(LibRadosAio, RoundTripPP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, - bl1, sizeof(buf), 0)); + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), + bl1, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); } ASSERT_EQ(0, my_completion->get_return_value()); bufferlist bl2; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", - my_completion2, &bl2, sizeof(buf), 0)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), + &bl2, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); @@ -227,34 +210,29 @@ TEST(LibRadosAio, RoundTripPP) { ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), bl2.length()); ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf))); - delete my_completion; - delete my_completion2; } TEST(LibRadosAio, RoundTripPP2) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, - bl1, sizeof(buf), 0)); + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), + bl1, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); } ASSERT_EQ(0, my_completion->get_return_value()); bufferlist bl2; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", - my_completion2, &bl2, sizeof(buf), 0)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), + &bl2, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); @@ -262,8 +240,6 @@ TEST(LibRadosAio, RoundTripPP2) { ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), bl2.length()); ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf))); - delete my_completion; - delete my_completion2; } //using ObjectWriteOperation/ObjectReadOperation with iohint @@ -275,8 +251,7 @@ TEST(LibRadosAio, RoundTripPP3) IoCtx ioctx; cluster.ioctx_create(pool_name.c_str(), ioctx); - boost::scoped_ptr my_completion1( - cluster.aio_create_completion(nullptr, nullptr)); + auto my_completion1 = std::unique_ptr{Rados::aio_create_completion()}; ObjectWriteOperation op; char buf[128]; memset(buf, 0xcc, sizeof(buf)); @@ -292,8 +267,7 @@ TEST(LibRadosAio, RoundTripPP3) } EXPECT_EQ(0, my_completion1->get_return_value()); - boost::scoped_ptr my_completion2( - cluster.aio_create_completion(nullptr, nullptr)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; bl.clear(); ObjectReadOperation op1; op1.read(0, sizeof(buf), &bl, NULL); @@ -326,15 +300,13 @@ TEST(LibRadosAio, RoundTripPP3) TEST(LibRadosAio, RoundTripSparseReadPP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -343,19 +315,16 @@ TEST(LibRadosAio, RoundTripSparseReadPP) { ASSERT_EQ(0, my_completion->get_return_value()); std::map extents; bufferlist bl2; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_sparse_read("foo", - my_completion2, &extents, &bl2, sizeof(buf), 0)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_sparse_read("foo", my_completion2.get(), + &extents, &bl2, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); } ASSERT_EQ(0, my_completion2->get_return_value()); assert_eq_sparse(bl1, extents, bl2); - delete my_completion; - delete my_completion2; } TEST(LibRadosAioPP, ReadIntoBufferlist) { @@ -365,16 +334,14 @@ TEST(LibRadosAioPP, ReadIntoBufferlist) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, - bl1, sizeof(buf), 0)); + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), + bl1, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); @@ -385,19 +352,16 @@ TEST(LibRadosAioPP, ReadIntoBufferlist) { char buf2[sizeof(buf)]; memset(buf2, 0xbb, sizeof(buf2)); bl2.append(buffer::create_static(sizeof(buf2), buf2)); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2, - &bl2, sizeof(buf), 0)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), + &bl2, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); } ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(0, memcmp(buf, buf2, sizeof(buf))); - delete my_completion; - delete my_completion2; } TEST(LibRadosAioPP, XattrsRoundTripPP) { @@ -412,9 +376,7 @@ TEST(LibRadosAioPP, XattrsRoundTripPP) { ASSERT_EQ(0, test_data.m_ioctx.append("foo", bl1, sizeof(buf))); bufferlist bl2; // async getxattr - boost::scoped_ptr my_completion - (test_data.m_cluster.aio_create_completion - (nullptr, nullptr)); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; ASSERT_EQ(0, test_data.m_ioctx.aio_getxattr("foo", my_completion.get(), attr1, bl2)); { TestAlarm alarm; @@ -427,9 +389,7 @@ TEST(LibRadosAioPP, XattrsRoundTripPP) { // async setxattr AioTestDataPP test_data2; ASSERT_EQ("", test_data2.init()); - boost::scoped_ptr my_completion2 - (test_data.m_cluster.aio_create_completion - (nullptr, nullptr)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; ASSERT_EQ(0, test_data.m_ioctx.aio_setxattr("foo", my_completion2.get(), attr1, bl3)); { TestAlarm alarm; @@ -440,9 +400,7 @@ TEST(LibRadosAioPP, XattrsRoundTripPP) { bufferlist bl4; AioTestDataPP test_data3; ASSERT_EQ("", test_data3.init()); - boost::scoped_ptr my_completion3 - (test_data.m_cluster.aio_create_completion - (nullptr, nullptr)); + auto my_completion3 = std::unique_ptr{Rados::aio_create_completion()}; ASSERT_EQ(0, test_data.m_ioctx.aio_getxattr("foo", my_completion3.get(), attr1, bl4)); { TestAlarm alarm; @@ -466,9 +424,7 @@ TEST(LibRadosAioPP, RmXattrPP) { // async setxattr bufferlist bl2; bl2.append(attr1_buf, sizeof(attr1_buf)); - boost::scoped_ptr my_completion - (test_data.m_cluster.aio_create_completion - (nullptr, nullptr)); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; ASSERT_EQ(0, test_data.m_ioctx.aio_setxattr("foo", my_completion.get(), attr1, bl2)); { TestAlarm alarm; @@ -478,9 +434,7 @@ TEST(LibRadosAioPP, RmXattrPP) { // async rmxattr AioTestDataPP test_data2; ASSERT_EQ("", test_data2.init()); - boost::scoped_ptr my_completion2 - (test_data.m_cluster.aio_create_completion - (nullptr, nullptr)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; ASSERT_EQ(0, test_data.m_ioctx.aio_rmxattr("foo", my_completion2.get(), attr1)); { TestAlarm alarm; @@ -490,9 +444,7 @@ TEST(LibRadosAioPP, RmXattrPP) { // async getxattr AioTestDataPP test_data3; ASSERT_EQ("", test_data3.init()); - boost::scoped_ptr my_completion3 - (test_data.m_cluster.aio_create_completion - (nullptr, nullptr)); + auto my_completion3 = std::unique_ptr{Rados::aio_create_completion()}; bufferlist bl3; ASSERT_EQ(0, test_data.m_ioctx.aio_getxattr("foo", my_completion3.get(), attr1, bl3)); { @@ -513,9 +465,7 @@ TEST(LibRadosAioPP, RmXattrPP) { // async setxattr AioTestDataPP test_data4; ASSERT_EQ("", test_data4.init()); - boost::scoped_ptr my_completion4 - (test_data.m_cluster.aio_create_completion - (nullptr, nullptr)); + auto my_completion4 = std::unique_ptr{Rados::aio_create_completion()}; ASSERT_EQ(0, test_data.m_ioctx.aio_setxattr("foo_rmxattr", my_completion4.get(), attr2, bl22)); { TestAlarm alarm; @@ -527,9 +477,7 @@ TEST(LibRadosAioPP, RmXattrPP) { // async rmxattr on non existing object AioTestDataPP test_data5; ASSERT_EQ("", test_data5.init()); - boost::scoped_ptr my_completion5 - (test_data.m_cluster.aio_create_completion - (nullptr, nullptr)); + auto my_completion5 = std::unique_ptr{Rados::aio_create_completion()}; ASSERT_EQ(0, test_data.m_ioctx.aio_rmxattr("foo_rmxattr", my_completion5.get(), attr2)); { TestAlarm alarm; @@ -561,9 +509,7 @@ TEST(LibRadosIoPP, XattrListPP) { bl3.append(attr2_buf, sizeof(attr2_buf)); ASSERT_EQ(0, test_data.m_ioctx.setxattr("foo", attr2, bl3)); // call async version of getxattrs - boost::scoped_ptr my_completion - (test_data.m_cluster.aio_create_completion - (nullptr, nullptr)); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; std::map attrset; ASSERT_EQ(0, test_data.m_ioctx.aio_getxattrs("foo", my_completion.get(), attrset)); { @@ -588,15 +534,13 @@ TEST(LibRadosIoPP, XattrListPP) { TEST(LibRadosAio, IsCompletePP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -604,11 +548,10 @@ TEST(LibRadosAio, IsCompletePP) { } ASSERT_EQ(0, my_completion->get_return_value()); bufferlist bl2; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2, - &bl2, sizeof(buf), 0)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), + &bl2, sizeof(buf), 0)); { TestAlarm alarm; @@ -623,22 +566,18 @@ TEST(LibRadosAio, IsCompletePP) { ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), bl2.length()); ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf))); - delete my_completion; - delete my_completion2; } TEST(LibRadosAio, IsSafePP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -652,11 +591,10 @@ TEST(LibRadosAio, IsSafePP) { } } ASSERT_EQ(0, my_completion->get_return_value()); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; bufferlist bl2; - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2, + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), &bl2, sizeof(buf), 0)); { TestAlarm alarm; @@ -665,48 +603,40 @@ TEST(LibRadosAio, IsSafePP) { ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), bl2.length()); ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf))); - delete my_completion; - delete my_completion2; } TEST(LibRadosAio, ReturnValuePP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); bufferlist bl1; - ASSERT_EQ(0, test_data.m_ioctx.aio_read("nonexistent", - my_completion, &bl1, 128, 0)); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("nonexistent", my_completion.get(), + &bl1, 128, 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); } ASSERT_EQ(-ENOENT, my_completion->get_return_value()); - delete my_completion; } TEST(LibRadosAio, FlushPP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xee, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); ASSERT_EQ(0, test_data.m_ioctx.aio_flush()); ASSERT_EQ(0, my_completion->get_return_value()); bufferlist bl2; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2, + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), &bl2, sizeof(buf), 0)); { TestAlarm alarm; @@ -715,26 +645,21 @@ TEST(LibRadosAio, FlushPP) { ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), bl2.length()); ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf))); - delete my_completion; - delete my_completion2; } TEST(LibRadosAio, FlushAsyncPP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *flush_completion = - test_data.m_cluster.aio_create_completion(NULL, NULL); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + auto flush_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xee, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); - ASSERT_EQ(0, test_data.m_ioctx.aio_flush_async(flush_completion)); + ASSERT_EQ(0, test_data.m_ioctx.aio_flush_async(flush_completion.get())); { TestAlarm alarm; ASSERT_EQ(0, flush_completion->wait_for_complete()); @@ -743,10 +668,9 @@ TEST(LibRadosAio, FlushAsyncPP) { ASSERT_EQ(1, flush_completion->is_complete()); ASSERT_EQ(0, my_completion->get_return_value()); bufferlist bl2; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2, + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), &bl2, sizeof(buf), 0)); { TestAlarm alarm; @@ -755,23 +679,18 @@ TEST(LibRadosAio, FlushAsyncPP) { ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), bl2.length()); ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf))); - delete my_completion; - delete my_completion2; - delete flush_completion; } TEST(LibRadosAio, RoundTripWriteFullPP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -782,20 +701,18 @@ TEST(LibRadosAio, RoundTripWriteFullPP) { memset(buf2, 0xdd, sizeof(buf2)); bufferlist bl2; bl2.append(buf2, sizeof(buf2)); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_write_full("foo", my_completion2, bl2)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_write_full("foo", my_completion2.get(), bl2)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); } ASSERT_EQ(0, my_completion2->get_return_value()); bufferlist bl3; - AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion3, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3, + auto my_completion3 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion3); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3.get(), &bl3, sizeof(buf), 0)); { TestAlarm alarm; @@ -804,9 +721,6 @@ TEST(LibRadosAio, RoundTripWriteFullPP) { ASSERT_EQ((int)sizeof(buf2), my_completion3->get_return_value()); ASSERT_EQ(sizeof(buf2), bl3.length()); ASSERT_EQ(0, memcmp(bl3.c_str(), buf2, sizeof(buf2))); - delete my_completion; - delete my_completion2; - delete my_completion3; } //using ObjectWriteOperation/ObjectReadOperation with iohint @@ -818,7 +732,7 @@ TEST(LibRadosAio, RoundTripWriteFullPP2) IoCtx ioctx; cluster.ioctx_create(pool_name.c_str(), ioctx); - boost::scoped_ptr my_completion1(cluster.aio_create_completion(0, 0)); + auto my_completion1 = std::unique_ptr{Rados::aio_create_completion()}; ObjectWriteOperation op; char buf[128]; memset(buf, 0xcc, sizeof(buf)); @@ -834,7 +748,7 @@ TEST(LibRadosAio, RoundTripWriteFullPP2) } EXPECT_EQ(0, my_completion1->get_return_value()); - boost::scoped_ptr my_completion2(cluster.aio_create_completion(0, 0)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; bl.clear(); ObjectReadOperation op1; op1.read(0, sizeof(buf), &bl, NULL); @@ -854,15 +768,13 @@ TEST(LibRadosAio, RoundTripWriteFullPP2) TEST(LibRadosAio, RoundTripWriteSamePP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char full[128]; memset(full, 0xcc, sizeof(full)); bufferlist bl1; bl1.append(full, sizeof(full)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(full), 0)); { TestAlarm alarm; @@ -875,10 +787,9 @@ TEST(LibRadosAio, RoundTripWriteSamePP) { memset(buf, 0xdd, sizeof(buf)); bufferlist bl2; bl2.append(buf, sizeof(buf)); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_writesame("foo", my_completion2, bl2, + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_writesame("foo", my_completion2.get(), bl2, ws_write_len, 0)); { TestAlarm alarm; @@ -886,10 +797,9 @@ TEST(LibRadosAio, RoundTripWriteSamePP) { } ASSERT_EQ(0, my_completion2->get_return_value()); bufferlist bl3; - AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion3, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3, + auto my_completion3 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion3); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3.get(), &bl3, sizeof(full), 0)); { TestAlarm alarm; @@ -901,9 +811,6 @@ TEST(LibRadosAio, RoundTripWriteSamePP) { cmp += sizeof(buf)) { ASSERT_EQ(0, memcmp(cmp, buf, sizeof(buf))); } - delete my_completion; - delete my_completion2; - delete my_completion3; } TEST(LibRadosAio, RoundTripWriteSamePP2) @@ -914,8 +821,7 @@ TEST(LibRadosAio, RoundTripWriteSamePP2) IoCtx ioctx; cluster.ioctx_create(pool_name.c_str(), ioctx); - boost::scoped_ptr - wr_cmpl(cluster.aio_create_completion(0, 0)); + auto wr_cmpl = std::unique_ptr{Rados::aio_create_completion()}; ObjectWriteOperation op; char buf[128]; memset(buf, 0xcc, sizeof(buf)); @@ -958,15 +864,13 @@ TEST(LibRadosAio, RoundTripWriteSamePP2) TEST(LibRadosAio, SimpleStatPPNS) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -975,33 +879,28 @@ TEST(LibRadosAio, SimpleStatPPNS) { ASSERT_EQ(0, my_completion->get_return_value()); uint64_t psize; time_t pmtime; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2, - &psize, &pmtime)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2.get(), + &psize, &pmtime)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); } ASSERT_EQ(0, my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), psize); - delete my_completion; - delete my_completion2; } TEST(LibRadosAio, SimpleStatPP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -1010,33 +909,28 @@ TEST(LibRadosAio, SimpleStatPP) { ASSERT_EQ(0, my_completion->get_return_value()); uint64_t psize; time_t pmtime; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2, - &psize, &pmtime)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2.get(), + &psize, &pmtime)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); } ASSERT_EQ(0, my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), psize); - delete my_completion; - delete my_completion2; } TEST(LibRadosAio, StatRemovePP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -1045,11 +939,10 @@ TEST(LibRadosAio, StatRemovePP) { ASSERT_EQ(0, my_completion->get_return_value()); uint64_t psize; time_t pmtime; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2, - &psize, &pmtime)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2.get(), + &psize, &pmtime)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); @@ -1058,55 +951,46 @@ TEST(LibRadosAio, StatRemovePP) { ASSERT_EQ(sizeof(buf), psize); uint64_t psize2; time_t pmtime2; - AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion3, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_remove("foo", my_completion3)); + auto my_completion3 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion3); + ASSERT_EQ(0, test_data.m_ioctx.aio_remove("foo", my_completion3.get())); { TestAlarm alarm; ASSERT_EQ(0, my_completion3->wait_for_complete()); } ASSERT_EQ(0, my_completion3->get_return_value()); - AioCompletion *my_completion4 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion4, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion4, + auto my_completion4 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion4); + ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion4.get(), &psize2, &pmtime2)); { TestAlarm alarm; ASSERT_EQ(0, my_completion4->wait_for_complete()); } ASSERT_EQ(-ENOENT, my_completion4->get_return_value()); - delete my_completion; - delete my_completion2; - delete my_completion3; - delete my_completion4; } TEST(LibRadosAio, ExecuteClassPP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); } ASSERT_EQ(0, my_completion->get_return_value()); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); bufferlist in, out; - ASSERT_EQ(0, test_data.m_ioctx.aio_exec("foo", my_completion2, + ASSERT_EQ(0, test_data.m_ioctx.aio_exec("foo", my_completion2.get(), "hello", "say_hello", in, &out)); { TestAlarm alarm; @@ -1114,8 +998,6 @@ TEST(LibRadosAio, ExecuteClassPP) { } ASSERT_EQ(0, my_completion2->get_return_value()); ASSERT_EQ(std::string("Hello, world!"), std::string(out.c_str(), out.length())); - delete my_completion; - delete my_completion2; } using std::string; @@ -1326,15 +1208,13 @@ TEST(LibRadosAio, OmapPP) { TEST(LibRadosAio, MultiWritePP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -1346,10 +1226,9 @@ TEST(LibRadosAio, MultiWritePP) { memset(buf2, 0xdd, sizeof(buf2)); bufferlist bl2; bl2.append(buf2, sizeof(buf2)); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion2, + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion2.get(), bl2, sizeof(buf2), sizeof(buf))); { TestAlarm alarm; @@ -1358,10 +1237,9 @@ TEST(LibRadosAio, MultiWritePP) { ASSERT_EQ(0, my_completion2->get_return_value()); bufferlist bl3; - AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion3, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3, + auto my_completion3 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion3); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3.get(), &bl3, (sizeof(buf) + sizeof(buf2) * 3), 0)); { TestAlarm alarm; @@ -1371,18 +1249,13 @@ TEST(LibRadosAio, MultiWritePP) { ASSERT_EQ(sizeof(buf) + sizeof(buf2), bl3.length()); ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf))); ASSERT_EQ(0, memcmp(bl3.c_str() + sizeof(buf), buf2, sizeof(buf2))); - delete my_completion; - delete my_completion2; - delete my_completion3; } TEST(LibRadosAio, AioUnlockPP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); ASSERT_EQ(0, test_data.m_ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0)); - boost::scoped_ptr my_completion - (test_data.m_cluster.aio_create_completion - (nullptr, nullptr)); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; ASSERT_EQ(0, test_data.m_ioctx.aio_unlock("foo", "TestLock", "Cookie", my_completion.get())); { TestAlarm alarm; @@ -1444,68 +1317,58 @@ TEST(LibRadosAioEC, SimpleWritePP) { { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", - my_completion, bl1, sizeof(buf), 0)); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), + bl1, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); } ASSERT_EQ(0, my_completion->get_return_value()); - delete my_completion; } { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); test_data.m_ioctx.set_namespace("nspace"); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", - my_completion, bl1, sizeof(buf), 0)); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), + bl1, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); } ASSERT_EQ(0, my_completion->get_return_value()); - delete my_completion; } } TEST(LibRadosAioEC, WaitForSafePP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", - my_completion, bl1, sizeof(buf), 0)); + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), + bl1, sizeof(buf), 0)); TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); ASSERT_EQ(0, my_completion->get_return_value()); - delete my_completion; } TEST(LibRadosAioEC, RoundTripPP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -1513,11 +1376,10 @@ TEST(LibRadosAioEC, RoundTripPP) { } ASSERT_EQ(0, my_completion->get_return_value()); bufferlist bl2; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", - my_completion2, &bl2, sizeof(buf), 0)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), + &bl2, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); @@ -1525,22 +1387,18 @@ TEST(LibRadosAioEC, RoundTripPP) { ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), bl2.length()); ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf))); - delete my_completion; - delete my_completion2; } TEST(LibRadosAioEC, RoundTripPP2) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -1548,11 +1406,10 @@ TEST(LibRadosAioEC, RoundTripPP2) { } ASSERT_EQ(0, my_completion->get_return_value()); bufferlist bl2; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", - my_completion2, &bl2, sizeof(buf), 0)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), + &bl2, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); @@ -1560,8 +1417,6 @@ TEST(LibRadosAioEC, RoundTripPP2) { ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), bl2.length()); ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf))); - delete my_completion; - delete my_completion2; } //using ObjectWriteOperation/ObjectReadOperation with iohint @@ -1573,7 +1428,7 @@ TEST(LibRadosAioEC, RoundTripPP3) IoCtx ioctx; cluster.ioctx_create(pool_name.c_str(), ioctx); - boost::scoped_ptr my_completion1(cluster.aio_create_completion(0, 0)); + auto my_completion1 = std::unique_ptr{Rados::aio_create_completion()};; ObjectWriteOperation op; char buf[128]; memset(buf, 0xcc, sizeof(buf)); @@ -1589,7 +1444,7 @@ TEST(LibRadosAioEC, RoundTripPP3) } EXPECT_EQ(0, my_completion1->get_return_value()); - boost::scoped_ptr my_completion2(cluster.aio_create_completion(0, 0)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; bl.clear(); ObjectReadOperation op1; op1.read(0, sizeof(buf), &bl, NULL); @@ -1609,15 +1464,13 @@ TEST(LibRadosAioEC, RoundTripPP3) TEST(LibRadosAio, RoundTripAppendPP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion.get(), bl1, sizeof(buf))); { TestAlarm alarm; @@ -1628,10 +1481,9 @@ TEST(LibRadosAio, RoundTripAppendPP) { memset(buf2, 0xdd, sizeof(buf2)); bufferlist bl2; bl2.append(buf2, sizeof(buf2)); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion2, + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion2.get(), bl2, sizeof(buf2))); { TestAlarm alarm; @@ -1639,11 +1491,10 @@ TEST(LibRadosAio, RoundTripAppendPP) { } ASSERT_EQ(0, my_completion2->get_return_value()); bufferlist bl3; - AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion3, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", - my_completion3, &bl3, 2 * sizeof(buf), 0)); + auto my_completion3 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion3); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3.get(), + &bl3, 2 * sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion3->wait_for_complete()); @@ -1652,9 +1503,6 @@ TEST(LibRadosAio, RoundTripAppendPP) { ASSERT_EQ(sizeof(buf) * 2, bl3.length()); ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf))); ASSERT_EQ(0, memcmp(bl3.c_str() + sizeof(buf), buf2, sizeof(buf2))); - delete my_completion; - delete my_completion2; - delete my_completion3; } TEST(LibRadosAioPP, RemoveTestPP) { @@ -1665,9 +1513,7 @@ TEST(LibRadosAioPP, RemoveTestPP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); ASSERT_EQ(0, test_data.m_ioctx.append("foo", bl1, sizeof(buf))); - boost::scoped_ptr my_completion - (test_data.m_cluster.aio_create_completion - (nullptr, nullptr)); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; ASSERT_EQ(0, test_data.m_ioctx.aio_remove("foo", my_completion.get())); { TestAlarm alarm; @@ -1681,15 +1527,13 @@ TEST(LibRadosAioPP, RemoveTestPP) { TEST(LibRadosAioEC, RoundTripSparseReadPP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -1699,28 +1543,23 @@ TEST(LibRadosAioEC, RoundTripSparseReadPP) { map extents; bufferlist bl2; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_sparse_read("foo", - my_completion2, &extents, &bl2, sizeof(buf), 0)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_sparse_read("foo", my_completion2.get(), + &extents, &bl2, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); } ASSERT_EQ(0, my_completion2->get_return_value()); assert_eq_sparse(bl1, extents, bl2); - delete my_completion; - delete my_completion2; } TEST(LibRadosAioEC, RoundTripAppendPP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); bool requires; ASSERT_EQ(0, test_data.m_ioctx.pool_requires_alignment2(&requires)); ASSERT_TRUE(requires); @@ -1732,7 +1571,7 @@ TEST(LibRadosAioEC, RoundTripAppendPP) { memset(buf, 0xcc, bsize); bufferlist bl1; bl1.append(buf, bsize); - ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion.get(), bl1, bsize)); { TestAlarm alarm; @@ -1745,10 +1584,9 @@ TEST(LibRadosAioEC, RoundTripAppendPP) { memset(buf2, 0xdd, hbsize); bufferlist bl2; bl2.append(buf2, hbsize); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion2, + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion2.get(), bl2, hbsize)); { TestAlarm alarm; @@ -1756,10 +1594,9 @@ TEST(LibRadosAioEC, RoundTripAppendPP) { } ASSERT_EQ(0, my_completion2->get_return_value()); - AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion3, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion3, + auto my_completion3 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion3); + ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion3.get(), bl2, hbsize)); { TestAlarm alarm; @@ -1768,11 +1605,10 @@ TEST(LibRadosAioEC, RoundTripAppendPP) { EXPECT_EQ(-EOPNOTSUPP, my_completion3->get_return_value()); bufferlist bl3; - AioCompletion *my_completion4 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion4, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", - my_completion4, &bl3, bsize * 3, 0)); + auto my_completion4 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion4); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion4.get(), + &bl3, bsize * 3, 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion4->wait_for_complete()); @@ -1782,9 +1618,6 @@ TEST(LibRadosAioEC, RoundTripAppendPP) { ASSERT_EQ((unsigned)tbsize, bl3.length()); ASSERT_EQ(0, memcmp(bl3.c_str(), buf, bsize)); ASSERT_EQ(0, memcmp(bl3.c_str() + bsize, buf2, hbsize)); - delete my_completion; - delete my_completion2; - delete my_completion3; delete[] buf; delete[] buf2; } @@ -1792,15 +1625,13 @@ TEST(LibRadosAioEC, RoundTripAppendPP) { TEST(LibRadosAioEC, IsCompletePP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -1808,10 +1639,9 @@ TEST(LibRadosAioEC, IsCompletePP) { } ASSERT_EQ(0, my_completion->get_return_value()); bufferlist bl2; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2, + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), &bl2, sizeof(buf), 0)); { TestAlarm alarm; @@ -1827,21 +1657,17 @@ TEST(LibRadosAioEC, IsCompletePP) { ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), bl2.length()); ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf))); - delete my_completion; - delete my_completion2; } TEST(LibRadosAioEC, IsSafePP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -1855,11 +1681,10 @@ TEST(LibRadosAioEC, IsSafePP) { } } ASSERT_EQ(0, my_completion->get_return_value()); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; bufferlist bl2; - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2, + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), &bl2, sizeof(buf), 0)); { TestAlarm alarm; @@ -1868,48 +1693,40 @@ TEST(LibRadosAioEC, IsSafePP) { ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), bl2.length()); ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf))); - delete my_completion; - delete my_completion2; } TEST(LibRadosAioEC, ReturnValuePP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); bufferlist bl1; - ASSERT_EQ(0, test_data.m_ioctx.aio_read("nonexistent", - my_completion, &bl1, 128, 0)); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("nonexistent", my_completion.get(), + &bl1, 128, 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); } ASSERT_EQ(-ENOENT, my_completion->get_return_value()); - delete my_completion; } TEST(LibRadosAioEC, FlushPP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xee, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); ASSERT_EQ(0, test_data.m_ioctx.aio_flush()); ASSERT_EQ(0, my_completion->get_return_value()); bufferlist bl2; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2, + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), &bl2, sizeof(buf), 0)); { TestAlarm alarm; @@ -1918,26 +1735,21 @@ TEST(LibRadosAioEC, FlushPP) { ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), bl2.length()); ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf))); - delete my_completion; - delete my_completion2; } TEST(LibRadosAioEC, FlushAsyncPP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *flush_completion = - test_data.m_cluster.aio_create_completion(NULL, NULL); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + auto flush_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xee, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); - ASSERT_EQ(0, test_data.m_ioctx.aio_flush_async(flush_completion)); + ASSERT_EQ(0, test_data.m_ioctx.aio_flush_async(flush_completion.get())); { TestAlarm alarm; ASSERT_EQ(0, flush_completion->wait_for_complete()); @@ -1946,10 +1758,9 @@ TEST(LibRadosAioEC, FlushAsyncPP) { ASSERT_EQ(1, flush_completion->is_complete()); ASSERT_EQ(0, my_completion->get_return_value()); bufferlist bl2; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2, + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2.get(), &bl2, sizeof(buf), 0)); { TestAlarm alarm; @@ -1958,23 +1769,18 @@ TEST(LibRadosAioEC, FlushAsyncPP) { ASSERT_EQ((int)sizeof(buf), my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), bl2.length()); ASSERT_EQ(0, memcmp(buf, bl2.c_str(), sizeof(buf))); - delete my_completion; - delete my_completion2; - delete flush_completion; } TEST(LibRadosAioEC, RoundTripWriteFullPP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -1985,20 +1791,18 @@ TEST(LibRadosAioEC, RoundTripWriteFullPP) { memset(buf2, 0xdd, sizeof(buf2)); bufferlist bl2; bl2.append(buf2, sizeof(buf2)); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_write_full("foo", my_completion2, bl2)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_write_full("foo", my_completion2.get(), bl2)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); } ASSERT_EQ(0, my_completion2->get_return_value()); bufferlist bl3; - AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion3, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3, + auto my_completion3 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion3); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3.get(), &bl3, sizeof(buf), 0)); { TestAlarm alarm; @@ -2007,9 +1811,6 @@ TEST(LibRadosAioEC, RoundTripWriteFullPP) { ASSERT_EQ((int)sizeof(buf2), my_completion3->get_return_value()); ASSERT_EQ(sizeof(buf2), bl3.length()); ASSERT_EQ(0, memcmp(bl3.c_str(), buf2, sizeof(buf2))); - delete my_completion; - delete my_completion2; - delete my_completion3; } //using ObjectWriteOperation/ObjectReadOperation with iohint @@ -2021,7 +1822,7 @@ TEST(LibRadosAioEC, RoundTripWriteFullPP2) IoCtx ioctx; cluster.ioctx_create(pool_name.c_str(), ioctx); - boost::scoped_ptr my_completion1(cluster.aio_create_completion(0, 0)); + auto my_completion1 = std::unique_ptr{Rados::aio_create_completion()}; ObjectWriteOperation op; char buf[128]; memset(buf, 0xcc, sizeof(buf)); @@ -2037,7 +1838,7 @@ TEST(LibRadosAioEC, RoundTripWriteFullPP2) } EXPECT_EQ(0, my_completion1->get_return_value()); - boost::scoped_ptr my_completion2(cluster.aio_create_completion(0, 0)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; bl.clear(); ObjectReadOperation op1; op1.read(0, sizeof(buf), &bl, NULL); @@ -2057,15 +1858,13 @@ TEST(LibRadosAioEC, RoundTripWriteFullPP2) TEST(LibRadosAioEC, SimpleStatPP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -2074,33 +1873,28 @@ TEST(LibRadosAioEC, SimpleStatPP) { ASSERT_EQ(0, my_completion->get_return_value()); uint64_t psize; time_t pmtime; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2, - &psize, &pmtime)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2.get(), + &psize, &pmtime)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); } ASSERT_EQ(0, my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), psize); - delete my_completion; - delete my_completion2; } TEST(LibRadosAioEC, SimpleStatPPNS) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -2109,33 +1903,28 @@ TEST(LibRadosAioEC, SimpleStatPPNS) { ASSERT_EQ(0, my_completion->get_return_value()); uint64_t psize; time_t pmtime; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2, - &psize, &pmtime)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2.get(), + &psize, &pmtime)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); } ASSERT_EQ(0, my_completion2->get_return_value()); ASSERT_EQ(sizeof(buf), psize); - delete my_completion; - delete my_completion2; } TEST(LibRadosAioEC, StatRemovePP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -2144,11 +1933,10 @@ TEST(LibRadosAioEC, StatRemovePP) { ASSERT_EQ(0, my_completion->get_return_value()); uint64_t psize; time_t pmtime; - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2, - &psize, &pmtime)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2.get(), + &psize, &pmtime)); { TestAlarm alarm; ASSERT_EQ(0, my_completion2->wait_for_complete()); @@ -2157,55 +1945,46 @@ TEST(LibRadosAioEC, StatRemovePP) { ASSERT_EQ(sizeof(buf), psize); uint64_t psize2; time_t pmtime2; - AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion3, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_remove("foo", my_completion3)); + auto my_completion3 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion3); + ASSERT_EQ(0, test_data.m_ioctx.aio_remove("foo", my_completion3.get())); { TestAlarm alarm; ASSERT_EQ(0, my_completion3->wait_for_complete()); } ASSERT_EQ(0, my_completion3->get_return_value()); - AioCompletion *my_completion4 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion4, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion4, + auto my_completion4 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion4); + ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion4.get(), &psize2, &pmtime2)); { TestAlarm alarm; ASSERT_EQ(0, my_completion4->wait_for_complete()); } ASSERT_EQ(-ENOENT, my_completion4->get_return_value()); - delete my_completion; - delete my_completion2; - delete my_completion3; - delete my_completion4; } TEST(LibRadosAioEC, ExecuteClassPP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; ASSERT_EQ(0, my_completion->wait_for_complete()); } ASSERT_EQ(0, my_completion->get_return_value()); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); bufferlist in, out; - ASSERT_EQ(0, test_data.m_ioctx.aio_exec("foo", my_completion2, + ASSERT_EQ(0, test_data.m_ioctx.aio_exec("foo", my_completion2.get(), "hello", "say_hello", in, &out)); { TestAlarm alarm; @@ -2213,8 +1992,6 @@ TEST(LibRadosAioEC, ExecuteClassPP) { } ASSERT_EQ(0, my_completion2->get_return_value()); ASSERT_EQ(std::string("Hello, world!"), std::string(out.c_str(), out.length())); - delete my_completion; - delete my_completion2; } TEST(LibRadosAioEC, OmapPP) { @@ -2230,7 +2007,7 @@ TEST(LibRadosAioEC, OmapPP) { header_to_set.push_back(bp); map to_set; { - boost::scoped_ptr my_completion(cluster.aio_create_completion(0, 0)); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; ObjectWriteOperation op; to_set["foo"] = header_to_set; to_set["foo2"] = header_to_set; @@ -2253,15 +2030,13 @@ TEST(LibRadosAioEC, OmapPP) { TEST(LibRadosAioEC, MultiWritePP) { AioTestDataECPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl1; bl1.append(buf, sizeof(buf)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(buf), 0)); { TestAlarm alarm; @@ -2273,10 +2048,9 @@ TEST(LibRadosAioEC, MultiWritePP) { memset(buf2, 0xdd, sizeof(buf2)); bufferlist bl2; bl2.append(buf2, sizeof(buf2)); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion2, + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion2.get(), bl2, sizeof(buf2), sizeof(buf))); { TestAlarm alarm; @@ -2285,10 +2059,9 @@ TEST(LibRadosAioEC, MultiWritePP) { ASSERT_EQ(-EOPNOTSUPP, my_completion2->get_return_value()); bufferlist bl3; - AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion3, my_completion_null); - ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3, + auto my_completion3 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion3); + ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3.get(), &bl3, (sizeof(buf) + sizeof(buf2) * 3), 0)); { TestAlarm alarm; @@ -2297,26 +2070,22 @@ TEST(LibRadosAioEC, MultiWritePP) { ASSERT_EQ((int)sizeof(buf), my_completion3->get_return_value()); ASSERT_EQ(sizeof(buf), bl3.length()); ASSERT_EQ(0, memcmp(bl3.c_str(), buf, sizeof(buf))); - delete my_completion; - delete my_completion2; - delete my_completion3; + } TEST(LibRadosAio, RacingRemovePP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init({{"objecter_retry_writes_after_first_reply", "true"}})); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion, nullptr); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char buf[128]; memset(buf, 0xcc, sizeof(buf)); bufferlist bl; bl.append(buf, sizeof(buf)); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_NE(my_completion2, nullptr); - ASSERT_EQ(0, test_data.m_ioctx.aio_remove("foo", my_completion2)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion2); + ASSERT_EQ(0, test_data.m_ioctx.aio_remove("foo", my_completion2.get())); + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl, sizeof(buf), 0)); { TestAlarm alarm; @@ -2326,22 +2095,18 @@ TEST(LibRadosAio, RacingRemovePP) { ASSERT_EQ(-ENOENT, my_completion2->get_return_value()); ASSERT_EQ(0, my_completion->get_return_value()); ASSERT_EQ(0, test_data.m_ioctx.stat("foo", nullptr, nullptr)); - delete my_completion; - delete my_completion2; } TEST(LibRadosAio, RoundTripCmpExtPP) { AioTestDataPP test_data; ASSERT_EQ("", test_data.init()); - AioCompletion *my_completion = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - AioCompletion *my_completion_null = NULL; - ASSERT_NE(my_completion, my_completion_null); + auto my_completion = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_TRUE(my_completion); char full[128]; memset(full, 0xcc, sizeof(full)); bufferlist bl1; bl1.append(full, sizeof(full)); - ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion, + ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion.get(), bl1, sizeof(full), 0)); { TestAlarm alarm; @@ -2352,9 +2117,8 @@ TEST(LibRadosAio, RoundTripCmpExtPP) { /* compare with match */ bufferlist cbl; cbl.append(full, sizeof(full)); - AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_EQ(0, test_data.m_ioctx.aio_cmpext("foo", my_completion2, 0, cbl)); + auto my_completion2 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_EQ(0, test_data.m_ioctx.aio_cmpext("foo", my_completion2.get(), 0, cbl)); { TestAlarm alarm; @@ -2366,19 +2130,13 @@ TEST(LibRadosAio, RoundTripCmpExtPP) { memset(full, 0xdd, sizeof(full)); cbl.clear(); cbl.append(full, sizeof(full)); - AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion( - nullptr, nullptr); - ASSERT_EQ(0, test_data.m_ioctx.aio_cmpext("foo", my_completion3, 0, cbl)); - + auto my_completion3 = std::unique_ptr{Rados::aio_create_completion()}; + ASSERT_EQ(0, test_data.m_ioctx.aio_cmpext("foo", my_completion3.get(), 0, cbl)); { TestAlarm alarm; ASSERT_EQ(0, my_completion3->wait_for_complete()); } ASSERT_EQ(-MAX_ERRNO, my_completion3->get_return_value()); - - delete my_completion; - delete my_completion2; - delete my_completion3; } TEST(LibRadosAio, RoundTripCmpExtPP2) @@ -2393,8 +2151,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP2) IoCtx ioctx; cluster.ioctx_create(pool_name.c_str(), ioctx); - boost::scoped_ptr - wr_cmpl(cluster.aio_create_completion(0, 0)); + auto wr_cmpl = std::unique_ptr{Rados::aio_create_completion()}; ObjectWriteOperation wr_op; memset(buf, 0xcc, sizeof(buf)); memset(miscmp_buf, 0xdd, sizeof(miscmp_buf)); @@ -2411,8 +2168,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP2) EXPECT_EQ(0, wr_cmpl->get_return_value()); /* cmpext as write op. first match then mismatch */ - boost::scoped_ptr - wr_cmpext_cmpl(cluster.aio_create_completion(0, 0)); + auto wr_cmpext_cmpl = std::unique_ptr{Rados::aio_create_completion()}; cbl.append(buf, sizeof(buf)); ret = 0; @@ -2426,8 +2182,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP2) EXPECT_EQ(0, wr_cmpext_cmpl->get_return_value()); EXPECT_EQ(0, ret); - boost::scoped_ptr - wr_cmpext_cmpl2(cluster.aio_create_completion(0, 0)); + auto wr_cmpext_cmpl2 = std::unique_ptr{Rados::aio_create_completion()}; cbl.clear(); cbl.append(miscmp_buf, sizeof(miscmp_buf)); ret = 0; @@ -2443,8 +2198,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP2) EXPECT_EQ(-MAX_ERRNO, ret); /* cmpext as read op */ - boost::scoped_ptr - rd_cmpext_cmpl(cluster.aio_create_completion(0, 0)); + auto rd_cmpext_cmpl = std::unique_ptr{Rados::aio_create_completion()}; ObjectReadOperation rd_op; cbl.clear(); cbl.append(buf, sizeof(buf)); @@ -2459,8 +2213,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP2) EXPECT_EQ(0, rd_cmpext_cmpl->get_return_value()); EXPECT_EQ(0, ret); - boost::scoped_ptr - rd_cmpext_cmpl2(cluster.aio_create_completion(0, 0)); + auto rd_cmpext_cmpl2 = std::unique_ptr{Rados::aio_create_completion()}; cbl.clear(); cbl.append(miscmp_buf, sizeof(miscmp_buf)); ret = 0; -- 2.39.5