Merge #9206: Make test constant consistent with consensus.h

09dc406 Make test constant consistent with consensus.h (BtcDrak)

Author: MarcoFalke

qa/rpc-tests/p2p-fullblocktest.py

@@ -351,32 +351,32 @@ def update_block(block_number, new_transactions):
         block(22, spend=out[5])
         yield rejected()
 
-        # Create a block on either side of MAX_BLOCK_SIZE and make sure its accepted/rejected
+        # Create a block on either side of MAX_BLOCK_BASE_SIZE and make sure its accepted/rejected
         #     genesis -> b1 (0) -> b2 (1) -> b5 (2) -> b6  (3)
         #                                          \-> b12 (3) -> b13 (4) -> b15 (5) -> b23 (6)
         #                                                                           \-> b24 (6) -> b25 (7)
         #                      \-> b3 (1) -> b4 (2)
         tip(15)
         b23 = block(23, spend=out[6])
         tx = CTransaction()
-        script_length = MAX_BLOCK_SIZE - len(b23.serialize()) - 69
+        script_length = MAX_BLOCK_BASE_SIZE - len(b23.serialize()) - 69
         script_output = CScript([b'\x00' * script_length])
         tx.vout.append(CTxOut(0, script_output))
         tx.vin.append(CTxIn(COutPoint(b23.vtx[1].sha256, 0)))
         b23 = update_block(23, [tx])
         # Make sure the math above worked out to produce a max-sized block
-        assert_equal(len(b23.serialize()), MAX_BLOCK_SIZE)
+        assert_equal(len(b23.serialize()), MAX_BLOCK_BASE_SIZE)
         yield accepted()
         save_spendable_output()
 
         # Make the next block one byte bigger and check that it fails
         tip(15)
         b24 = block(24, spend=out[6])
-        script_length = MAX_BLOCK_SIZE - len(b24.serialize()) - 69
+        script_length = MAX_BLOCK_BASE_SIZE - len(b24.serialize()) - 69
         script_output = CScript([b'\x00' * (script_length+1)])
         tx.vout = [CTxOut(0, script_output)]
         b24 = update_block(24, [tx])
-        assert_equal(len(b24.serialize()), MAX_BLOCK_SIZE+1)
+        assert_equal(len(b24.serialize()), MAX_BLOCK_BASE_SIZE+1)
         yield rejected(RejectResult(16, b'bad-blk-length'))
 
         block(25, spend=out[7])
@@ -523,12 +523,12 @@ def update_block(block_number, new_transactions):
         tx_new = None
         tx_last = tx
         total_size=len(b39.serialize())
-        while(total_size < MAX_BLOCK_SIZE):
+        while(total_size < MAX_BLOCK_BASE_SIZE):
             tx_new = create_tx(tx_last, 1, 1, p2sh_script)
             tx_new.vout.append(CTxOut(tx_last.vout[1].nValue - 1, CScript([OP_TRUE])))
             tx_new.rehash()
             total_size += len(tx_new.serialize())
-            if total_size >= MAX_BLOCK_SIZE:
+            if total_size >= MAX_BLOCK_BASE_SIZE:
                 break
             b39.vtx.append(tx_new) # add tx to block
             tx_last = tx_new
@@ -877,7 +877,7 @@ def update_block(block_number, new_transactions):
 
 
         #  This checks that a block with a bloated VARINT between the block_header and the array of tx such that
-        #  the block is > MAX_BLOCK_SIZE with the bloated varint, but <= MAX_BLOCK_SIZE without the bloated varint,
+        #  the block is > MAX_BLOCK_BASE_SIZE with the bloated varint, but <= MAX_BLOCK_BASE_SIZE without the bloated varint,
         #  does not cause a subsequent, identical block with canonical encoding to be rejected.  The test does not
         #  care whether the bloated block is accepted or rejected; it only cares that the second block is accepted.
         #
@@ -901,12 +901,12 @@ def update_block(block_number, new_transactions):
         tx = CTransaction()
 
         # use canonical serialization to calculate size
-        script_length = MAX_BLOCK_SIZE - len(b64a.normal_serialize()) - 69
+        script_length = MAX_BLOCK_BASE_SIZE - len(b64a.normal_serialize()) - 69
         script_output = CScript([b'\x00' * script_length])
         tx.vout.append(CTxOut(0, script_output))
         tx.vin.append(CTxIn(COutPoint(b64a.vtx[1].sha256, 0)))
         b64a = update_block("64a", [tx])
-        assert_equal(len(b64a.serialize()), MAX_BLOCK_SIZE + 8)
+        assert_equal(len(b64a.serialize()), MAX_BLOCK_BASE_SIZE + 8)
         yield TestInstance([[self.tip, None]])
 
         # comptool workaround: to make sure b64 is delivered, manually erase b64a from blockstore
@@ -916,7 +916,7 @@ def update_block(block_number, new_transactions):
         b64 = CBlock(b64a)
         b64.vtx = copy.deepcopy(b64a.vtx)
         assert_equal(b64.hash, b64a.hash)
-        assert_equal(len(b64.serialize()), MAX_BLOCK_SIZE)
+        assert_equal(len(b64.serialize()), MAX_BLOCK_BASE_SIZE)
         self.blocks[64] = b64
         update_block(64, [])
         yield accepted()
@@ -1250,12 +1250,12 @@ def update_block(block_number, new_transactions):
             for i in range(89, LARGE_REORG_SIZE + 89):
                 b = block(i, spend)
                 tx = CTransaction()
