diff --git a/src/Makefile.test.include b/src/Makefile.test.include
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -50,8 +50,8 @@
   test/blockindex_tests.cpp \
   test/blockstatus_tests.cpp \
   test/bloom_tests.cpp \
+  test/bswap_opcode_tests.cpp \
   test/bswap_tests.cpp \
-  test/byteswap_tests.cpp \
   test/cashaddr_tests.cpp \
   test/cashaddrenc_tests.cpp \
   test/checkdatasig_tests.cpp \
diff --git a/src/qt/test/compattests.cpp b/src/qt/test/compattests.cpp
--- a/src/qt/test/compattests.cpp
+++ b/src/qt/test/compattests.cpp
@@ -16,7 +16,7 @@
 #include <compat/byteswap.h>
 
 void CompatTests::bswapTests() {
-    // Sibling in bitcoin/src/test/byteswap_tests.cpp
+    // Sibling in bitcoin/src/test/bswap_tests.cpp
     uint16_t u1 = 0x1234;
     uint32_t u2 = 0x56789abc;
     uint64_t u3 = 0xdef0123456789abc;
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -1235,6 +1235,22 @@
                         stacktop(-1) = std::move(n2);
                     } break;
 
+                    case OP_BSWAP: {
+                        if (!(flags & SCRIPT_ENABLE_OP_BSWAP)) {
+                            return set_error(serror, ScriptError::BAD_OPCODE);
+                        }
+
+                        // (in -- out)
+                        if (stack.size() < 1) {
+                            return set_error(
+                                serror, ScriptError::INVALID_STACK_OPERATION);
+                        }
+
+                        valtype &data = stacktop(-1);
+
+                        std::reverse(data.begin(), data.end());
+                    } break;
+
                     //
                     // Conversion operations
                     //
@@ -1300,22 +1316,6 @@
                         }
                     } break;
 
-                    case OP_BSWAP: {
-                        if (!(flags & SCRIPT_ENABLE_OP_BSWAP)) {
-                            return set_error(serror, ScriptError::BAD_OPCODE);
-                        }
-
-                        // (in -- out)
-                        if (stack.size() < 1) {
-                            return set_error(
-                                serror, ScriptError::INVALID_STACK_OPERATION);
-                        }
-
-                        valtype &data = stacktop(-1);
-
-                        std::reverse(data.begin(), data.end());
-                    } break;
-
                     default:
                         return set_error(serror, ScriptError::BAD_OPCODE);
                 }
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -72,8 +72,8 @@
 		blockindex_tests.cpp
 		blockstatus_tests.cpp
 		bloom_tests.cpp
+		bswap_opcode_tests.cpp
 		bswap_tests.cpp
-		byteswap_tests.cpp
 		cashaddr_tests.cpp
 		cashaddrenc_tests.cpp
 		checkdatasig_tests.cpp
