test/librados: Un-deprecated version of aio_create_completion

Signed-off-by: Adam C. Emerson <aemerson@redhat.com>

diff --git a/src/test/librados/aio_cxx.cc b/src/test/librados/aio_cxx.cc
index 341391012cf9077803300cc39b06cd32d4c2a964..293c0a780acff4403a2b91a4ff6550f028dcc473 100644 (file)
--- a/src/test/librados/aio_cxx.cc
+++ b/src/test/librados/aio_cxx.cc
@@ -74,7 +74,8 @@ TEST(LibRadosAio, TooBigPP) {
   ASSERT_EQ("", test_data.init());
 
   bufferlist bl;
-  AioCompletion *aio_completion = test_data.m_cluster.aio_create_completion(nullptr, NULL, NULL);
+  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));
   // ioctx.aio_write_full no way to overflow bl.length()
@@ -129,7 +130,7 @@ TEST(LibRadosAio, PoolQuotaPP) {
       test_data.m_cluster.aio_create_completion();
     ASSERT_EQ(0, ioctx.aio_operate("bar", completion, &op, 0));
     sleep(5);
-    ASSERT_FALSE(completion->is_safe());
+    ASSERT_FALSE(completion->is_complete());
     completion->release();
   }
 
@@ -145,8 +146,8 @@ TEST(LibRadosAio, SimpleWritePP) {
   {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
-  AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+  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",
@@ -163,8 +164,8 @@ TEST(LibRadosAio, SimpleWritePP) {
   AioTestDataPP 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, nullptr);
+  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));
   {
@@ -179,8 +180,8 @@ TEST(LibRadosAio, SimpleWritePP) {
 TEST(LibRadosAio, WaitForSafePP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
-  AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+  AioCompletion *my_completion =
+    test_data.m_cluster.aio_create_completion(nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -199,7 +200,7 @@ TEST(LibRadosAio, RoundTripPP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -215,7 +216,7 @@ TEST(LibRadosAio, RoundTripPP) {
   ASSERT_EQ(0, my_completion->get_return_value());
   bufferlist bl2;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         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));
@@ -234,7 +235,7 @@ TEST(LibRadosAio, RoundTripPP2) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -250,7 +251,7 @@ TEST(LibRadosAio, RoundTripPP2) {
   ASSERT_EQ(0, my_completion->get_return_value());
   bufferlist bl2;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         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));
@@ -274,7 +275,8 @@ TEST(LibRadosAio, RoundTripPP3)
   IoCtx ioctx;
   cluster.ioctx_create(pool_name.c_str(), ioctx);
 
-  boost::scoped_ptr<AioCompletion> my_completion1(cluster.aio_create_completion(0, 0, 0));
+  boost::scoped_ptr<AioCompletion> my_completion1(
+    cluster.aio_create_completion(nullptr, nullptr));
   ObjectWriteOperation op;
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
@@ -290,7 +292,8 @@ TEST(LibRadosAio, RoundTripPP3)
   }
   EXPECT_EQ(0, my_completion1->get_return_value());
 
-  boost::scoped_ptr<AioCompletion> my_completion2(cluster.aio_create_completion(0, 0, 0));
+  boost::scoped_ptr<AioCompletion> my_completion2(
+    cluster.aio_create_completion(nullptr, nullptr));
   bl.clear();
   ObjectReadOperation op1;
   op1.read(0, sizeof(buf), &bl, NULL);
@@ -324,7 +327,7 @@ TEST(LibRadosAio, RoundTripSparseReadPP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -341,7 +344,7 @@ TEST(LibRadosAio, RoundTripSparseReadPP) {
   std::map<uint64_t, uint64_t> extents;
   bufferlist bl2;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         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));
@@ -363,7 +366,7 @@ TEST(LibRadosAioPP, ReadIntoBufferlist) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -383,7 +386,7 @@ TEST(LibRadosAioPP, ReadIntoBufferlist) {
   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, nullptr);
+    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));
@@ -411,7 +414,7 @@ TEST(LibRadosAioPP, XattrsRoundTripPP) {
   // async getxattr
   boost::scoped_ptr<AioCompletion> my_completion
     (test_data.m_cluster.aio_create_completion
-     (nullptr, nullptr, nullptr));
+     (nullptr, nullptr));
   ASSERT_EQ(0, test_data.m_ioctx.aio_getxattr("foo", my_completion.get(), attr1, bl2));
   {
     TestAlarm alarm;
@@ -426,7 +429,7 @@ TEST(LibRadosAioPP, XattrsRoundTripPP) {
   ASSERT_EQ("", test_data2.init());
   boost::scoped_ptr<AioCompletion> my_completion2
     (test_data.m_cluster.aio_create_completion
-     (nullptr, nullptr, nullptr));
+     (nullptr, nullptr));
   ASSERT_EQ(0, test_data.m_ioctx.aio_setxattr("foo", my_completion2.get(), attr1, bl3));
   {
     TestAlarm alarm;
@@ -439,7 +442,7 @@ TEST(LibRadosAioPP, XattrsRoundTripPP) {
   ASSERT_EQ("", test_data3.init());
   boost::scoped_ptr<AioCompletion> my_completion3
     (test_data.m_cluster.aio_create_completion
-     (nullptr, nullptr, nullptr));
+     (nullptr, nullptr));
   ASSERT_EQ(0, test_data.m_ioctx.aio_getxattr("foo", my_completion3.get(), attr1, bl4));
   {
     TestAlarm alarm;
@@ -465,7 +468,7 @@ TEST(LibRadosAioPP, RmXattrPP) {
   bl2.append(attr1_buf, sizeof(attr1_buf));
   boost::scoped_ptr<AioCompletion> my_completion
     (test_data.m_cluster.aio_create_completion
-     (nullptr, nullptr, nullptr));
+     (nullptr, nullptr));
   ASSERT_EQ(0, test_data.m_ioctx.aio_setxattr("foo", my_completion.get(), attr1, bl2));
   {
     TestAlarm alarm;
@@ -477,7 +480,7 @@ TEST(LibRadosAioPP, RmXattrPP) {
   ASSERT_EQ("", test_data2.init());
   boost::scoped_ptr<AioCompletion> my_completion2
     (test_data.m_cluster.aio_create_completion
-     (nullptr, nullptr, nullptr));
+     (nullptr, nullptr));
   ASSERT_EQ(0, test_data.m_ioctx.aio_rmxattr("foo", my_completion2.get(), attr1));
   {
     TestAlarm alarm;
@@ -489,7 +492,7 @@ TEST(LibRadosAioPP, RmXattrPP) {
   ASSERT_EQ("", test_data3.init());
   boost::scoped_ptr<AioCompletion> my_completion3
     (test_data.m_cluster.aio_create_completion
-     (nullptr, nullptr, nullptr));
+     (nullptr, nullptr));
   bufferlist bl3;
   ASSERT_EQ(0, test_data.m_ioctx.aio_getxattr("foo", my_completion3.get(), attr1, bl3));
   {
@@ -512,7 +515,7 @@ TEST(LibRadosAioPP, RmXattrPP) {
   ASSERT_EQ("", test_data4.init());
   boost::scoped_ptr<AioCompletion> my_completion4
     (test_data.m_cluster.aio_create_completion
-     (nullptr, nullptr, nullptr));
+     (nullptr, nullptr));
   ASSERT_EQ(0, test_data.m_ioctx.aio_setxattr("foo_rmxattr", my_completion4.get(), attr2, bl22));
   {
     TestAlarm alarm;
@@ -526,7 +529,7 @@ TEST(LibRadosAioPP, RmXattrPP) {
   ASSERT_EQ("", test_data5.init());
   boost::scoped_ptr<AioCompletion> my_completion5
     (test_data.m_cluster.aio_create_completion
-     (nullptr, nullptr, nullptr));
+     (nullptr, nullptr));
   ASSERT_EQ(0, test_data.m_ioctx.aio_rmxattr("foo_rmxattr", my_completion5.get(), attr2));
   {
     TestAlarm alarm;
@@ -560,7 +563,7 @@ TEST(LibRadosIoPP, XattrListPP) {
   // call async version of getxattrs
   boost::scoped_ptr<AioCompletion> my_completion
     (test_data.m_cluster.aio_create_completion
-     (nullptr, nullptr, nullptr));
+     (nullptr, nullptr));
   std::map<std::string, bufferlist> attrset;
   ASSERT_EQ(0, test_data.m_ioctx.aio_getxattrs("foo", my_completion.get(), attrset));
   {
@@ -586,7 +589,7 @@ TEST(LibRadosAio, IsCompletePP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -602,7 +605,7 @@ 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, nullptr);
+         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));
@@ -628,7 +631,7 @@ TEST(LibRadosAio, IsSafePP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -643,14 +646,14 @@ TEST(LibRadosAio, IsSafePP) {
     // Busy-wait until the AIO completes.
     // Normally we wouldn't do this, but we want to test rados_aio_is_safe.
     while (true) {
-      int is_safe = my_completion->is_safe();
-      if (is_safe)
+      int is_complete = my_completion->is_complete();
+      if (is_complete)
        break;
     }
   }
   ASSERT_EQ(0, my_completion->get_return_value());
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   bufferlist bl2;
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2,
@@ -670,7 +673,7 @@ TEST(LibRadosAio, ReturnValuePP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   bufferlist bl1;
@@ -688,7 +691,7 @@ TEST(LibRadosAio, FlushPP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -701,7 +704,7 @@ TEST(LibRadosAio, FlushPP) {
   ASSERT_EQ(0, my_completion->get_return_value());
   bufferlist bl2;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         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));
@@ -720,9 +723,9 @@ TEST(LibRadosAio, FlushAsyncPP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *flush_completion =
-      test_data.m_cluster.aio_create_completion(NULL, NULL, NULL);
+      test_data.m_cluster.aio_create_completion(NULL, NULL);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -737,13 +740,11 @@ TEST(LibRadosAio, FlushAsyncPP) {
       ASSERT_EQ(0, flush_completion->wait_for_complete());
   }
   ASSERT_EQ(1, my_completion->is_complete());
-  ASSERT_EQ(1, my_completion->is_safe());
   ASSERT_EQ(1, flush_completion->is_complete());
-  ASSERT_EQ(1, flush_completion->is_safe());
   ASSERT_EQ(0, my_completion->get_return_value());
   bufferlist bl2;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         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));
@@ -763,7 +764,7 @@ TEST(LibRadosAio, RoundTripWriteFullPP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -782,7 +783,7 @@ TEST(LibRadosAio, RoundTripWriteFullPP) {
   bufferlist bl2;
   bl2.append(buf2, sizeof(buf2));
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_write_full("foo", my_completion2, bl2));
   {
@@ -792,7 +793,7 @@ TEST(LibRadosAio, RoundTripWriteFullPP) {
   ASSERT_EQ(0, my_completion2->get_return_value());
   bufferlist bl3;
   AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion3, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3,
                                          &bl3, sizeof(buf), 0));
@@ -817,7 +818,7 @@ TEST(LibRadosAio, RoundTripWriteFullPP2)
   IoCtx ioctx;
   cluster.ioctx_create(pool_name.c_str(), ioctx);
 
-  boost::scoped_ptr<AioCompletion> my_completion1(cluster.aio_create_completion(0, 0, 0));
+  boost::scoped_ptr<AioCompletion> my_completion1(cluster.aio_create_completion(0, 0));
   ObjectWriteOperation op;
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
@@ -833,7 +834,7 @@ TEST(LibRadosAio, RoundTripWriteFullPP2)
   }
   EXPECT_EQ(0, my_completion1->get_return_value());
 
-  boost::scoped_ptr<AioCompletion> my_completion2(cluster.aio_create_completion(0, 0, 0));
+  boost::scoped_ptr<AioCompletion> my_completion2(cluster.aio_create_completion(0, 0));
   bl.clear();
   ObjectReadOperation op1;
   op1.read(0, sizeof(buf), &bl, NULL);
@@ -854,7 +855,7 @@ TEST(LibRadosAio, RoundTripWriteSamePP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char full[128];
@@ -875,7 +876,7 @@ TEST(LibRadosAio, RoundTripWriteSamePP) {
   bufferlist bl2;
   bl2.append(buf, sizeof(buf));
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_writesame("foo", my_completion2, bl2,
                                               ws_write_len, 0));
@@ -886,7 +887,7 @@ 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, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion3, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3,
                                          &bl3, sizeof(full), 0));
@@ -914,7 +915,7 @@ TEST(LibRadosAio, RoundTripWriteSamePP2)
   cluster.ioctx_create(pool_name.c_str(), ioctx);
 
   boost::scoped_ptr<AioCompletion>
-                       wr_cmpl(cluster.aio_create_completion(0, 0, 0));
+                       wr_cmpl(cluster.aio_create_completion(0, 0));
   ObjectWriteOperation op;
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
@@ -931,7 +932,7 @@ TEST(LibRadosAio, RoundTripWriteSamePP2)
   EXPECT_EQ(0, wr_cmpl->get_return_value());
 
   boost::scoped_ptr<AioCompletion>
-                       rd_cmpl(cluster.aio_create_completion(0, 0, 0));
+                       rd_cmpl(cluster.aio_create_completion(0, 0));
   char *cmp;
   char full[sizeof(buf) * 4];
   memset(full, 0, sizeof(full));
@@ -958,7 +959,7 @@ TEST(LibRadosAio, SimpleStatPPNS) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -975,10 +976,10 @@ TEST(LibRadosAio, SimpleStatPPNS) {
   uint64_t psize;
   time_t pmtime;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2,
-                                       &psize, &pmtime));
+                                          &psize, &pmtime));
   {
     TestAlarm alarm;
     ASSERT_EQ(0, my_completion2->wait_for_complete());
@@ -993,7 +994,7 @@ TEST(LibRadosAio, SimpleStatPP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1010,10 +1011,10 @@ TEST(LibRadosAio, SimpleStatPP) {
   uint64_t psize;
   time_t pmtime;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2,
-                                       &psize, &pmtime));
+                                          &psize, &pmtime));
   {
     TestAlarm alarm;
     ASSERT_EQ(0, my_completion2->wait_for_complete());
@@ -1028,7 +1029,7 @@ TEST(LibRadosAio, StatRemovePP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1045,10 +1046,10 @@ TEST(LibRadosAio, StatRemovePP) {
   uint64_t psize;
   time_t pmtime;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2,
-                                       &psize, &pmtime));
+                                          &psize, &pmtime));
   {
     TestAlarm alarm;
     ASSERT_EQ(0, my_completion2->wait_for_complete());
@@ -1058,7 +1059,7 @@ TEST(LibRadosAio, StatRemovePP) {
   uint64_t psize2;
   time_t pmtime2;
   AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion3, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_remove("foo", my_completion3));
   {
@@ -1068,7 +1069,7 @@ TEST(LibRadosAio, StatRemovePP) {
   ASSERT_EQ(0, my_completion3->get_return_value());
 
   AioCompletion *my_completion4 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion4, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion4,
                                        &psize2, &pmtime2));
@@ -1087,7 +1088,7 @@ TEST(LibRadosAio, ExecuteClassPP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1102,7 +1103,7 @@ TEST(LibRadosAio, ExecuteClassPP) {
   }
   ASSERT_EQ(0, my_completion->get_return_value());
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   bufferlist in, out;
   ASSERT_EQ(0, test_data.m_ioctx.aio_exec("foo", my_completion2,
@@ -1134,7 +1135,7 @@ TEST(LibRadosAio, OmapPP) {
   header_to_set.push_back(bp);
   map<string, bufferlist> to_set;
   {
-    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0));
     ObjectWriteOperation op;
     to_set["foo"] = header_to_set;
     to_set["foo2"] = header_to_set;
@@ -1152,7 +1153,7 @@ TEST(LibRadosAio, OmapPP) {
   }
 
   {
-    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0));
     ObjectReadOperation op;
     map<string, pair<bufferlist, int> > assertions;
     bufferlist val;
@@ -1172,7 +1173,7 @@ TEST(LibRadosAio, OmapPP) {
   }
 
   {
-    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0));
     ObjectReadOperation op;
 
     set<string> set_got;
@@ -1216,7 +1217,7 @@ TEST(LibRadosAio, OmapPP) {
   }
 
   {
-    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0));
     ObjectWriteOperation op;
     set<string> to_remove;
     to_remove.insert("foo2");
@@ -1230,7 +1231,7 @@ TEST(LibRadosAio, OmapPP) {
   }
 
   {
-    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0));
     ObjectReadOperation op;
 
     set<string> set_got;
@@ -1245,7 +1246,7 @@ TEST(LibRadosAio, OmapPP) {
   }
 
   {
-    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0));
     ObjectWriteOperation op;
     op.omap_clear();
     ioctx.aio_operate("test_obj", my_completion.get(), &op);
@@ -1257,7 +1258,7 @@ TEST(LibRadosAio, OmapPP) {
   }
 
   {
-    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0));
     ObjectReadOperation op;
 
     set<string> set_got;
