diff --git a/src/Makefile.test.include b/src/Makefile.test.include
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -95,6 +95,7 @@
   test/scheduler_tests.cpp \
   test/schnorr_tests.cpp \
   test/script_commitment_tests.cpp \
+  test/script_pushonly_tests.cpp \
   test/script_P2SH_tests.cpp \
   test/script_standard_tests.cpp \
   test/script_tests.cpp \
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -111,6 +111,7 @@
 	scheduler_tests.cpp
 	schnorr_tests.cpp
 	script_commitment_tests.cpp
+	script_pushonly_tests.cpp
 	script_P2SH_tests.cpp
 	script_standard_tests.cpp
 	script_tests.cpp
diff --git a/src/test/script_pushonly_tests.cpp b/src/test/script_pushonly_tests.cpp
new file mode 100644
--- /dev/null
+++ b/src/test/script_pushonly_tests.cpp
@@ -0,0 +1,208 @@
+// Copyright (c) 2019 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/script.h>
+
+#include <test/test_bitcoin.h>
+
+#include <boost/test/unit_test.hpp>
+
+inline CScript script_from_raw(std::vector<uint8_t> bytes) {
+    CScript tmp(bytes.begin(), bytes.end());
+    return tmp;
+}
+
+BOOST_FIXTURE_TEST_SUITE(script_pushonly_tests, BasicTestingSetup)
+
+BOOST_AUTO_TEST_CASE(invalid_scripts) {
+    // IsPushOnly returns false when given a script containing only pushes that
+    // are invalid due to truncation. IsPushOnly() is consensus critical because
+    // P2SH evaluation uses it, although this specific behavior should not be
+    // consensus critical as the P2SH evaluation would fail first due to the
+    // invalid push. Still, it doesn't hurt to test it explicitly.
+    {
+        CScript script = script_from_raw({0x01});
+        BOOST_CHECK(!script.IsPushOnly());
+    }
+    // Additional tests
+    {
+        // PUSHDATA1 truncated before size
+        CScript script = script_from_raw({0x4c});
+        BOOST_CHECK(!script.IsPushOnly());
+    }
+    {
+        // PUSHDATA1 truncated mid-data
+        CScript script = script_from_raw({0x4c, 0x02, 0x00});
+        BOOST_CHECK(!script.IsPushOnly());
+    }
+    {
+        // PUSHDATA2 truncated mid-size
+        CScript script = script_from_raw({0x4d, 0x01});
+        BOOST_CHECK(!script.IsPushOnly());
+    }
+    {
+        // PUSHDATA2 truncated mid-data
+        CScript script = script_from_raw({0x4d, 0x02, 0x00, 0x00});
+        BOOST_CHECK(!script.IsPushOnly());
+    }
+    {
+        // PUSHDATA4 truncated mid-size
+        CScript script = script_from_raw({0x4e, 0x01});
+        BOOST_CHECK(!script.IsPushOnly());
+    }
+    {
+        // PUSHDATA4 truncated mid-data
+        CScript script = script_from_raw({0x4e, 0x02, 0x00, 0x00, 0x00, 0x00});
+        BOOST_CHECK(!script.IsPushOnly());
+    }
+    {
+        // PUSHDATA4 with massive size (4 GB), truncated
+        CScript script =
+            script_from_raw({0x4e, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00});
+        BOOST_CHECK(!script.IsPushOnly());
+    }
+}
+
+BOOST_AUTO_TEST_CASE(singlebyteopcodes) {
+    // OP_0 and OP_1NEGATE and OP_1 through OP_16 are push-only.
+    CScript onebytepushes = CScript() << OP_0 << OP_1NEGATE << OP_1 << OP_2
+                                      << OP_3 << OP_4 << OP_5 << OP_6 << OP_7
+                                      << OP_8 << OP_9 << OP_10 << OP_11 << OP_12
+                                      << OP_13 << OP_14 << OP_15 << OP_16;
+    BOOST_CHECK(onebytepushes.IsPushOnly());
+    // OP_0 and OP_1NEGATE through to OP_16 (incl OP_RESERVED) are "PushOnly".
+    CScript withreserved = onebytepushes << OP_RESERVED;
+    BOOST_CHECK(withreserved.IsPushOnly());
+
+    // Do all single-byte opcodes, except OP_0.
+    for (uint8_t op = 0xff; op > OP_PUSHDATA4; op--) {
+        CScript script = CScript() << OP_5 << opcodetype(op) << OP_11;
+        BOOST_CHECK_EQUAL(script.IsPushOnly(), op <= OP_16);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(byteforms) {
+    // Test various ways of pushing the same thing.
+
+    // Do 0-byte (null) push in all four forms.
+    {
+        CScript scriptPUSH = CScript() << OP_0;
+        BOOST_CHECK(scriptPUSH.IsPushOnly());
+
+        CScript scriptPUSHDATA1 = script_from_raw({0x4c, 0x00});
+        BOOST_CHECK(scriptPUSHDATA1.IsPushOnly());
+
+        CScript scriptPUSHDATA2 = script_from_raw({0x4d, 0x00, 0x00});
+        BOOST_CHECK(scriptPUSHDATA2.IsPushOnly());
+
+        CScript scriptPUSHDATA4 =
+            script_from_raw({0x4e, 0x00, 0x00, 0x00, 0x00});
+        BOOST_CHECK(scriptPUSHDATA4.IsPushOnly());
+    }
+
+    // Do all possible 1-byte pushes in all four forms.
+    for (int i = 0; i < 256; i++) {
+        CScript scriptPUSH = script_from_raw({0x01, uint8_t(i)});
+        BOOST_CHECK(scriptPUSH.IsPushOnly());
+
+        CScript scriptPUSHDATA1 = script_from_raw({0x4c, 0x01, uint8_t(i)});
+        BOOST_CHECK(scriptPUSHDATA1.IsPushOnly());
+
+        CScript scriptPUSHDATA2 =
+            script_from_raw({0x4d, 0x01, 0x00, uint8_t(i)});
+        BOOST_CHECK(scriptPUSHDATA2.IsPushOnly());
+
+        CScript scriptPUSHDATA4 =
+            script_from_raw({0x4e, 0x01, 0x00, 0x00, 0x00, uint8_t(i)});
+        BOOST_CHECK(scriptPUSHDATA4.IsPushOnly());
+    }
+
+    // Do various longer pushes.
+
+    // two bytes: [0x00, 0x00]
+    {
+        CScript scriptPUSH = script_from_raw({0x02, 0x00, 0x00});
+        BOOST_CHECK(scriptPUSH.IsPushOnly());
+
+        CScript scriptPUSHDATA1 = script_from_raw({0x4c, 0x02, 0x00, 0x00});
+        BOOST_CHECK(scriptPUSHDATA1.IsPushOnly());
+
+        CScript scriptPUSHDATA2 =
+            script_from_raw({0x4d, 0x02, 0x00, 0x00, 0x00});
+        BOOST_CHECK(scriptPUSHDATA2.IsPushOnly());
+
+        CScript scriptPUSHDATA4 =
+            script_from_raw({0x4e, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00});
+        BOOST_CHECK(scriptPUSHDATA4.IsPushOnly());
+    }
+
+    // 75 zero bytes
+    {
+        CScript scriptPUSH = script_from_raw({75});
+        scriptPUSH.resize(scriptPUSH.size() + 75);
+        BOOST_CHECK(scriptPUSH.IsPushOnly());
+
+        CScript scriptPUSHDATA1 = script_from_raw({0x4c, 75});
+        scriptPUSHDATA1.resize(scriptPUSHDATA1.size() + 75);
+        BOOST_CHECK(scriptPUSHDATA1.IsPushOnly());
+
+        CScript scriptPUSHDATA2 = script_from_raw({
+            0x4d,
+            75,
+            0x00,
+        });
+        scriptPUSHDATA2.resize(scriptPUSHDATA2.size() + 75);
+        BOOST_CHECK(scriptPUSHDATA2.IsPushOnly());
+
+        CScript scriptPUSHDATA4 = script_from_raw({0x4e, 75, 0x00, 0x00, 0x00});
+        scriptPUSHDATA4.resize(scriptPUSHDATA4.size() + 75);
+        BOOST_CHECK(scriptPUSHDATA4.IsPushOnly());
+    }
+
+    // 255 zero bytes
+    {
+        CScript scriptPUSHDATA1 = script_from_raw({0x4c, 255});
+        scriptPUSHDATA1.resize(scriptPUSHDATA1.size() + 255);
+        BOOST_CHECK(scriptPUSHDATA1.IsPushOnly());
+
+        CScript scriptPUSHDATA2 = script_from_raw({
+            0x4d,
+            255,
+            0x00,
+        });
+        scriptPUSHDATA2.resize(scriptPUSHDATA2.size() + 255);
+        BOOST_CHECK(scriptPUSHDATA2.IsPushOnly());
+
+        CScript scriptPUSHDATA4 =
+            script_from_raw({0x4e, 255, 0x00, 0x00, 0x00});
+        scriptPUSHDATA4.resize(scriptPUSHDATA4.size() + 255);
+        BOOST_CHECK(scriptPUSHDATA4.IsPushOnly());
+    }
+
+    // 0xffff zero bytes
+    {
+        CScript scriptPUSHDATA2 = script_from_raw({
+            0x4d,
+            0xff,
+            0xff,
+        });
+        scriptPUSHDATA2.resize(scriptPUSHDATA2.size() + 0xffff);
+        BOOST_CHECK(scriptPUSHDATA2.IsPushOnly());
+
+        CScript scriptPUSHDATA4 =
+            script_from_raw({0x4e, 0xff, 0xff, 0x00, 0x00});
+        scriptPUSHDATA4.resize(scriptPUSHDATA4.size() + 0xffff);
+        BOOST_CHECK(scriptPUSHDATA4.IsPushOnly());
+    }
+
+    // 0x10000 zero bytes
+    {
+        CScript scriptPUSHDATA4 =
+            script_from_raw({0x4e, 0x00, 0x00, 0x01, 0x00});
+        scriptPUSHDATA4.resize(scriptPUSHDATA4.size() + 0x10000);
+        BOOST_CHECK(scriptPUSHDATA4.IsPushOnly());
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
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
@@ -2766,16 +2766,6 @@
     }
 }
 
-BOOST_AUTO_TEST_CASE(script_IsPushOnly_on_invalid_scripts) {
-    // IsPushOnly returns false when given a script containing only pushes that
-    // are invalid due to truncation. IsPushOnly() is consensus critical because
-    // P2SH evaluation uses it, although this specific behavior should not be
-    // consensus critical as the P2SH evaluation would fail first due to the
-    // invalid push. Still, it doesn't hurt to test it explicitly.
-    static const uint8_t direct[] = {1};
-    BOOST_CHECK(!CScript(direct, direct + sizeof(direct)).IsPushOnly());
-}
-
 BOOST_AUTO_TEST_CASE(script_GetScriptAsm) {
     BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY",
                       ScriptToAsmStr(CScript() << OP_NOP2, true));