diff --git a/src/test/bswap_opcode_tests.cpp b/src/test/bswap_opcode_tests.cpp
new file mode 100644
--- /dev/null
+++ b/src/test/bswap_opcode_tests.cpp
@@ -0,0 +1,128 @@
+// Copyright (c) 2020 The Bitcoin developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <script/interpreter.h>
+#include <script/script.h>
+
+#include <test/lcg.h>
+#include <test/test_bitcoin.h>
+
+#include <boost/test/unit_test.hpp>
+
+typedef std::vector<uint8_t> valtype;
+typedef std::vector<valtype> stacktype;
+
+BOOST_FIXTURE_TEST_SUITE(bswap_opcode_tests, BasicTestingSetup)
+
+static void CheckErrorWithFlags(const uint32_t flags,
+                                const stacktype &original_stack,
+                                const CScript &script,
+                                const ScriptError expected) {
+    BaseSignatureChecker sigchecker;
+    ScriptError err = ScriptError::OK;
+    stacktype stack{original_stack};
+    bool r = EvalScript(stack, script, flags, sigchecker, &err);
+    BOOST_CHECK(!r);
+    BOOST_CHECK(err == expected);
+}
+
+static void CheckPassWithFlags(const uint32_t flags,
+                               const stacktype &original_stack,
+                               const CScript &script,
+                               const stacktype &expected) {
+    BaseSignatureChecker sigchecker;
+    ScriptError err = ScriptError::OK;
+    stacktype stack{original_stack};
+    bool r = EvalScript(stack, script, flags, sigchecker, &err);
+    BOOST_CHECK(r);
+    BOOST_CHECK(err == ScriptError::OK);
+    BOOST_CHECK(stack == expected);
+}
+
+/**
+ * Verifies that the given error occurs with OP_BSWAP enabled
+ * and that BAD_OPCODE occurs if disabled.
+ */
+static void CheckErrorIfEnabled(const uint32_t flags,
+                                const stacktype &original_stack,
+                                const CScript &script,
+                                const ScriptError expected) {
+    CheckErrorWithFlags(flags | SCRIPT_ENABLE_OP_BSWAP, original_stack, script,
+                        expected);
+    CheckErrorWithFlags(flags & ~SCRIPT_ENABLE_OP_BSWAP, original_stack, script,
+                        ScriptError::BAD_OPCODE);
+}
+
+/**
+ * Verifies that the given stack results with OP_BSWAP enabled
+ * and that BAD_OPCODE occurs if disabled.
+ */
+static void CheckPassIfEnabled(const uint32_t flags,
+                               const stacktype &original_stack,
+                               const CScript &script,
+                               const stacktype &expected) {
+    CheckPassWithFlags(flags | SCRIPT_ENABLE_OP_BSWAP, original_stack, script,
+                       expected);
+    CheckErrorWithFlags(flags & ~SCRIPT_ENABLE_OP_BSWAP, original_stack, script,
+                        ScriptError::BAD_OPCODE);
+}
+
+BOOST_AUTO_TEST_CASE(bswap_opcode_tests) {
+    MMIXLinearCongruentialGenerator lcg;
+    for (int i = 0; i < 4096; i++) {
+        uint32_t flags = lcg.next();
+
+        // Empty stack.
+        CheckErrorIfEnabled(flags, {}, CScript() << OP_BSWAP,
+                            ScriptError::INVALID_STACK_OPERATION);
+
+        // Manual tests.
+        CheckPassIfEnabled(flags, {{}}, CScript() << OP_BSWAP, {{}});
+        CheckPassIfEnabled(flags, {{99}}, CScript() << OP_BSWAP, {{99}});
+        CheckPassIfEnabled(flags, {{0xde, 0xad}}, CScript() << OP_BSWAP,
+                           {{0xad, 0xde}});
+        CheckPassIfEnabled(flags, {{0xde, 0xad, 0xa1}}, CScript() << OP_BSWAP,
+                           {{0xa1, 0xad, 0xde}});
+        CheckPassIfEnabled(flags, {{0xde, 0xad, 0xbe, 0xef}},
+                           CScript() << OP_BSWAP, {{0xef, 0xbe, 0xad, 0xde}});
+
+        // Generated tests, sizes 0 to 520 shoud succeed
+        for (int32_t datasize = 0; datasize <= (int32_t)MAX_SCRIPT_ELEMENT_SIZE;
+             ++datasize) {
+            valtype data;
+            int32_t item;
+            data.reserve(datasize);
+            for (item = 0; item < datasize; ++item) {
+                data.push_back(uint8_t(item % 256));
+            }
+            valtype reversed_data;
+            reversed_data.reserve(datasize);
+            for (item = datasize - 1; item >= 0; --item) {
+                reversed_data.push_back(uint8_t(item % 256));
+            }
+            CheckPassIfEnabled(flags, {data}, CScript() << OP_BSWAP,
+                               {reversed_data});
+        }
+
+        // More tests.
+        CheckPassIfEnabled(flags, {{0x12, 0x34, 0x56}, {0x56, 0x34, 0x12}},
+                           CScript() << OP_BSWAP << OP_EQUALVERIFY, {});
+
+        CheckPassIfEnabled(
+            flags, {{0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C}},
+            CScript() << OP_DUP << OP_BSWAP << OP_BSWAP << OP_EQUALVERIFY, {});
+
+        // Verify palindrome.
+        CheckPassIfEnabled(flags, {{0x01, 0x02, 0x03, 0x02, 0x01}},
+                           CScript() << OP_DUP << OP_BSWAP << OP_EQUALVERIFY,
+                           {});
+
+        // Verify non-palindrome fails.
+        CheckErrorIfEnabled(flags, {{0x01, 0x02, 0x03, 0x02, 0x02}},
+                            CScript() << OP_DUP << OP_BSWAP << OP_EQUALVERIFY,
+                            ScriptError::EQUALVERIFY);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/bswap_tests.cpp b/src/test/bswap_tests.cpp
--- a/src/test/bswap_tests.cpp
+++ b/src/test/bswap_tests.cpp
@@ -1,126 +1,26 @@
-// Copyright (c) 2018 The Bitcoin developers
+// Copyright (c) 2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <policy/policy.h>
-#include <script/interpreter.h>
+#include <compat/byteswap.h>
 
-#include <test/lcg.h>
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
-#include <array>
-#include <bitset>
-
-typedef std::vector<uint8_t> valtype;
-typedef std::vector<valtype> stacktype;
-
 BOOST_FIXTURE_TEST_SUITE(bswap_tests, BasicTestingSetup)
 
-std::array<uint32_t, 3> flagset{{0, STANDARD_SCRIPT_VERIFY_FLAGS}};
-
-static void CheckError(uint32_t flags, const stacktype &original_stack,
-                       const CScript &script, ScriptError expected) {
-    BaseSignatureChecker sigchecker;
-    ScriptError err = ScriptError::OK;
-    stacktype stack{original_stack};
-    bool r = EvalScript(stack, script, flags, sigchecker, &err);
-    BOOST_CHECK(!r);
-    BOOST_CHECK(err == expected);
-}
-
-static void CheckPass(uint32_t flags, const stacktype &original_stack,
-                      const CScript &script, const stacktype &expected) {
-    BaseSignatureChecker sigchecker;
-    ScriptError err = ScriptError::OK;
-    stacktype stack{original_stack};
-    bool r = EvalScript(stack, script, flags, sigchecker, &err);
-    BOOST_CHECK(r);
-    BOOST_CHECK(err == ScriptError::OK);
-    BOOST_CHECK(stack == expected);
-}
-
-/**
- * General utility functions to check for script passing/failing.
- */
-static void CheckErrorForAllFlags(const stacktype &original_stack,
-                                  const CScript &script, ScriptError expected) {
-    for (uint32_t flags : flagset) {
-        // The script generates the proper error regardless of whether or not
-        // SCRIPT_ENABLE_OP_BSWAP flag is passed.
-        CheckError(flags & ~SCRIPT_ENABLE_OP_BSWAP, original_stack, script,
-                   expected);
-        CheckError(flags | SCRIPT_ENABLE_OP_BSWAP, original_stack, script,
-                   expected);
-    }
-}
-
-BOOST_AUTO_TEST_CASE(bswap_test) {
-    // Opcode not enabled.
-    CheckError(STANDARD_SCRIPT_VERIFY_FLAGS & ~SCRIPT_ENABLE_OP_BSWAP, {},
-               CScript() << OP_BSWAP, ScriptError::BAD_OPCODE);
-
-    // Empty stack.
-    CheckError(STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_OP_BSWAP, {},
-               CScript() << OP_BSWAP, ScriptError::INVALID_STACK_OPERATION);
-
-    // Manual tests.
-    CheckPass(STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_OP_BSWAP, {{}},
-              CScript() << OP_BSWAP, {{}});
-    CheckPass(STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_OP_BSWAP, {{99}},
-              CScript() << OP_BSWAP, {{99}});
-    CheckPass(STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_OP_BSWAP,
-              {{0xde, 0xad}}, CScript() << OP_BSWAP, {{0xad, 0xde}});
-    CheckPass(STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_OP_BSWAP,
-              {{0xde, 0xad, 0xa1}}, CScript() << OP_BSWAP,
-              {{0xa1, 0xad, 0xde}});
-    CheckPass(STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_OP_BSWAP,
-              {{0xde, 0xad, 0xbe, 0xef}}, CScript() << OP_BSWAP,
-              {{0xef, 0xbe, 0xad, 0xde}});
-
-    // Generated tests, sizes 0 to 520 that shoud succeed
-    // + 20 that should fail.
-    for (size_t datasize = 0; datasize <= 520 + 20; ++datasize) {
-        valtype data;
-        data.reserve(datasize);
-        for (uint8_t item = 0; item < (uint8_t)datasize; ++item) {
-            data.push_back(item);
-        }
-        if (datasize <= 520) {
-            valtype reversed_data;
-            reversed_data.reserve(datasize);
-            for (uint8_t item = (uint8_t)datasize - 1; item >= 0; --item) {
-                reversed_data.push_back(item);
-            }
-            CheckPass(STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_OP_BSWAP,
-                      {data}, CScript() << OP_BSWAP, {reversed_data});
-        } else {
-            CheckErrorForAllFlags({data}, CScript() << OP_BSWAP,
-                                  ScriptError::PUSH_SIZE);
-        }
-    }
-
-    // More tests.
-    CheckPass(STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_OP_BSWAP,
-              {{0x12, 0x34, 0x56}, {0x56, 0x34, 0x12}},
-              CScript() << OP_BSWAP << OP_EQUALVERIFY, {});
-
-    CheckPass(STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_OP_BSWAP,
-              {{0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C}},
-              CScript() << OP_DUP << OP_BSWAP << OP_BSWAP << OP_EQUALVERIFY,
-              {});
-
-    // Verify palindrome.
-    CheckPass(STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_OP_BSWAP,
-              {{0x01, 0x02, 0x03, 0x02, 0x01}},
-              CScript() << OP_DUP << OP_BSWAP << OP_EQUALVERIFY, {});
-
-    // Verify non-palindrome fails.
-    CheckError(STANDARD_SCRIPT_VERIFY_FLAGS | SCRIPT_ENABLE_OP_BSWAP,
-               {{0x01, 0x02, 0x03, 0x02, 0x02}},
-               CScript() << OP_DUP << OP_BSWAP << OP_EQUALVERIFY,
-               ScriptError::EQUALVERIFY);
+BOOST_AUTO_TEST_CASE(bswap_tests) {
+    // Sibling in bitcoin/src/qt/test/compattests.cpp
+    uint16_t u1 = 0x1234;
+    uint32_t u2 = 0x56789abc;
+    uint64_t u3 = 0xdef0123456789abc;
+    uint16_t e1 = 0x3412;
+    uint32_t e2 = 0xbc9a7856;
+    uint64_t e3 = 0xbc9a78563412f0de;
+    BOOST_CHECK(bswap_16(u1) == e1);
+    BOOST_CHECK(bswap_32(u2) == e2);
+    BOOST_CHECK(bswap_64(u3) == e3);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/byteswap_tests.cpp b/src/test/byteswap_tests.cpp
deleted file mode 100644
--- a/src/test/byteswap_tests.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) 2016 The Bitcoin Core developers
-// Distributed under the MIT software license, see the accompanying
-// file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-#include <compat/byteswap.h>
-
-#include <test/test_bitcoin.h>
-
-#include <boost/test/unit_test.hpp>
-
-BOOST_FIXTURE_TEST_SUITE(byteswap_tests, BasicTestingSetup)
-
-BOOST_AUTO_TEST_CASE(byteswap_tests) {
-    // Sibling in bitcoin/src/qt/test/compattests.cpp
-    uint16_t u1 = 0x1234;
-    uint32_t u2 = 0x56789abc;
-    uint64_t u3 = 0xdef0123456789abc;
-    uint16_t e1 = 0x3412;
-    uint32_t e2 = 0xbc9a7856;
-    uint64_t e3 = 0xbc9a78563412f0de;
-    BOOST_CHECK(bswap_16(u1) == e1);
-    BOOST_CHECK(bswap_32(u2) == e2);
-    BOOST_CHECK(bswap_64(u3) == e3);
-}
-
-BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/data/script_tests.json b/src/test/data/script_tests.json
--- a/src/test/data/script_tests.json
+++ b/src/test/data/script_tests.json
@@ -960,6 +960,38 @@
     "P2SH,STRICTENC", "OK", "SPLIT, maximum length with empty string"
 ],
 
+["BSWAP"],
+["", "BSWAP 0 EQUAL", "P2SH", "BAD_OPCODE", "BSWAP, empty stack"],
+["0", "BSWAP 0 EQUAL", "P2SH,BSWAP", "OK", "BSWAP, empty data"],
+["0x01 0x99", "BSWAP 0x01 0x99 EQUAL", "P2SH,BSWAP", "OK", "BSWAP, 1 byte"],
+["0x02 0xbeef", "BSWAP 0x02 0xefbe EQUAL", "P2SH,BSWAP", "OK", "BSWAP, 2 bytes"],
+["0x03 0xdeada1", "BSWAP 0x03 0xa1adde EQUAL", "P2SH,BSWAP", "OK", "BSWAP, 3 bytes"],
+["0x04 0xdeadbeef", "BSWAP 0x04 0xefbeadde EQUAL", "P2SH,BSWAP", "OK", "BSWAP, 4 bytes"],
+["'Bitcoin:_A_peer-to-peer_electronic_cash_system'", "BSWAP 'metsys_hsac_cinortcele_reep-ot-reep_A_:nioctiB' EQUAL", "P2SH,BSWAP", "OK", "BSWAP, whitepaper title"],
+[
+    "'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh'",
+    "BSWAP 'hhfanqyfcglncrriufjfvjgqcbbwrilaxeczpotsfzvmyrwlobpjtvtmhamvzoiwwjqazpyekvxpvsiiwuvertiqqiksmgkfplzamdvcelrrjsrvsxgojxngirwcoxhtmvtpzdjwzsuamlpudecziyiqkuukdbakbswcyelaksmudkgqccxpbobrkdpajsgogcuspzrptvrrsyuhrtxcftlpwlodgkavcqwofyxcwrsbovwojgznkiyijhohlyxevhqnqsibheuinifzybtbblzutjtsrotyqndybrncsdyrzlblxctejeyienvjeuslnzxomqzclruxceqispbntxngdpttfzzvqxshwlktvtkupouvjaugatahxgzzjidcauprbwdwakushoyhmogialwljyjrluudbkwjrkitxfsbtrvvyaesdosyzyxiysldhrybsxfrzpwwpubzncyzupdwoumfkfxnivdsryzlizjumarmlpqwfwqvngfegryrinviygnz' EQUAL",
+    "P2SH,BSWAP", "OK", "BSWAP, 520 bytes"
+],
+["0x03 0x123456", "BSWAP 0x03 0x563412 OP_EQUAL", "P2SH,BSWAP", "OK", "BSWAP, 3 bytes equal"],
+["0x06 0x020406080a0c", "DUP BSWAP BSWAP OP_EQUAL", "P2SH,BSWAP", "OK", "BSWAP, 3 bytes double reverse equal"],
+["'Bitcoin:_A_peer-to-peer_electronic_cash_system'", "DUP BSWAP BSWAP OP_EQUAL", "P2SH,BSWAP", "OK", "BSWAP, whitepaper title double reverse equal"],
+[
+    "'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh'",
+    "DUP BSWAP BSWAP OP_EQUAL",
+    "P2SH,BSWAP",
+    "OK",
+    "BSWAP, 520 bytes double reverse equal"
+],
+["0x05 0x0102030201", "DUP BSWAP OP_EQUAL", "P2SH,BSWAP", "OK", "BSWAP, palindrome 1"],
+["0x08 0x7766554444556677", "DUP BSWAP OP_EQUAL", "P2SH,BSWAP", "OK", "BSWAP, palindrome 2"],
+["'madam'", "DUP BSWAP OP_EQUAL", "P2SH,BSWAP", "OK", "BSWAP, palindrome 3"],
+["'racecar'", "DUP BSWAP OP_EQUAL", "P2SH,BSWAP", "OK", "BSWAP, palindrome 4"],
+["'redrum_siris_murder'", "DUP BSWAP OP_EQUAL", "P2SH,BSWAP", "OK", "BSWAP, palindrome 5"],
+["'step_on_no_pets'", "DUP BSWAP OP_EQUAL", "P2SH,BSWAP", "OK", "BSWAP, palindrome 6"],
+["'Bitcoin:_A_peer-to-peer_electronic_cash_system'", "DUP BSWAP OP_EQUAL", "P2SH,BSWAP", "EVAL_FALSE", "BSWAP, non-palindrome 1"],
+["0x02 0x1234", "DUP BSWAP OP_EQUAL", "P2SH,BSWAP", "EVAL_FALSE", "BSWAP, non-palindrome 1"],
+
 ["NUM2BIN"],
 ["", "NUM2BIN 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "NUM2BIN, empty stack"],
 ["0", "NUM2BIN 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "NUM2BIN, one parameter"],
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -184,7 +184,7 @@
         // anything about what happens when they are flipped. Keep them as-is.
         extra_flags &=
             ~(SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_ENABLE_REPLAY_PROTECTION |
-              SCRIPT_ENABLE_SCHNORR_MULTISIG);
+              SCRIPT_ENABLE_SCHNORR_MULTISIG | SCRIPT_ENABLE_OP_BSWAP);
         uint32_t combined_flags =
             expect ? (flags & ~extra_flags) : (flags | extra_flags);
         // Weed out invalid flag combinations.