@@ -1273,7 +1274,7 @@ TEST(LibRadosAio, OmapPP) {
 
   // omap_clear clears header *and* keys
   {
-    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0));
     ObjectWriteOperation op;
     bufferlist bl;
     bl.append("some data");
@@ -1291,7 +1292,7 @@ TEST(LibRadosAio, OmapPP) {
     EXPECT_EQ(0, my_completion->get_return_value());
   }
   {
-    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0));
     ObjectWriteOperation op;
     op.omap_clear();
     ioctx.aio_operate("foo3", my_completion.get(), &op);
@@ -1302,7 +1303,7 @@ TEST(LibRadosAio, OmapPP) {
     EXPECT_EQ(0, my_completion->get_return_value());
   }
   {
-    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0));
     ObjectReadOperation op;
     set<string> set_got;
     bufferlist hdr;
@@ -1326,7 +1327,7 @@ TEST(LibRadosAio, MultiWritePP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1346,7 +1347,7 @@ TEST(LibRadosAio, MultiWritePP) {
   bufferlist bl2;
   bl2.append(buf2, sizeof(buf2));
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion2,
                                           bl2, sizeof(buf2), sizeof(buf)));
@@ -1358,7 +1359,7 @@ TEST(LibRadosAio, MultiWritePP) {
 
   bufferlist bl3;
   AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion3, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3,
                                          &bl3, (sizeof(buf) + sizeof(buf2) * 3), 0));
