scripted-diff: test: Remove brackets after assert

-BEGIN VERIFY SCRIPT-
sed -i --regexp-extended -e 's/assert ?\((.+)\)(( )*)?(#.*)?$/assert \1\3\3\4/g' $(git grep -l --extended-regexp 'assert ?\(' test)
-END VERIFY SCRIPT-

Author: MarcoFalke

test/functional/feature_bip68_sequence.py

@@ -63,7 +63,7 @@ def test_disable_flag(self):
         self.nodes[0].sendtoaddress(new_addr, 2) # send 2 BTC
 
         utxos = self.nodes[0].listunspent(0, 0)
-        assert(len(utxos) > 0)
+        assert len(utxos) > 0
 
         utxo = utxos[0]
 
@@ -253,7 +253,7 @@ def test_nonzero_locks(orig_tx, node, relayfee, use_height_lock):
             self.nodes[0].generate(1)
             cur_time += 600
 
-        assert(tx2.hash in self.nodes[0].getrawmempool())
+        assert tx2.hash in self.nodes[0].getrawmempool()
 
         test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=True)
         test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=False)
@@ -264,23 +264,23 @@ def test_nonzero_locks(orig_tx, node, relayfee, use_height_lock):
         # Advance the time on the node so that we can test timelocks
         self.nodes[0].setmocktime(cur_time+600)
         self.nodes[0].generate(1)
-        assert(tx2.hash not in self.nodes[0].getrawmempool())
+        assert tx2.hash not in self.nodes[0].getrawmempool()
 
         # Now that tx2 is not in the mempool, a sequence locked spend should
         # succeed
         tx3 = test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=False)
-        assert(tx3.hash in self.nodes[0].getrawmempool())
+        assert tx3.hash in self.nodes[0].getrawmempool()
 
         self.nodes[0].generate(1)
-        assert(tx3.hash not in self.nodes[0].getrawmempool())
+        assert tx3.hash not in self.nodes[0].getrawmempool()
 
         # One more test, this time using height locks
         tx4 = test_nonzero_locks(tx3, self.nodes[0], self.relayfee, use_height_lock=True)
-        assert(tx4.hash in self.nodes[0].getrawmempool())
+        assert tx4.hash in self.nodes[0].getrawmempool()
 
         # Now try combining confirmed and unconfirmed inputs
         tx5 = test_nonzero_locks(tx4, self.nodes[0], self.relayfee, use_height_lock=True)
-        assert(tx5.hash not in self.nodes[0].getrawmempool())
+        assert tx5.hash not in self.nodes[0].getrawmempool()
 
         utxos = self.nodes[0].listunspent()
         tx5.vin.append(CTxIn(COutPoint(int(utxos[0]["txid"], 16), utxos[0]["vout"]), nSequence=1))
@@ -299,8 +299,8 @@ def test_nonzero_locks(orig_tx, node, relayfee, use_height_lock):
         # If we invalidate the tip, tx3 should get added to the mempool, causing
         # tx4 to be removed (fails sequence-lock).
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
-        assert(tx4.hash not in self.nodes[0].getrawmempool())
-        assert(tx3.hash in self.nodes[0].getrawmempool())
+        assert tx4.hash not in self.nodes[0].getrawmempool()
+        assert tx3.hash in self.nodes[0].getrawmempool()
 
         # Now mine 2 empty blocks to reorg out the current tip (labeled tip-1 in
         # diagram above).
@@ -319,8 +319,8 @@ def test_nonzero_locks(orig_tx, node, relayfee, use_height_lock):
             cur_time += 1
 
         mempool = self.nodes[0].getrawmempool()
-        assert(tx3.hash not in mempool)
-        assert(tx2.hash in mempool)
+        assert tx3.hash not in mempool
+        assert tx2.hash in mempool
 
         # Reset the chain and get rid of the mocktimed-blocks
         self.nodes[0].setmocktime(0)
@@ -332,7 +332,7 @@ def test_nonzero_locks(orig_tx, node, relayfee, use_height_lock):
     # being run, then it's possible the test has activated the soft fork, and
     # this test should be moved to run earlier, or deleted.
     def test_bip68_not_consensus(self):
-        assert(get_bip9_status(self.nodes[0], 'csv')['status'] != 'active')
+        assert get_bip9_status(self.nodes[0], 'csv')['status'] != 'active'
         txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 2)
 
         tx1 = FromHex(CTransaction(), self.nodes[0].getrawtransaction(txid))

test/functional/feature_block.py

