2019-01-05 20:20:42 +01:00
|
|
|
#!/usr/bin/env python3
|
2020-04-16 19:14:08 +02:00
|
|
|
# Copyright (c) 2018-2020 The Bitcoin Core developers
|
2019-01-05 20:20:42 +01:00
|
|
|
# Distributed under the MIT software license, see the accompanying
|
|
|
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
"""Backwards compatibility functional test
|
|
|
|
|
|
|
|
Test various backwards compatibility scenarios. Download the previous node binaries:
|
|
|
|
|
2019-10-09 21:10:37 +02:00
|
|
|
contrib/devtools/previous_release.sh -b v0.19.0.1 v0.18.1 v0.17.1
|
2019-01-05 20:20:42 +01:00
|
|
|
|
|
|
|
Due to RPC changes introduced in various versions the below tests
|
|
|
|
won't work for older versions without some patches or workarounds.
|
|
|
|
|
|
|
|
Use only the latest patch version of each release, unless a test specifically
|
|
|
|
needs an older patch version.
|
|
|
|
"""
|
|
|
|
|
|
|
|
import os
|
2019-02-20 20:43:35 +01:00
|
|
|
import shutil
|
2019-01-05 20:20:42 +01:00
|
|
|
|
2020-04-30 15:36:54 +02:00
|
|
|
from test_framework.test_framework import BitcoinTestFramework
|
2019-02-20 21:40:29 +01:00
|
|
|
from test_framework.descriptors import descsum_create
|
2019-01-05 20:20:42 +01:00
|
|
|
|
|
|
|
from test_framework.util import (
|
|
|
|
assert_equal,
|
2019-02-20 20:43:35 +01:00
|
|
|
sync_blocks,
|
2020-04-30 15:36:54 +02:00
|
|
|
sync_mempools,
|
2019-01-05 20:20:42 +01:00
|
|
|
)
|
|
|
|
|
2020-04-30 15:36:54 +02:00
|
|
|
|
2019-01-05 20:20:42 +01:00
|
|
|
class BackwardsCompatibilityTest(BitcoinTestFramework):
|
|
|
|
def set_test_params(self):
|
|
|
|
self.setup_clean_chain = True
|
2019-10-09 21:10:37 +02:00
|
|
|
self.num_nodes = 5
|
2019-01-05 20:20:42 +01:00
|
|
|
# Add new version after each release:
|
|
|
|
self.extra_args = [
|
2019-02-20 20:43:35 +01:00
|
|
|
["-addresstype=bech32"], # Pre-release: use to mine blocks
|
|
|
|
["-nowallet", "-walletrbf=1", "-addresstype=bech32"], # Pre-release: use to receive coins, swap wallets, etc
|
2019-10-09 21:10:37 +02:00
|
|
|
["-nowallet", "-walletrbf=1", "-addresstype=bech32"], # v0.19.0.1
|
2019-02-20 20:43:35 +01:00
|
|
|
["-nowallet", "-walletrbf=1", "-addresstype=bech32"], # v0.18.1
|
|
|
|
["-nowallet", "-walletrbf=1", "-addresstype=bech32"] # v0.17.1
|
2019-01-05 20:20:42 +01:00
|
|
|
]
|
|
|
|
|
2020-04-06 03:03:17 +02:00
|
|
|
def skip_test_if_missing_module(self):
|
|
|
|
self.skip_if_no_wallet()
|
2020-04-30 15:36:54 +02:00
|
|
|
self.skip_if_no_previous_releases()
|
2020-04-06 03:03:17 +02:00
|
|
|
|
2019-01-05 20:20:42 +01:00
|
|
|
def setup_nodes(self):
|
|
|
|
self.add_nodes(self.num_nodes, extra_args=self.extra_args, versions=[
|
|
|
|
None,
|
|
|
|
None,
|
2020-04-30 15:36:54 +02:00
|
|
|
190001,
|
2019-01-05 20:20:42 +01:00
|
|
|
180100,
|
2020-04-30 15:36:54 +02:00
|
|
|
170100,
|
2019-01-05 20:20:42 +01:00
|
|
|
])
|
|
|
|
|
|
|
|
self.start_nodes()
|
|
|
|
|
|
|
|
def run_test(self):
|
2019-02-20 20:43:35 +01:00
|
|
|
self.nodes[0].generatetoaddress(101, self.nodes[0].getnewaddress())
|
2019-01-05 20:20:42 +01:00
|
|
|
|
|
|
|
sync_blocks(self.nodes)
|
|
|
|
|
|
|
|
# Sanity check the test framework:
|
|
|
|
res = self.nodes[self.num_nodes - 1].getblockchaininfo()
|
|
|
|
assert_equal(res['blocks'], 101)
|
|
|
|
|
2019-10-09 21:10:37 +02:00
|
|
|
node_master = self.nodes[self.num_nodes - 4]
|
|
|
|
node_v19 = self.nodes[self.num_nodes - 3]
|
2019-02-20 20:43:35 +01:00
|
|
|
node_v18 = self.nodes[self.num_nodes - 2]
|
|
|
|
node_v17 = self.nodes[self.num_nodes - 1]
|
|
|
|
|
|
|
|
self.log.info("Test wallet backwards compatibility...")
|
|
|
|
# Create a number of wallets and open them in older versions:
|
|
|
|
|
|
|
|
# w1: regular wallet, created on master: update this test when default
|
|
|
|
# wallets can no longer be opened by older versions.
|
2020-04-03 00:09:15 +02:00
|
|
|
node_master.rpc.createwallet(wallet_name="w1")
|
2019-02-20 20:43:35 +01:00
|
|
|
wallet = node_master.get_wallet_rpc("w1")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled']
|
|
|
|
assert info['keypoolsize'] > 0
|
|
|
|
# Create a confirmed transaction, receiving coins
|
|
|
|
address = wallet.getnewaddress()
|
|
|
|
self.nodes[0].sendtoaddress(address, 10)
|
|
|
|
sync_mempools(self.nodes)
|
|
|
|
self.nodes[0].generate(1)
|
|
|
|
sync_blocks(self.nodes)
|
|
|
|
# Create a conflicting transaction using RBF
|
|
|
|
return_address = self.nodes[0].getnewaddress()
|
|
|
|
tx1_id = self.nodes[1].sendtoaddress(return_address, 1)
|
|
|
|
tx2_id = self.nodes[1].bumpfee(tx1_id)["txid"]
|
|
|
|
# Confirm the transaction
|
|
|
|
sync_mempools(self.nodes)
|
|
|
|
self.nodes[0].generate(1)
|
|
|
|
sync_blocks(self.nodes)
|
|
|
|
# Create another conflicting transaction using RBF
|
|
|
|
tx3_id = self.nodes[1].sendtoaddress(return_address, 1)
|
|
|
|
tx4_id = self.nodes[1].bumpfee(tx3_id)["txid"]
|
2020-03-03 07:58:57 +01:00
|
|
|
# Abandon transaction, but don't confirm
|
2019-02-20 20:43:35 +01:00
|
|
|
self.nodes[1].abandontransaction(tx3_id)
|
|
|
|
|
2019-10-09 21:10:37 +02:00
|
|
|
# w1_v19: regular wallet, created with v0.19
|
2020-04-03 00:09:15 +02:00
|
|
|
node_v19.rpc.createwallet(wallet_name="w1_v19")
|
2019-10-09 21:10:37 +02:00
|
|
|
wallet = node_v19.get_wallet_rpc("w1_v19")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled']
|
|
|
|
assert info['keypoolsize'] > 0
|
2020-02-11 19:59:24 +01:00
|
|
|
# Use addmultisigaddress (see #18075)
|
2020-04-03 00:09:15 +02:00
|
|
|
address_18075 = wallet.rpc.addmultisigaddress(1, ["0296b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52", "037211a824f55b505228e4c3d5194c1fcfaa15a456abdf37f9b9d97a4040afc073"], "", "legacy")["address"]
|
2020-02-11 19:59:24 +01:00
|
|
|
assert wallet.getaddressinfo(address_18075)["solvable"]
|
2019-10-09 21:10:37 +02:00
|
|
|
|
2019-02-20 20:43:35 +01:00
|
|
|
# w1_v18: regular wallet, created with v0.18
|
2020-04-03 00:09:15 +02:00
|
|
|
node_v18.rpc.createwallet(wallet_name="w1_v18")
|
2019-02-20 20:43:35 +01:00
|
|
|
wallet = node_v18.get_wallet_rpc("w1_v18")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled']
|
|
|
|
assert info['keypoolsize'] > 0
|
|
|
|
|
|
|
|
# w2: wallet with private keys disabled, created on master: update this
|
|
|
|
# test when default wallets private keys disabled can no longer be
|
|
|
|
# opened by older versions.
|
2020-04-03 00:09:15 +02:00
|
|
|
node_master.rpc.createwallet(wallet_name="w2", disable_private_keys=True)
|
2019-02-20 20:43:35 +01:00
|
|
|
wallet = node_master.get_wallet_rpc("w2")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled'] == False
|
|
|
|
assert info['keypoolsize'] == 0
|
|
|
|
|
2019-10-09 21:10:37 +02:00
|
|
|
# w2_v19: wallet with private keys disabled, created with v0.19
|
2020-04-03 00:09:15 +02:00
|
|
|
node_v19.rpc.createwallet(wallet_name="w2_v19", disable_private_keys=True)
|
2019-10-09 21:10:37 +02:00
|
|
|
wallet = node_v19.get_wallet_rpc("w2_v19")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled'] == False
|
|
|
|
assert info['keypoolsize'] == 0
|
|
|
|
|
2019-02-20 20:43:35 +01:00
|
|
|
# w2_v18: wallet with private keys disabled, created with v0.18
|
2020-04-03 00:09:15 +02:00
|
|
|
node_v18.rpc.createwallet(wallet_name="w2_v18", disable_private_keys=True)
|
2019-02-20 20:43:35 +01:00
|
|
|
wallet = node_v18.get_wallet_rpc("w2_v18")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled'] == False
|
|
|
|
assert info['keypoolsize'] == 0
|
|
|
|
|
|
|
|
# w3: blank wallet, created on master: update this
|
|
|
|
# test when default blank wallets can no longer be opened by older versions.
|
2020-04-03 00:09:15 +02:00
|
|
|
node_master.rpc.createwallet(wallet_name="w3", blank=True)
|
2019-02-20 20:43:35 +01:00
|
|
|
wallet = node_master.get_wallet_rpc("w3")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled']
|
|
|
|
assert info['keypoolsize'] == 0
|
|
|
|
|
2019-10-09 21:10:37 +02:00
|
|
|
# w3_v19: blank wallet, created with v0.19
|
2020-04-03 00:09:15 +02:00
|
|
|
node_v19.rpc.createwallet(wallet_name="w3_v19", blank=True)
|
2019-10-09 21:10:37 +02:00
|
|
|
wallet = node_v19.get_wallet_rpc("w3_v19")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled']
|
|
|
|
assert info['keypoolsize'] == 0
|
|
|
|
|
2019-02-20 20:43:35 +01:00
|
|
|
# w3_v18: blank wallet, created with v0.18
|
2020-04-03 00:09:15 +02:00
|
|
|
node_v18.rpc.createwallet(wallet_name="w3_v18", blank=True)
|
2019-02-20 20:43:35 +01:00
|
|
|
wallet = node_v18.get_wallet_rpc("w3_v18")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled']
|
|
|
|
assert info['keypoolsize'] == 0
|
|
|
|
|
|
|
|
# Copy the wallets to older nodes:
|
|
|
|
node_master_wallets_dir = os.path.join(node_master.datadir, "regtest/wallets")
|
2019-10-09 21:10:37 +02:00
|
|
|
node_v19_wallets_dir = os.path.join(node_v19.datadir, "regtest/wallets")
|
2019-02-20 20:43:35 +01:00
|
|
|
node_v18_wallets_dir = os.path.join(node_v18.datadir, "regtest/wallets")
|
|
|
|
node_v17_wallets_dir = os.path.join(node_v17.datadir, "regtest/wallets")
|
|
|
|
node_master.unloadwallet("w1")
|
|
|
|
node_master.unloadwallet("w2")
|
2019-10-09 21:10:37 +02:00
|
|
|
node_v19.unloadwallet("w1_v19")
|
|
|
|
node_v19.unloadwallet("w2_v19")
|
2019-02-20 20:43:35 +01:00
|
|
|
node_v18.unloadwallet("w1_v18")
|
|
|
|
node_v18.unloadwallet("w2_v18")
|
|
|
|
|
|
|
|
# Copy wallets to v0.17
|
|
|
|
for wallet in os.listdir(node_master_wallets_dir):
|
|
|
|
shutil.copytree(
|
|
|
|
os.path.join(node_master_wallets_dir, wallet),
|
|
|
|
os.path.join(node_v17_wallets_dir, wallet)
|
|
|
|
)
|
|
|
|
for wallet in os.listdir(node_v18_wallets_dir):
|
|
|
|
shutil.copytree(
|
|
|
|
os.path.join(node_v18_wallets_dir, wallet),
|
|
|
|
os.path.join(node_v17_wallets_dir, wallet)
|
|
|
|
)
|
|
|
|
|
|
|
|
# Copy wallets to v0.18
|
|
|
|
for wallet in os.listdir(node_master_wallets_dir):
|
|
|
|
shutil.copytree(
|
|
|
|
os.path.join(node_master_wallets_dir, wallet),
|
|
|
|
os.path.join(node_v18_wallets_dir, wallet)
|
|
|
|
)
|
|
|
|
|
2019-10-09 21:10:37 +02:00
|
|
|
# Copy wallets to v0.19
|
|
|
|
for wallet in os.listdir(node_master_wallets_dir):
|
|
|
|
shutil.copytree(
|
|
|
|
os.path.join(node_master_wallets_dir, wallet),
|
|
|
|
os.path.join(node_v19_wallets_dir, wallet)
|
|
|
|
)
|
|
|
|
|
|
|
|
# Open the wallets in v0.19
|
|
|
|
node_v19.loadwallet("w1")
|
|
|
|
wallet = node_v19.get_wallet_rpc("w1")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled']
|
|
|
|
assert info['keypoolsize'] > 0
|
|
|
|
txs = wallet.listtransactions()
|
|
|
|
assert_equal(len(txs), 5)
|
|
|
|
assert_equal(txs[1]["txid"], tx1_id)
|
|
|
|
assert_equal(txs[2]["walletconflicts"], [tx1_id])
|
|
|
|
assert_equal(txs[1]["replaced_by_txid"], tx2_id)
|
|
|
|
assert not(txs[1]["abandoned"])
|
|
|
|
assert_equal(txs[1]["confirmations"], -1)
|
|
|
|
assert_equal(txs[2]["blockindex"], 1)
|
|
|
|
assert txs[3]["abandoned"]
|
|
|
|
assert_equal(txs[4]["walletconflicts"], [tx3_id])
|
|
|
|
assert_equal(txs[3]["replaced_by_txid"], tx4_id)
|
|
|
|
assert not(hasattr(txs[3], "blockindex"))
|
|
|
|
|
|
|
|
node_v19.loadwallet("w2")
|
|
|
|
wallet = node_v19.get_wallet_rpc("w2")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled'] == False
|
|
|
|
assert info['keypoolsize'] == 0
|
|
|
|
|
|
|
|
node_v19.loadwallet("w3")
|
|
|
|
wallet = node_v19.get_wallet_rpc("w3")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled']
|
|
|
|
assert info['keypoolsize'] == 0
|
|
|
|
|
2019-02-20 20:43:35 +01:00
|
|
|
# Open the wallets in v0.18
|
|
|
|
node_v18.loadwallet("w1")
|
|
|
|
wallet = node_v18.get_wallet_rpc("w1")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled']
|
|
|
|
assert info['keypoolsize'] > 0
|
|
|
|
txs = wallet.listtransactions()
|
|
|
|
assert_equal(len(txs), 5)
|
|
|
|
assert_equal(txs[1]["txid"], tx1_id)
|
|
|
|
assert_equal(txs[2]["walletconflicts"], [tx1_id])
|
|
|
|
assert_equal(txs[1]["replaced_by_txid"], tx2_id)
|
|
|
|
assert not(txs[1]["abandoned"])
|
|
|
|
assert_equal(txs[1]["confirmations"], -1)
|
|
|
|
assert_equal(txs[2]["blockindex"], 1)
|
|
|
|
assert txs[3]["abandoned"]
|
|
|
|
assert_equal(txs[4]["walletconflicts"], [tx3_id])
|
|
|
|
assert_equal(txs[3]["replaced_by_txid"], tx4_id)
|
|
|
|
assert not(hasattr(txs[3], "blockindex"))
|
|
|
|
|
|
|
|
node_v18.loadwallet("w2")
|
|
|
|
wallet = node_v18.get_wallet_rpc("w2")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled'] == False
|
|
|
|
assert info['keypoolsize'] == 0
|
|
|
|
|
|
|
|
node_v18.loadwallet("w3")
|
|
|
|
wallet = node_v18.get_wallet_rpc("w3")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled']
|
|
|
|
assert info['keypoolsize'] == 0
|
|
|
|
|
|
|
|
# Open the wallets in v0.17
|
|
|
|
node_v17.loadwallet("w1_v18")
|
|
|
|
wallet = node_v17.get_wallet_rpc("w1_v18")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled']
|
|
|
|
assert info['keypoolsize'] > 0
|
|
|
|
|
|
|
|
node_v17.loadwallet("w1")
|
|
|
|
wallet = node_v17.get_wallet_rpc("w1")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled']
|
|
|
|
assert info['keypoolsize'] > 0
|
|
|
|
|
|
|
|
node_v17.loadwallet("w2_v18")
|
|
|
|
wallet = node_v17.get_wallet_rpc("w2_v18")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled'] == False
|
|
|
|
assert info['keypoolsize'] == 0
|
|
|
|
|
|
|
|
node_v17.loadwallet("w2")
|
|
|
|
wallet = node_v17.get_wallet_rpc("w2")
|
|
|
|
info = wallet.getwalletinfo()
|
|
|
|
assert info['private_keys_enabled'] == False
|
|
|
|
assert info['keypoolsize'] == 0
|
|
|
|
|
|
|
|
# RPC loadwallet failure causes bitcoind to exit, in addition to the RPC
|
|
|
|
# call failure, so the following test won't work:
|
|
|
|
# assert_raises_rpc_error(-4, "Wallet loading failed.", node_v17.loadwallet, 'w3_v18')
|
|
|
|
|
|
|
|
# Instead, we stop node and try to launch it with the wallet:
|
|
|
|
self.stop_node(self.num_nodes - 1)
|
|
|
|
node_v17.assert_start_raises_init_error(["-wallet=w3_v18"], "Error: Error loading w3_v18: Wallet requires newer version of Bitcoin Core")
|
|
|
|
node_v17.assert_start_raises_init_error(["-wallet=w3"], "Error: Error loading w3: Wallet requires newer version of Bitcoin Core")
|
2019-02-20 21:40:29 +01:00
|
|
|
self.start_node(self.num_nodes - 1)
|
|
|
|
|
|
|
|
self.log.info("Test wallet upgrade path...")
|
|
|
|
# u1: regular wallet, created with v0.17
|
2020-04-03 00:09:15 +02:00
|
|
|
node_v17.rpc.createwallet(wallet_name="u1_v17")
|
2019-02-20 21:40:29 +01:00
|
|
|
wallet = node_v17.get_wallet_rpc("u1_v17")
|
|
|
|
address = wallet.getnewaddress("bech32")
|
2020-05-03 05:33:33 +02:00
|
|
|
v17_info = wallet.getaddressinfo(address)
|
|
|
|
hdkeypath = v17_info["hdkeypath"]
|
|
|
|
pubkey = v17_info["pubkey"]
|
2019-02-20 21:40:29 +01:00
|
|
|
|
2020-02-11 19:59:24 +01:00
|
|
|
# Copy the 0.17 wallet to the last Bitcoin Core version and open it:
|
2019-02-20 21:40:29 +01:00
|
|
|
node_v17.unloadwallet("u1_v17")
|
|
|
|
shutil.copytree(
|
|
|
|
os.path.join(node_v17_wallets_dir, "u1_v17"),
|
|
|
|
os.path.join(node_master_wallets_dir, "u1_v17")
|
|
|
|
)
|
|
|
|
node_master.loadwallet("u1_v17")
|
|
|
|
wallet = node_master.get_wallet_rpc("u1_v17")
|
|
|
|
info = wallet.getaddressinfo(address)
|
|
|
|
descriptor = "wpkh([" + info["hdmasterfingerprint"] + hdkeypath[1:] + "]" + pubkey + ")"
|
|
|
|
assert_equal(info["desc"], descsum_create(descriptor))
|
2019-02-20 20:43:35 +01:00
|
|
|
|
2020-05-03 05:33:33 +02:00
|
|
|
# Now copy that same wallet back to 0.17 to make sure no automatic upgrade breaks it
|
|
|
|
node_master.unloadwallet("u1_v17")
|
|
|
|
shutil.rmtree(os.path.join(node_v17_wallets_dir, "u1_v17"))
|
|
|
|
shutil.copytree(
|
|
|
|
os.path.join(node_master_wallets_dir, "u1_v17"),
|
|
|
|
os.path.join(node_v17_wallets_dir, "u1_v17")
|
|
|
|
)
|
|
|
|
node_v17.loadwallet("u1_v17")
|
|
|
|
wallet = node_v17.get_wallet_rpc("u1_v17")
|
|
|
|
info = wallet.getaddressinfo(address)
|
|
|
|
assert_equal(info, v17_info)
|
|
|
|
|
2020-02-11 19:59:24 +01:00
|
|
|
# Copy the 0.19 wallet to the last Bitcoin Core version and open it:
|
|
|
|
shutil.copytree(
|
|
|
|
os.path.join(node_v19_wallets_dir, "w1_v19"),
|
|
|
|
os.path.join(node_master_wallets_dir, "w1_v19")
|
|
|
|
)
|
|
|
|
node_master.loadwallet("w1_v19")
|
|
|
|
wallet = node_master.get_wallet_rpc("w1_v19")
|
|
|
|
assert wallet.getaddressinfo(address_18075)["solvable"]
|
|
|
|
|
2020-05-03 05:33:33 +02:00
|
|
|
# Now copy that same wallet back to 0.19 to make sure no automatic upgrade breaks it
|
|
|
|
node_master.unloadwallet("w1_v19")
|
|
|
|
shutil.rmtree(os.path.join(node_v19_wallets_dir, "w1_v19"))
|
|
|
|
shutil.copytree(
|
|
|
|
os.path.join(node_master_wallets_dir, "w1_v19"),
|
|
|
|
os.path.join(node_v19_wallets_dir, "w1_v19")
|
|
|
|
)
|
|
|
|
node_v19.loadwallet("w1_v19")
|
|
|
|
wallet = node_v19.get_wallet_rpc("w1_v19")
|
|
|
|
assert wallet.getaddressinfo(address_18075)["solvable"]
|
|
|
|
|
2019-01-05 20:20:42 +01:00
|
|
|
if __name__ == '__main__':
|
|
|
|
BackwardsCompatibilityTest().main()
|