@@ -1381,7 +1382,7 @@ TEST(LibRadosAio, AioUnlockPP) {
   ASSERT_EQ(0, test_data.m_ioctx.lock_exclusive("foo", "TestLock", "Cookie", "", NULL, 0));
   boost::scoped_ptr<AioCompletion> my_completion
     (test_data.m_cluster.aio_create_completion
-     (nullptr, nullptr, nullptr));
+     (nullptr, nullptr));
   ASSERT_EQ(0, test_data.m_ioctx.aio_unlock("foo", "TestLock", "Cookie", my_completion.get()));
   {
     TestAlarm alarm;
@@ -1444,7 +1445,7 @@ TEST(LibRadosAioEC, SimpleWritePP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo",
@@ -1462,7 +1463,7 @@ TEST(LibRadosAioEC, SimpleWritePP) {
   ASSERT_EQ("", test_data.init());
   test_data.m_ioctx.set_namespace("nspace");
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo",
                               my_completion, bl1, sizeof(buf), 0));
   {
@@ -1478,7 +1479,7 @@ TEST(LibRadosAioEC, WaitForSafePP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1497,7 +1498,7 @@ TEST(LibRadosAioEC, RoundTripPP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1513,7 +1514,7 @@ 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, nullptr);
+         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));
@@ -1532,7 +1533,7 @@ TEST(LibRadosAioEC, RoundTripPP2) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1548,7 +1549,7 @@ 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, nullptr);
+         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));
@@ -1572,7 +1573,7 @@ TEST(LibRadosAioEC, RoundTripPP3)
   IoCtx ioctx;
   cluster.ioctx_create(pool_name.c_str(), ioctx);
 
