1 files changed, 22 insertions, 56 deletions

diff --git a/src/mongo/db/repl/task_runner_test.cpp b/src/mongo/db/repl/task_runner_test.cpp
index ae385374eac..0279955ab06 100644
--- a/src/mongo/db/repl/task_runner_test.cpp
+++ b/src/mongo/db/repl/task_runner_test.cpp
@@ -47,15 +47,8 @@ using Task = TaskRunner::Task;
 
 TEST_F(TaskRunnerTest, InvalidConstruction) {
     // Null thread pool.
-    ASSERT_THROWS_CODE(
-        TaskRunner(nullptr, [](Client*) { return ServiceContext::UniqueOperationContext(); }),
-        UserException,
-        ErrorCodes::BadValue);
-
-    // Null function for creating operation contexts.
-    ASSERT_THROWS_CODE(TaskRunner(&getThreadPool(), TaskRunner::CreateOperationContextFn()),
-                       UserException,
-                       ErrorCodes::BadValue);
+    ASSERT_THROWS_CODE_AND_WHAT(
+        TaskRunner(nullptr), UserException, ErrorCodes::BadValue, "null thread pool");
 }
 
 TEST_F(TaskRunnerTest, GetDiagnosticString) {
@@ -84,48 +77,24 @@ TEST_F(TaskRunnerTest, CallbackValues) {
     ASSERT_OK(status);
 }
 
-TEST_F(TaskRunnerTest, OperationContextFactoryReturnsNull) {
-    resetTaskRunner(new TaskRunner(
-        &getThreadPool(), [](Client*) { return ServiceContext::UniqueOperationContext(); }));
-    stdx::mutex mutex;
-    bool called = false;
-    OperationContextNoop opCtxNoop;
-    OperationContext* txn = &opCtxNoop;
-    Status status = getDetectableErrorStatus();
-    auto task = [&](OperationContext* theTxn, const Status& theStatus) {
-        stdx::lock_guard<stdx::mutex> lk(mutex);
-        called = true;
-        txn = theTxn;
-        status = theStatus;
-        return TaskRunner::NextAction::kCancel;
-    };
-    getTaskRunner().schedule(task);
-    getThreadPool().join();
-    ASSERT_FALSE(getTaskRunner().isActive());
+using OpIdVector = std::vector<unsigned int>;
 
-    stdx::lock_guard<stdx::mutex> lk(mutex);
-    ASSERT_TRUE(called);
-    ASSERT_FALSE(txn);
-    ASSERT_OK(status);
-}
-
-std::vector<int> _testRunTaskTwice(TaskRunnerTest& test,
-                                   TaskRunner::NextAction nextAction,
-                                   stdx::function<void(const Task& task)> schedule) {
+OpIdVector _testRunTaskTwice(TaskRunnerTest& test,
+                             TaskRunner::NextAction nextAction,
+                             stdx::function<void(const Task& task)> schedule) {
     unittest::Barrier barrier(2U);
     stdx::mutex mutex;
-    int i = 0;
-    OperationContext* txn[2] = {nullptr, nullptr};
-    int txnId[2] = {-100, -100};
+    std::vector<OperationContext*> txns;
+    OpIdVector txnIds;
     auto task = [&](OperationContext* theTxn, const Status& theStatus) {
         stdx::lock_guard<stdx::mutex> lk(mutex);
-        int j = i++;
-        if (j >= 2) {
+        if (txns.size() >= 2U) {
             return TaskRunner::NextAction::kInvalid;
         }
-        txn[j] = theTxn;
-        txnId[j] = TaskRunnerTest::getOperationContextId(txn[j]);
-        TaskRunner::NextAction result = j == 0 ? nextAction : TaskRunner::NextAction::kCancel;
+        TaskRunner::NextAction result =
+            txns.size() == 0 ? nextAction : TaskRunner::NextAction::kCancel;
+        txns.push_back(theTxn);
+        txnIds.push_back(theTxn->getOpID());
         barrier.countDownAndWait();
         return result;
     };
@@ -142,22 +111,20 @@ std::vector<int> _testRunTaskTwice(TaskRunnerTest& test,
     ASSERT_FALSE(test.getTaskRunner().isActive());
 
     stdx::lock_guard<stdx::mutex> lk(mutex);
-    ASSERT_EQUALS(2, i);
-    ASSERT(txn[0]);
-    ASSERT(txn[1]);
-    ASSERT_NOT_LESS_THAN(txnId[0], 0);
-    ASSERT_NOT_LESS_THAN(txnId[1], 0);
-    return {txnId[0], txnId[1]};
+    ASSERT_EQUALS(2U, txns.size());
+    ASSERT(txns[0]);
+    ASSERT(txns[1]);
+    return txnIds;
 }
 
-std::vector<int> _testRunTaskTwice(TaskRunnerTest& test, TaskRunner::NextAction nextAction) {
+std::vector<unsigned int> _testRunTaskTwice(TaskRunnerTest& test,
+                                            TaskRunner::NextAction nextAction) {
     auto schedule = [&](const Task& task) { test.getTaskRunner().schedule(task); };
     return _testRunTaskTwice(test, nextAction, schedule);
 }
 
 TEST_F(TaskRunnerTest, RunTaskTwiceDisposeOperationContext) {
-    std::vector<int> txnId =
-        _testRunTaskTwice(*this, TaskRunner::NextAction::kDisposeOperationContext);
+    auto txnId = _testRunTaskTwice(*this, TaskRunner::NextAction::kDisposeOperationContext);
     ASSERT_NOT_EQUALS(txnId[0], txnId[1]);
 }
 
@@ -169,14 +136,13 @@ TEST_F(TaskRunnerTest, RunTaskTwiceDisposeOperationContextJoinThreadPoolBeforeSc
         getThreadPool().join();
         getTaskRunner().schedule(task);
     };
-    std::vector<int> txnId =
+    auto txnId =
         _testRunTaskTwice(*this, TaskRunner::NextAction::kDisposeOperationContext, schedule);
     ASSERT_NOT_EQUALS(txnId[0], txnId[1]);
 }
 
 TEST_F(TaskRunnerTest, RunTaskTwiceKeepOperationContext) {
-    std::vector<int> txnId =
-        _testRunTaskTwice(*this, TaskRunner::NextAction::kKeepOperationContext);
+    auto txnId = _testRunTaskTwice(*this, TaskRunner::NextAction::kKeepOperationContext);
     ASSERT_EQUALS(txnId[0], txnId[1]);
 }