kvazar/kevacoin
1
0
Fork 0
mirror of https://github.com/kvazar-network/kevacoin.git synced 2025-01-18 19:10:11 +00:00
Code Issues Projects Releases Wiki Activity

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

Browse Source 
09dc406 Make test constant consistent with consensus.h (BtcDrak)
This commit is contained in:
MarcoFalke 2016-11-23 11:37:17 +01:00
commit e662d281b8
No known key found for this signature in database
GPG Key ID: 2D7F2372E50FE137
4 changed files with 24 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
qa/rpc-tests/p2p-fullblocktest.py
View File

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

14
qa/rpc-tests/p2p-segwit.py
View File

@ -498,7 +498,7 @@ class SegWitTest(BitcoinTestFramework):
block.solve() block.solve()
block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.append(b'a'*5000000) 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 # 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 # TODO: repeat this test with a block that can be relayed
@ -507,7 +507,7 @@ class SegWitTest(BitcoinTestFramework):
assert(self.nodes[0].getbestblockhash() != block.hash) assert(self.nodes[0].getbestblockhash() != block.hash)
block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.pop() 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))) self.nodes[0].submitblock(bytes_to_hex_str(block.serialize(True)))
assert(self.nodes[0].getbestblockhash() == block.hash) assert(self.nodes[0].getbestblockhash() == block.hash)
@ -572,10 +572,10 @@ class SegWitTest(BitcoinTestFramework):
self.update_witness_block_with_transactions(block, [parent_tx, child_tx]) self.update_witness_block_with_transactions(block, [parent_tx, child_tx])
vsize = get_virtual_size(block) vsize = get_virtual_size(block)
additional_bytes = (MAX_BLOCK_SIZE - vsize)*4 additional_bytes = (MAX_BLOCK_BASE_SIZE - vsize)*4
i = 0 i = 0
while additional_bytes > 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) 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) 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 additional_bytes -= extra_bytes
@ -585,7 +585,7 @@ class SegWitTest(BitcoinTestFramework):
add_witness_commitment(block) add_witness_commitment(block)
block.solve() block.solve()
vsize = get_virtual_size(block) 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 # Make sure that our test case would exceed the old max-network-message
# limit # limit
assert(len(block.serialize(True)) > 2*1024*1024) assert(len(block.serialize(True)) > 2*1024*1024)
@ -598,7 +598,7 @@ class SegWitTest(BitcoinTestFramework):
block.vtx[0].vout.pop() block.vtx[0].vout.pop()
add_witness_commitment(block) add_witness_commitment(block)
block.solve() 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) self.test_node.test_witness_block(block, accepted=True)
@ -1433,7 +1433,7 @@ class SegWitTest(BitcoinTestFramework):
block.vtx.append(tx) block.vtx.append(tx)
# Test the block periodically, if we're close to maxblocksize # 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.update_witness_block_with_transactions(block, [])
self.test_node.test_witness_block(block, accepted=True) self.test_node.test_witness_block(block, accepted=True)
block = self.build_next_block() block = self.build_next_block()

6
qa/rpc-tests/prioritise_transaction.py
View File

@ -9,7 +9,7 @@
from test_framework.test_framework import BitcoinTestFramework from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import * 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): class PrioritiseTransactionTest(BitcoinTestFramework):
@ -42,7 +42,7 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
txids[i] = create_lots_of_big_transactions(self.nodes[0], self.txouts, utxos[start_range:end_range], (i+1)*base_fee) 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 # 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. # more transactions.
mempool = self.nodes[0].getrawmempool(True) mempool = self.nodes[0].getrawmempool(True)
sizes = [0, 0, 0] sizes = [0, 0, 0]
@ -50,7 +50,7 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
for j in txids[i]: for j in txids[i]:
assert(j in mempool) assert(j in mempool)
sizes[i] += mempool[j]['size'] 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 # 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 # also check that a different entry in the cheapest bucket is NOT mined (lower

2
qa/rpc-tests/test_framework/mininode.py
View File

@ -44,7 +44,7 @@ MY_SUBVERSION = b"/python-mininode-tester:0.0.3/"
MY_RELAY = 1 # from version 70001 onwards, fRelay should be appended to version messages (BIP37) MY_RELAY = 1 # from version 70001 onwards, fRelay should be appended to version messages (BIP37)
MAX_INV_SZ = 50000 MAX_INV_SZ = 50000
MAX_BLOCK_SIZE = 1000000 MAX_BLOCK_BASE_SIZE = 1000000
COIN = 100000000 # 1 btc in satoshis COIN = 100000000 # 1 btc in satoshis