-  boost::scoped_ptr<AioCompletion> my_completion1(cluster.aio_create_completion(0, 0, 0));
+  boost::scoped_ptr<AioCompletion> my_completion1(cluster.aio_create_completion(0, 0));
   ObjectWriteOperation op;
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
@@ -1588,7 +1589,7 @@ TEST(LibRadosAioEC, RoundTripPP3)
   }
   EXPECT_EQ(0, my_completion1->get_return_value());
 
-  boost::scoped_ptr<AioCompletion> my_completion2(cluster.aio_create_completion(0, 0, 0));
+  boost::scoped_ptr<AioCompletion> my_completion2(cluster.aio_create_completion(0, 0));
   bl.clear();
   ObjectReadOperation op1;
   op1.read(0, sizeof(buf), &bl, NULL);
@@ -1609,7 +1610,7 @@ TEST(LibRadosAio, RoundTripAppendPP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1628,7 +1629,7 @@ TEST(LibRadosAio, RoundTripAppendPP) {
   bufferlist bl2;
   bl2.append(buf2, sizeof(buf2));
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion2,
                                            bl2, sizeof(buf2)));
@@ -1639,7 +1640,7 @@ 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, nullptr);
+         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));
@@ -1666,7 +1667,7 @@ TEST(LibRadosAioPP, RemoveTestPP) {
   ASSERT_EQ(0, test_data.m_ioctx.append("foo", bl1, sizeof(buf)));
   boost::scoped_ptr<AioCompletion> my_completion
     (test_data.m_cluster.aio_create_completion
-     (nullptr, nullptr, nullptr));
+     (nullptr, nullptr));
   ASSERT_EQ(0, test_data.m_ioctx.aio_remove("foo", my_completion.get()));
   {
     TestAlarm alarm;
@@ -1681,7 +1682,7 @@ TEST(LibRadosAioEC, RoundTripSparseReadPP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1699,7 +1700,7 @@ TEST(LibRadosAioEC, RoundTripSparseReadPP) {
   map<uint64_t, uint64_t> extents;
   bufferlist bl2;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         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));
@@ -1717,7 +1718,7 @@ TEST(LibRadosAioEC, RoundTripAppendPP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   bool requires;
@@ -1745,7 +1746,7 @@ TEST(LibRadosAioEC, RoundTripAppendPP) {
   bufferlist bl2;
   bl2.append(buf2, hbsize);
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion2,
                                            bl2, hbsize));
@@ -1756,7 +1757,7 @@ TEST(LibRadosAioEC, RoundTripAppendPP) {
   ASSERT_EQ(0, my_completion2->get_return_value());
 
   AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion3, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_append("foo", my_completion3,
                                            bl2, hbsize));
@@ -1768,7 +1769,7 @@ TEST(LibRadosAioEC, RoundTripAppendPP) {
 
   bufferlist bl3;
   AioCompletion *my_completion4 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         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));