@@ -773,7 +773,7 @@ def run_test(self):
         self.move_tip(57)
         b58 = self.next_block(58, spend=out[17])
         tx = CTransaction()
-        assert(len(out[17].vout) < 42)
+        assert len(out[17].vout) < 42
         tx.vin.append(CTxIn(COutPoint(out[17].sha256, 42), CScript([OP_TRUE]), 0xffffffff))
         tx.vout.append(CTxOut(0, b""))
         tx.calc_sha256()
@@ -824,7 +824,7 @@ def run_test(self):
         tx.nLockTime = 0xffffffff  # this locktime is non-final
         tx.vin.append(CTxIn(COutPoint(out[18].sha256, 0)))  # don't set nSequence
         tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
-        assert(tx.vin[0].nSequence < 0xffffffff)
+        assert tx.vin[0].nSequence < 0xffffffff
         tx.calc_sha256()
         b62 = self.update_block(62, [tx])
         self.sync_blocks([b62], success=False, reject_reason='bad-txns-nonfinal')
@@ -1143,8 +1143,8 @@ def run_test(self):
         # now check that tx78 and tx79 have been put back into the peer's mempool
         mempool = self.nodes[0].getrawmempool()
         assert_equal(len(mempool), 2)
-        assert(tx78.hash in mempool)
-        assert(tx79.hash in mempool)
+        assert tx78.hash in mempool
+        assert tx79.hash in mempool
 
         # Test invalid opcodes in dead execution paths.
         #

test/functional/feature_csv_activation.py

@@ -106,7 +106,7 @@ def send_generic_input_tx(node, coinbases, address):
 def create_bip68txs(node, bip68inputs, txversion, address, locktime_delta=0):
     """Returns a list of bip68 transactions with different bits set."""
     txs = []
-    assert(len(bip68inputs) >= 16)
+    assert len(bip68inputs) >= 16
     for i, (sdf, srhb, stf, srlb) in enumerate(product(*[[True, False]] * 4)):
         locktime = relative_locktime(sdf, srhb, stf, srlb)
         tx = create_transaction(node, bip68inputs[i], address, amount=Decimal("49.98"))
@@ -121,7 +121,7 @@ def create_bip68txs(node, bip68inputs, txversion, address, locktime_delta=0):
 def create_bip112txs(node, bip112inputs, varyOP_CSV, txversion, address, locktime_delta=0):
     """Returns a list of bip68 transactions with different bits set."""
     txs = []
-    assert(len(bip112inputs) >= 16)
+    assert len(bip112inputs) >= 16
     for i, (sdf, srhb, stf, srlb) in enumerate(product(*[[True, False]] * 4)):
         locktime = relative_locktime(sdf, srhb, stf, srlb)
         tx = create_transaction(node, bip112inputs[i], address, amount=Decimal("49.98"))

test/functional/feature_nulldummy.py

@@ -27,7 +27,7 @@ def trueDummy(tx):
     newscript = []
     for i in scriptSig:
         if (len(newscript) == 0):
-            assert(len(i) == 0)
+            assert len(i) == 0
             newscript.append(b'\x51')
         else:
             newscript.append(i)

test/functional/feature_proxy.py

@@ -95,7 +95,7 @@ def node_test(self, node, proxies, auth, test_onion=True):
         # Test: outgoing IPv4 connection through node
         node.addnode("15.61.23.23:1234", "onetry")
         cmd = proxies[0].queue.get()
-        assert(isinstance(cmd, Socks5Command))
+        assert isinstance(cmd, Socks5Command)
         # Note: bitcoind's SOCKS5 implementation only sends atyp DOMAINNAME, even if connecting directly to IPv4/IPv6
         assert_equal(cmd.atyp, AddressType.DOMAINNAME)
         assert_equal(cmd.addr, b"15.61.23.23")
@@ -109,7 +109,7 @@ def node_test(self, node, proxies, auth, test_onion=True):
             # Test: outgoing IPv6 connection through node
             node.addnode("[1233:3432:2434:2343:3234:2345:6546:4534]:5443", "onetry")
             cmd = proxies[1].queue.get()
-            assert(isinstance(cmd, Socks5Command))
+            assert isinstance(cmd, Socks5Command)
             # Note: bitcoind's SOCKS5 implementation only sends atyp DOMAINNAME, even if connecting directly to IPv4/IPv6
             assert_equal(cmd.atyp, AddressType.DOMAINNAME)
             assert_equal(cmd.addr, b"1233:3432:2434:2343:3234:2345:6546:4534")
