kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Make test constant consistent with consensus.h

0.14
BtcDrak 8 years ago
parent
0c577f2638
commit
09dc4064ac
4 changed files with 24 additions and 24 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 26
      qa/rpc-tests/p2p-fullblocktest.py
  2. 14
      qa/rpc-tests/p2p-segwit.py
  3. 6
      qa/rpc-tests/prioritise_transaction.py
  4. 2
      qa/rpc-tests/test_framework/mininode.py

26
qa/rpc-tests/p2p-fullblocktest.py
Unescape 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
Unescape 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
Unescape 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
Unescape 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

Write Preview
Loading…
Cancel
Save