@@ -1792,7 +1793,7 @@ TEST(LibRadosAioEC, IsCompletePP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1808,7 +1809,7 @@ 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, nullptr);
+         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));
@@ -1833,7 +1834,7 @@ TEST(LibRadosAioEC, IsSafePP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1848,14 +1849,14 @@ TEST(LibRadosAioEC, IsSafePP) {
     // Busy-wait until the AIO completes.
     // Normally we wouldn't do this, but we want to test rados_aio_is_safe.
     while (true) {
-      int is_safe = my_completion->is_safe();
-      if (is_safe)
+      int is_complete = my_completion->is_complete();
+      if (is_complete)
        break;
     }
   }
   ASSERT_EQ(0, my_completion->get_return_value());
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   bufferlist bl2;
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion2,
@@ -1875,7 +1876,7 @@ TEST(LibRadosAioEC, ReturnValuePP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   bufferlist bl1;
@@ -1893,7 +1894,7 @@ TEST(LibRadosAioEC, FlushPP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1906,7 +1907,7 @@ TEST(LibRadosAioEC, FlushPP) {
   ASSERT_EQ(0, my_completion->get_return_value());
   bufferlist bl2;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         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));
@@ -1925,9 +1926,9 @@ TEST(LibRadosAioEC, FlushAsyncPP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *flush_completion =
-      test_data.m_cluster.aio_create_completion(NULL, NULL, NULL);
+      test_data.m_cluster.aio_create_completion(NULL, NULL);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1942,13 +1943,11 @@ TEST(LibRadosAioEC, FlushAsyncPP) {
       ASSERT_EQ(0, flush_completion->wait_for_complete());
   }
   ASSERT_EQ(1, my_completion->is_complete());
-  ASSERT_EQ(1, my_completion->is_safe());
   ASSERT_EQ(1, flush_completion->is_complete());
-  ASSERT_EQ(1, flush_completion->is_safe());
   ASSERT_EQ(0, my_completion->get_return_value());
   bufferlist bl2;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         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));
@@ -1968,7 +1967,7 @@ TEST(LibRadosAioEC, RoundTripWriteFullPP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -1987,7 +1986,7 @@ TEST(LibRadosAioEC, RoundTripWriteFullPP) {
   bufferlist bl2;
   bl2.append(buf2, sizeof(buf2));
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_write_full("foo", my_completion2, bl2));
   {
@@ -1997,7 +1996,7 @@ TEST(LibRadosAioEC, RoundTripWriteFullPP) {
   ASSERT_EQ(0, my_completion2->get_return_value());
   bufferlist bl3;
   AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion3, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3,
                                          &bl3, sizeof(buf), 0));
@@ -2022,7 +2021,7 @@ TEST(LibRadosAioEC, RoundTripWriteFullPP2)
   IoCtx ioctx;
   cluster.ioctx_create(pool_name.c_str(), ioctx);
 
-  boost::scoped_ptr<AioCompletion> my_completion1(cluster.aio_create_completion(0, 0, 0));
+  boost::scoped_ptr<AioCompletion> my_completion1(cluster.aio_create_completion(0, 0));
   ObjectWriteOperation op;
   char buf[128];
   memset(buf, 0xcc, sizeof(buf));
@@ -2038,7 +2037,7 @@ TEST(LibRadosAioEC, RoundTripWriteFullPP2)
   }
   EXPECT_EQ(0, my_completion1->get_return_value());
 
-  boost::scoped_ptr<AioCompletion> my_completion2(cluster.aio_create_completion(0, 0, 0));
+  boost::scoped_ptr<AioCompletion> my_completion2(cluster.aio_create_completion(0, 0));
   bl.clear();
   ObjectReadOperation op1;
   op1.read(0, sizeof(buf), &bl, NULL);
@@ -2059,7 +2058,7 @@ TEST(LibRadosAioEC, SimpleStatPP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -2076,10 +2075,10 @@ TEST(LibRadosAioEC, SimpleStatPP) {
   uint64_t psize;
   time_t pmtime;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2,
-                                       &psize, &pmtime));
+                                          &psize, &pmtime));
   {
     TestAlarm alarm;
     ASSERT_EQ(0, my_completion2->wait_for_complete());
@@ -2094,7 +2093,7 @@ TEST(LibRadosAioEC, SimpleStatPPNS) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -2111,10 +2110,10 @@ TEST(LibRadosAioEC, SimpleStatPPNS) {
   uint64_t psize;
   time_t pmtime;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2,
-                                       &psize, &pmtime));
+                                          &psize, &pmtime));
   {
     TestAlarm alarm;
     ASSERT_EQ(0, my_completion2->wait_for_complete());
@@ -2129,7 +2128,7 @@ TEST(LibRadosAioEC, StatRemovePP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -2146,10 +2145,10 @@ TEST(LibRadosAioEC, StatRemovePP) {
   uint64_t psize;
   time_t pmtime;
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion2,
-                                       &psize, &pmtime));
+                                          &psize, &pmtime));
   {
     TestAlarm alarm;
     ASSERT_EQ(0, my_completion2->wait_for_complete());
@@ -2159,7 +2158,7 @@ TEST(LibRadosAioEC, StatRemovePP) {
   uint64_t psize2;
   time_t pmtime2;
   AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion3, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_remove("foo", my_completion3));
   {
@@ -2169,7 +2168,7 @@ TEST(LibRadosAioEC, StatRemovePP) {
   ASSERT_EQ(0, my_completion3->get_return_value());
 
   AioCompletion *my_completion4 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion4, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_stat("foo", my_completion4,
                                        &psize2, &pmtime2));
@@ -2188,7 +2187,7 @@ TEST(LibRadosAioEC, ExecuteClassPP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -2203,7 +2202,7 @@ TEST(LibRadosAioEC, ExecuteClassPP) {
   }
   ASSERT_EQ(0, my_completion->get_return_value());
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   bufferlist in, out;
   ASSERT_EQ(0, test_data.m_ioctx.aio_exec("foo", my_completion2,
@@ -2231,7 +2230,7 @@ TEST(LibRadosAioEC, OmapPP) {
   header_to_set.push_back(bp);
   map<string, bufferlist> to_set;
   {
-    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0, 0));
+    boost::scoped_ptr<AioCompletion> my_completion(cluster.aio_create_completion(0, 0));
     ObjectWriteOperation op;
     to_set["foo"] = header_to_set;
     to_set["foo2"] = header_to_set;
@@ -2255,7 +2254,7 @@ TEST(LibRadosAioEC, MultiWritePP) {
   AioTestDataECPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char buf[128];
@@ -2275,7 +2274,7 @@ TEST(LibRadosAioEC, MultiWritePP) {
   bufferlist bl2;
   bl2.append(buf2, sizeof(buf2));
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion2, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_write("foo", my_completion2,
                                           bl2, sizeof(buf2), sizeof(buf)));
@@ -2287,7 +2286,7 @@ TEST(LibRadosAioEC, MultiWritePP) {
 
   bufferlist bl3;
   AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_NE(my_completion3, my_completion_null);
   ASSERT_EQ(0, test_data.m_ioctx.aio_read("foo", my_completion3,
                                          &bl3, (sizeof(buf) + sizeof(buf2) * 3), 0));
@@ -2307,14 +2306,14 @@ 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, nullptr);
+        nullptr, nullptr);
   ASSERT_NE(my_completion, nullptr);
   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, nullptr);
+        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,
@@ -2335,7 +2334,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP) {
   AioTestDataPP test_data;
   ASSERT_EQ("", test_data.init());
   AioCompletion *my_completion = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);
   char full[128];
@@ -2354,7 +2353,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP) {
   bufferlist cbl;
   cbl.append(full, sizeof(full));
   AioCompletion *my_completion2 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_EQ(0, test_data.m_ioctx.aio_cmpext("foo", my_completion2, 0, cbl));
 
   {
@@ -2368,7 +2367,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP) {
   cbl.clear();
   cbl.append(full, sizeof(full));
   AioCompletion *my_completion3 = test_data.m_cluster.aio_create_completion(
-         nullptr, nullptr, nullptr);
+         nullptr, nullptr);
   ASSERT_EQ(0, test_data.m_ioctx.aio_cmpext("foo", my_completion3, 0, cbl));
 
   {
@@ -2395,7 +2394,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP2)
   cluster.ioctx_create(pool_name.c_str(), ioctx);
 
   boost::scoped_ptr<AioCompletion>
-                       wr_cmpl(cluster.aio_create_completion(0, 0, 0));
+                       wr_cmpl(cluster.aio_create_completion(0, 0));
   ObjectWriteOperation wr_op;
   memset(buf, 0xcc, sizeof(buf));
   memset(miscmp_buf, 0xdd, sizeof(miscmp_buf));
@@ -2413,7 +2412,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP2)
 
   /* cmpext as write op. first match then mismatch */
   boost::scoped_ptr<AioCompletion>
-                       wr_cmpext_cmpl(cluster.aio_create_completion(0, 0, 0));
+                       wr_cmpext_cmpl(cluster.aio_create_completion(0, 0));
   cbl.append(buf, sizeof(buf));
   ret = 0;
 
@@ -2428,7 +2427,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP2)
   EXPECT_EQ(0, ret);
 
   boost::scoped_ptr<AioCompletion>
-                       wr_cmpext_cmpl2(cluster.aio_create_completion(0, 0, 0));
+                       wr_cmpext_cmpl2(cluster.aio_create_completion(0, 0));
   cbl.clear();
   cbl.append(miscmp_buf, sizeof(miscmp_buf));
   ret = 0;
@@ -2445,7 +2444,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP2)
 
   /* cmpext as read op */
   boost::scoped_ptr<AioCompletion>