@@ -123,7 +123,7 @@ def node_test(self, node, proxies, auth, test_onion=True):
             # Test: outgoing onion connection through node
             node.addnode("bitcoinostk4e4re.onion:8333", "onetry")
             cmd = proxies[2].queue.get()
-            assert(isinstance(cmd, Socks5Command))
+            assert isinstance(cmd, Socks5Command)
             assert_equal(cmd.atyp, AddressType.DOMAINNAME)
             assert_equal(cmd.addr, b"bitcoinostk4e4re.onion")
             assert_equal(cmd.port, 8333)
@@ -135,7 +135,7 @@ def node_test(self, node, proxies, auth, test_onion=True):
         # Test: outgoing DNS name connection through node
         node.addnode("node.noumenon:8333", "onetry")
         cmd = proxies[3].queue.get()
-        assert(isinstance(cmd, Socks5Command))
+        assert isinstance(cmd, Socks5Command)
         assert_equal(cmd.atyp, AddressType.DOMAINNAME)
         assert_equal(cmd.addr, b"node.noumenon")
         assert_equal(cmd.port, 8333)

test/functional/feature_pruning.py

@@ -151,7 +151,7 @@ def reorg_test(self):
             self.nodes[1].invalidateblock(curhash)
             curhash = self.nodes[1].getblockhash(invalidheight - 1)
 
-        assert(self.nodes[1].getblockcount() == invalidheight - 1)
+        assert self.nodes[1].getblockcount() == invalidheight - 1
         self.log.info("New best height: %d" % self.nodes[1].getblockcount())
 
         # Reboot node1 to clear those giant tx's from mempool
@@ -219,17 +219,17 @@ def reorg_back(self):
             blocks_to_mine = first_reorg_height + 1 - self.mainchainheight
             self.log.info("Rewind node 0 to prev main chain to mine longer chain to trigger redownload. Blocks needed: %d" % blocks_to_mine)
             self.nodes[0].invalidateblock(curchainhash)
-            assert(self.nodes[0].getblockcount() == self.mainchainheight)
-            assert(self.nodes[0].getbestblockhash() == self.mainchainhash2)
+            assert self.nodes[0].getblockcount() == self.mainchainheight
+            assert self.nodes[0].getbestblockhash() == self.mainchainhash2
             goalbesthash = self.nodes[0].generate(blocks_to_mine)[-1]
             goalbestheight = first_reorg_height + 1
 
         self.log.info("Verify node 2 reorged back to the main chain, some blocks of which it had to redownload")
         # Wait for Node 2 to reorg to proper height
         wait_until(lambda: self.nodes[2].getblockcount() >= goalbestheight, timeout=900)
-        assert(self.nodes[2].getbestblockhash() == goalbesthash)
+        assert self.nodes[2].getbestblockhash() == goalbesthash
         # Verify we can now have the data for a block previously pruned
-        assert(self.nodes[2].getblock(self.forkhash)["height"] == self.forkheight)
+        assert self.nodes[2].getblock(self.forkhash)["height"] == self.forkheight
 
     def manual_test(self, node_number, use_timestamp):
         # at this point, node has 995 blocks and has not yet run in prune mode

test/functional/feature_rbf.py

@@ -56,7 +56,7 @@ def make_utxo(node, amount, confirmed=True, scriptPubKey=CScript([1])):
             new_size = len(node.getrawmempool())
             # Error out if we have something stuck in the mempool, as this
             # would likely be a bug.
-            assert(new_size < mempool_size)
+            assert new_size < mempool_size
             mempool_size = new_size
 
     return COutPoint(int(txid, 16), 0)
@@ -163,8 +163,8 @@ def test_simple_doublespend(self):
 
         mempool = self.nodes[0].getrawmempool()
 
-        assert (tx1a_txid not in mempool)
-        assert (tx1b_txid in mempool)
+        assert tx1a_txid not in mempool
+        assert tx1b_txid in mempool
 
         assert_equal(tx1b_hex, self.nodes[0].getrawtransaction(tx1b_txid))
 
@@ -211,7 +211,7 @@ def test_doublespend_chain(self):
 
         mempool = self.nodes[0].getrawmempool()
         for doublespent_txid in chain_txids:
-            assert(doublespent_txid not in mempool)
+            assert doublespent_txid not in mempool
 
     def test_doublespend_tree(self):
         """Doublespend of a big tree of transactions"""
