1 files changed, 19 insertions, 19 deletions
diff --git a/jstests/core/index/indexj.js b/jstests/core/index/indexj.js
index 3023b661e59..93034fec923 100644
--- a/jstests/core/index/indexj.js
+++ b/jstests/core/index/indexj.js
@@ -7,12 +7,15 @@
 //   # Different assertions are made depending on whether SBE or classic is used. Implicitly
 //   # creating an index can change which engine is used.
 //   assumes_no_implicit_index_creation,
+//   # This test assumes that either SBE or classic is fully enabled and that we're not running in
+//   # a mixed version cluster.
+//   requires_fcv_63,
 // ]
 
 (function() {
 "use strict";
 
-load("jstests/libs/sbe_explain_helpers.js");  // For engineSpecificAssertion.
+load("jstests/libs/sbe_util.js");  // For 'checkSBEEnabled'.
 const t = db[jsTestName()];
 t.drop();
 
@@ -56,42 +59,39 @@ assert.commandWorked(t.insert({a: 2, b: 2}));
 // SBE or the classic engine. This is because the classic engine will use a multi-interval index
 // scan whereas SBE will decompose the intervals into a set of single-interval bounds and will end
 // up examining 0 keys.
-let assertFn = function(expectedKeys, numKeysExamined) {
-    return numKeysExamined === expectedKeys;
-};
+const isSBEEnabled = checkSBEEnabled(db);
+let expectedKeys = isSBEEnabled ? 0 : 3;
 let errMsg = function(actualNumKeys) {
     return "Chosen plan examined " + actualNumKeys + " keys";
 };
-let sbeAssert = actualKeys => assertFn(0, actualKeys);
-let classicAssert = actualKeys => assertFn(3, actualKeys);
 let numKeys = keysExamined({a: {$in: [1, 2]}, b: {$gt: 1, $lt: 2}}, {a: 1, b: 1});
-engineSpecificAssertion(classicAssert(numKeys), sbeAssert(numKeys), db, errMsg(numKeys));
+assert.eq(numKeys, expectedKeys, errMsg(numKeys));
 numKeys = keysExamined({a: {$in: [1, 2]}, b: {$gt: 1, $lt: 2}}, {a: 1, b: 1}, {a: -1, b: -1});
-engineSpecificAssertion(classicAssert(numKeys), sbeAssert(numKeys), db, errMsg(numKeys));
+assert.eq(numKeys, expectedKeys, errMsg(numKeys));
 
 assert.commandWorked(t.insert({a: 1, b: 1}));
 assert.commandWorked(t.insert({a: 1, b: 1}));
 numKeys = keysExamined({a: {$in: [1, 2]}, b: {$gt: 1, $lt: 2}}, {a: 1, b: 1});
-engineSpecificAssertion(classicAssert(numKeys), sbeAssert(numKeys), db, errMsg(numKeys));
+assert.eq(numKeys, expectedKeys, errMsg(numKeys));
 numKeys = keysExamined({a: {$in: [1, 2]}, b: {$gt: 1, $lt: 2}}, {a: 1, b: 1});
-engineSpecificAssertion(classicAssert(numKeys), sbeAssert(numKeys), db, errMsg(numKeys));
+assert.eq(numKeys, expectedKeys, errMsg(numKeys));
 numKeys = keysExamined({a: {$in: [1, 2]}, b: {$gt: 1, $lt: 2}}, {a: 1, b: 1}, {a: -1, b: -1});
-engineSpecificAssertion(classicAssert(numKeys), sbeAssert(numKeys), db, errMsg(numKeys));
+assert.eq(numKeys, expectedKeys, errMsg(numKeys));
 
 // We examine one less key in the classic engine because the bounds are slightly tighter.
-classicAssert = actualKeys => assertFn(2, actualKeys);
-numKeys = keysExamined({a: {$in: [1, 1.9]}, b: {$gt: 1, $lt: 2}}, {a: 1, b: 1});
-engineSpecificAssertion(classicAssert(numKeys), sbeAssert(numKeys), db, errMsg(numKeys));
+if (!isSBEEnabled) {
+    expectedKeys = 2;
+}
 
+numKeys = keysExamined({a: {$in: [1, 1.9]}, b: {$gt: 1, $lt: 2}}, {a: 1, b: 1});
+assert.eq(numKeys, expectedKeys, errMsg(numKeys));
 numKeys = keysExamined({a: {$in: [1.1, 2]}, b: {$gt: 1, $lt: 2}}, {a: 1, b: 1}, {a: -1, b: -1});
-engineSpecificAssertion(classicAssert(numKeys), sbeAssert(numKeys), db, errMsg(numKeys));
-
+assert.eq(numKeys, expectedKeys, errMsg(numKeys));
 assert.commandWorked(t.insert({a: 1, b: 1.5}));
 
 // We examine one extra key in both engines because we've inserted a document that falls within
 // both sets of bounds being scanned.
-sbeAssert = actualKeys => assertFn(1, actualKeys);
-classicAssert = actualKeys => assertFn(4, actualKeys);
+expectedKeys = isSBEEnabled ? 1 : 4;
 numKeys = keysExamined({a: {$in: [1, 2]}, b: {$gt: 1, $lt: 2}}, {a: 1, b: 1});
-engineSpecificAssertion(classicAssert(numKeys), sbeAssert(numKeys), db, errMsg(numKeys));
+assert.eq(numKeys, expectedKeys, errMsg(numKeys));
 })();