-                       rd_cmpext_cmpl(cluster.aio_create_completion(0, 0, 0));
+                       rd_cmpext_cmpl(cluster.aio_create_completion(0, 0));
   ObjectReadOperation rd_op;
   cbl.clear();
   cbl.append(buf, sizeof(buf));
@@ -2461,7 +2460,7 @@ TEST(LibRadosAio, RoundTripCmpExtPP2)
   EXPECT_EQ(0, ret);
 
   boost::scoped_ptr<AioCompletion>
-                       rd_cmpext_cmpl2(cluster.aio_create_completion(0, 0, 0));
+                       rd_cmpext_cmpl2(cluster.aio_create_completion(0, 0));
   cbl.clear();
   cbl.append(miscmp_buf, sizeof(miscmp_buf));
   ret = 0;

diff --git a/src/test/librados/misc_cxx.cc b/src/test/librados/misc_cxx.cc
index 20348a5e128701439edfddae19fd5c9453986a5e..c74bde90b9b813f125a6d477ca760c5b67756cdd 100644 (file)
--- a/src/test/librados/misc_cxx.cc
+++ b/src/test/librados/misc_cxx.cc
@@ -269,7 +269,7 @@ TEST_F(LibRadosMiscPP, BigObjectPP) {
 TEST_F(LibRadosMiscPP, AioOperatePP) {
   bool my_aio_complete = false;
   AioCompletion *my_completion = cluster.aio_create_completion(
-         (void*)&my_aio_complete, set_completion_complete, NULL);
+         (void*)&my_aio_complete, set_completion_complete);
   AioCompletion *my_completion_null = NULL;
   ASSERT_NE(my_completion, my_completion_null);