@@ -236,7 +236,7 @@ def branch(prevout, initial_value, max_txs, tree_width=5, fee=0.0001*COIN, _tota
             tx.vout = vout
             tx_hex = txToHex(tx)
 
-            assert(len(tx.serialize()) < 100000)
+            assert len(tx.serialize()) < 100000
             txid = self.nodes[0].sendrawtransaction(tx_hex, True)
             yield tx
             _total_txs[0] += 1
@@ -274,7 +274,7 @@ def branch(prevout, initial_value, max_txs, tree_width=5, fee=0.0001*COIN, _tota
 
         for tx in tree_txs:
             tx.rehash()
-            assert (tx.hash not in mempool)
+            assert tx.hash not in mempool
 
         # Try again, but with more total transactions than the "max txs
         # double-spent at once" anti-DoS limit.
@@ -529,7 +529,7 @@ def test_prioritised_transactions(self):
         # Now tx1b should be able to replace tx1a
         tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True)
 
-        assert(tx1b_txid in self.nodes[0].getrawmempool())
+        assert tx1b_txid in self.nodes[0].getrawmempool()
 
         # 2. Check that absolute fee checks use modified fee.
         tx1_outpoint = make_utxo(self.nodes[0], int(1.1*COIN))
@@ -556,7 +556,7 @@ def test_prioritised_transactions(self):
         # tx2b should now be accepted
         tx2b_txid = self.nodes[0].sendrawtransaction(tx2b_hex, True)
 
-        assert(tx2b_txid in self.nodes[0].getrawmempool())
+        assert tx2b_txid in self.nodes[0].getrawmempool()
 
     def test_rpc(self):
         us0 = self.nodes[0].listunspent()[0]

test/functional/feature_segwit.py

@@ -93,17 +93,17 @@ def run_test(self):
         self.log.info("Verify sigops are counted in GBT with pre-BIP141 rules before the fork")
         txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
         tmpl = self.nodes[0].getblocktemplate({'rules': ['segwit']})
-        assert(tmpl['sizelimit'] == 1000000)
-        assert('weightlimit' not in tmpl)
-        assert(tmpl['sigoplimit'] == 20000)
-        assert(tmpl['transactions'][0]['hash'] == txid)
-        assert(tmpl['transactions'][0]['sigops'] == 2)
+        assert tmpl['sizelimit'] == 1000000
+        assert 'weightlimit' not in tmpl
+        assert tmpl['sigoplimit'] == 20000
+        assert tmpl['transactions'][0]['hash'] == txid
+        assert tmpl['transactions'][0]['sigops'] == 2
         tmpl = self.nodes[0].getblocktemplate({'rules': ['segwit']})
-        assert(tmpl['sizelimit'] == 1000000)
-        assert('weightlimit' not in tmpl)
-        assert(tmpl['sigoplimit'] == 20000)
-        assert(tmpl['transactions'][0]['hash'] == txid)
-        assert(tmpl['transactions'][0]['sigops'] == 2)
+        assert tmpl['sizelimit'] == 1000000
+        assert 'weightlimit' not in tmpl
+        assert tmpl['sigoplimit'] == 20000
+        assert tmpl['transactions'][0]['hash'] == txid
+        assert tmpl['transactions'][0]['sigops'] == 2
         self.nodes[0].generate(1)  # block 162
 
         balance_presetup = self.nodes[0].getbalance()
@@ -172,16 +172,16 @@ def run_test(self):
         self.fail_accept(self.nodes[0], "mandatory-script-verify-flag", p2sh_ids[NODE_0][WIT_V1][0], False, witness_script(True, self.pubkey[0]))
 
         self.log.info("Verify block and transaction serialization rpcs return differing serializations depending on rpc serialization flag")
-        assert(self.nodes[2].getblock(blockhash, False) != self.nodes[0].getblock(blockhash, False))
-        assert(self.nodes[1].getblock(blockhash, False) == self.nodes[2].getblock(blockhash, False))
+        assert self.nodes[2].getblock(blockhash, False) != self.nodes[0].getblock(blockhash, False)
+        assert self.nodes[1].getblock(blockhash, False) == self.nodes[2].getblock(blockhash, False)
 
         for tx_id in segwit_tx_list:
             tx = FromHex(CTransaction(), self.nodes[2].gettransaction(tx_id)["hex"])
-            assert(self.nodes[2].getrawtransaction(tx_id, False, blockhash) != self.nodes[0].getrawtransaction(tx_id, False, blockhash))
-            assert(self.nodes[1].getrawtransaction(tx_id, False, blockhash) == self.nodes[2].getrawtransaction(tx_id, False, blockhash))
-            assert(self.nodes[0].getrawtransaction(tx_id, False, blockhash) != self.nodes[2].gettransaction(tx_id)["hex"])
-            assert(self.nodes[1].getrawtransaction(tx_id, False, blockhash) == self.nodes[2].gettransaction(tx_id)["hex"])
-            assert(self.nodes[0].getrawtransaction(tx_id, False, blockhash) == tx.serialize_without_witness().hex())
+            assert self.nodes[2].getrawtransaction(tx_id, False, blockhash) != self.nodes[0].getrawtransaction(tx_id, False, blockhash)
+            assert self.nodes[1].getrawtransaction(tx_id, False, blockhash) == self.nodes[2].getrawtransaction(tx_id, False, blockhash)
+            assert self.nodes[0].getrawtransaction(tx_id, False, blockhash) != self.nodes[2].gettransaction(tx_id)["hex"]
+            assert self.nodes[1].getrawtransaction(tx_id, False, blockhash) == self.nodes[2].gettransaction(tx_id)["hex"]
+            assert self.nodes[0].getrawtransaction(tx_id, False, blockhash) == tx.serialize_without_witness().hex()
 
         self.log.info("Verify witness txs without witness data are invalid after the fork")
         self.fail_accept(self.nodes[2], 'non-mandatory-script-verify-flag (Witness program hash mismatch) (code 64)', wit_ids[NODE_2][WIT_V0][2], sign=False)
@@ -198,11 +198,11 @@ def run_test(self):
         self.log.info("Verify sigops are counted in GBT with BIP141 rules after the fork")
         txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 1)
         tmpl = self.nodes[0].getblocktemplate({'rules': ['segwit']})