-                script_length = MAX_BLOCK_SIZE - len(b.serialize()) - 69
+                script_length = MAX_BLOCK_BASE_SIZE - len(b.serialize()) - 69
                 script_output = CScript([b'\x00' * script_length])
                 tx.vout.append(CTxOut(0, script_output))
                 tx.vin.append(CTxIn(COutPoint(b.vtx[1].sha256, 0)))
                 b = update_block(i, [tx])
-                assert_equal(len(b.serialize()), MAX_BLOCK_SIZE)
+                assert_equal(len(b.serialize()), MAX_BLOCK_BASE_SIZE)
                 test1.blocks_and_transactions.append([self.tip, True])
                 save_spendable_output()
                 spend = get_spendable_output()

qa/rpc-tests/p2p-segwit.py

@@ -498,7 +498,7 @@ def test_block_malleability(self):
         block.solve()
 
         block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.append(b'a'*5000000)
-        assert(get_virtual_size(block) > MAX_BLOCK_SIZE)
+        assert(get_virtual_size(block) > MAX_BLOCK_BASE_SIZE)
 
         # We can't send over the p2p network, because this is too big to relay
         # TODO: repeat this test with a block that can be relayed
@@ -507,7 +507,7 @@ def test_block_malleability(self):
         assert(self.nodes[0].getbestblockhash() != block.hash)
 
         block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.pop()
-        assert(get_virtual_size(block) < MAX_BLOCK_SIZE)
+        assert(get_virtual_size(block) < MAX_BLOCK_BASE_SIZE)
         self.nodes[0].submitblock(bytes_to_hex_str(block.serialize(True)))
 
         assert(self.nodes[0].getbestblockhash() == block.hash)
@@ -572,10 +572,10 @@ def test_witness_block_size(self):
         self.update_witness_block_with_transactions(block, [parent_tx, child_tx])
 
         vsize = get_virtual_size(block)
-        additional_bytes = (MAX_BLOCK_SIZE - vsize)*4
+        additional_bytes = (MAX_BLOCK_BASE_SIZE - vsize)*4
         i = 0
         while additional_bytes > 0:
-            # Add some more bytes to each input until we hit MAX_BLOCK_SIZE+1
+            # Add some more bytes to each input until we hit MAX_BLOCK_BASE_SIZE+1
             extra_bytes = min(additional_bytes+1, 55)
             block.vtx[-1].wit.vtxinwit[int(i/(2*NUM_DROPS))].scriptWitness.stack[i%(2*NUM_DROPS)] = b'a'*(195+extra_bytes)
             additional_bytes -= extra_bytes
@@ -585,7 +585,7 @@ def test_witness_block_size(self):
         add_witness_commitment(block)
         block.solve()
         vsize = get_virtual_size(block)
-        assert_equal(vsize, MAX_BLOCK_SIZE + 1)
+        assert_equal(vsize, MAX_BLOCK_BASE_SIZE + 1)
         # Make sure that our test case would exceed the old max-network-message
         # limit
         assert(len(block.serialize(True)) > 2*1024*1024)
@@ -598,7 +598,7 @@ def test_witness_block_size(self):
         block.vtx[0].vout.pop()
         add_witness_commitment(block)
         block.solve()
-        assert(get_virtual_size(block) == MAX_BLOCK_SIZE)
+        assert(get_virtual_size(block) == MAX_BLOCK_BASE_SIZE)
 
         self.test_node.test_witness_block(block, accepted=True)
 
@@ -1433,7 +1433,7 @@ def test_signature_version_1(self):
             block.vtx.append(tx)
 
             # Test the block periodically, if we're close to maxblocksize
-            if (get_virtual_size(block) > MAX_BLOCK_SIZE - 1000):
+            if (get_virtual_size(block) > MAX_BLOCK_BASE_SIZE - 1000):
                 self.update_witness_block_with_transactions(block, [])
                 self.test_node.test_witness_block(block, accepted=True)
                 block = self.build_next_block()

qa/rpc-tests/prioritise_transaction.py

@@ -9,7 +9,7 @@
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import *
-from test_framework.mininode import COIN, MAX_BLOCK_SIZE
+from test_framework.mininode import COIN, MAX_BLOCK_BASE_SIZE
 
 class PrioritiseTransactionTest(BitcoinTestFramework):
 
@@ -42,15 +42,15 @@ def run_test(self):
             txids[i] = create_lots_of_big_transactions(self.nodes[0], self.txouts, utxos[start_range:end_range], (i+1)*base_fee)
 
         # Make sure that the size of each group of transactions exceeds
-        # MAX_BLOCK_SIZE -- otherwise the test needs to be revised to create
+        # MAX_BLOCK_BASE_SIZE -- otherwise the test needs to be revised to create
         # more transactions.
         mempool = self.nodes[0].getrawmempool(True)
         sizes = [0, 0, 0]
         for i in range(3):
             for j in txids[i]:
                 assert(j in mempool)
                 sizes[i] += mempool[j]['size']
-            assert(sizes[i] > MAX_BLOCK_SIZE) # Fail => raise utxo_count
+            assert(sizes[i] > MAX_BLOCK_BASE_SIZE) # Fail => raise utxo_count
 
         # add a fee delta to something in the cheapest bucket and make sure it gets mined
         # also check that a different entry in the cheapest bucket is NOT mined (lower

qa/rpc-tests/test_framework/mininode.py

@@ -44,7 +44,7 @@
 MY_RELAY = 1 # from version 70001 onwards, fRelay should be appended to version messages (BIP37)
 
 MAX_INV_SZ = 50000
-MAX_BLOCK_SIZE = 1000000
+MAX_BLOCK_BASE_SIZE = 1000000
 
 COIN = 100000000 # 1 btc in satoshis