-        assert(tmpl['sizelimit'] >= 3999577)  # actual maximum size is lower due to minimum mandatory non-witness data
-        assert(tmpl['weightlimit'] == 4000000)
-        assert(tmpl['sigoplimit'] == 80000)
-        assert(tmpl['transactions'][0]['txid'] == txid)
-        assert(tmpl['transactions'][0]['sigops'] == 8)
+        assert tmpl['sizelimit'] >= 3999577  # actual maximum size is lower due to minimum mandatory non-witness data
+        assert tmpl['weightlimit'] == 4000000
+        assert tmpl['sigoplimit'] == 80000
+        assert tmpl['transactions'][0]['txid'] == txid
+        assert tmpl['transactions'][0]['sigops'] == 8
 
         self.nodes[0].generate(1)  # Mine a block to clear the gbt cache
 
@@ -214,8 +214,8 @@ def run_test(self):
         txid1 = send_to_witness(1, self.nodes[0], find_spendable_utxo(self.nodes[0], 50), self.pubkey[0], False, Decimal("49.996"))
         hex_tx = self.nodes[0].gettransaction(txid)['hex']
         tx = FromHex(CTransaction(), hex_tx)
-        assert(tx.wit.is_null())  # This should not be a segwit input
-        assert(txid1 in self.nodes[0].getrawmempool())
+        assert tx.wit.is_null()  # This should not be a segwit input
+        assert txid1 in self.nodes[0].getrawmempool()
 
         # Now create tx2, which will spend from txid1.
         tx = CTransaction()
@@ -224,23 +224,23 @@ def run_test(self):
         tx2_hex = self.nodes[0].signrawtransactionwithwallet(ToHex(tx))['hex']
         txid2 = self.nodes[0].sendrawtransaction(tx2_hex)
         tx = FromHex(CTransaction(), tx2_hex)
-        assert(not tx.wit.is_null())
+        assert not tx.wit.is_null()
 
         # Now create tx3, which will spend from txid2
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(int(txid2, 16), 0), b""))
         tx.vout.append(CTxOut(int(49.95 * COIN), CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))  # Huge fee
         tx.calc_sha256()
         txid3 = self.nodes[0].sendrawtransaction(ToHex(tx))
-        assert(tx.wit.is_null())
-        assert(txid3 in self.nodes[0].getrawmempool())
+        assert tx.wit.is_null()
+        assert txid3 in self.nodes[0].getrawmempool()
 
         # Check that getblocktemplate includes all transactions.
         template = self.nodes[0].getblocktemplate({"rules": ["segwit"]})
         template_txids = [t['txid'] for t in template['transactions']]
-        assert(txid1 in template_txids)
-        assert(txid2 in template_txids)
-        assert(txid3 in template_txids)
+        assert txid1 in template_txids
+        assert txid2 in template_txids
+        assert txid3 in template_txids
 
         # Check that wtxid is properly reported in mempool entry
         assert_equal(int(self.nodes[0].getmempoolentry(txid3)["wtxid"], 16), tx.calc_sha256(True))