tooltest.py 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520
  1. #!/usr/bin/env python3
  2. #
  3. # mmgen = Multi-Mode GENerator, command-line Bitcoin cold storage solution
  4. # Copyright (C)2013-2019 The MMGen Project <mmgen@tuta.io>
  5. #
  6. # This program is free software: you can redistribute it and/or modify
  7. # it under the terms of the GNU General Public License as published by
  8. # the Free Software Foundation, either version 3 of the License, or
  9. # (at your option) any later version.
  10. #
  11. # This program is distributed in the hope that it will be useful,
  12. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. # GNU General Public License for more details.
  15. #
  16. # You should have received a copy of the GNU General Public License
  17. # along with this program. If not, see <http://www.gnu.org/licenses/>.
  18. """
  19. test/tooltest.py: Tests for the 'mmgen-tool' utility
  20. """
  21. import sys,os,subprocess,binascii
  22. repo_root = os.path.normpath(os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]),os.pardir)))
  23. os.chdir(repo_root)
  24. sys.path.__setitem__(0,repo_root)
  25. os.environ['MMGEN_TEST_SUITE'] = '1'
  26. # Import this _after_ local path's been added to sys.path
  27. from mmgen.common import *
  28. from test.common import *
  29. opts_data = lambda: {
  30. 'desc': "Test suite for the 'mmgen-tool' utility",
  31. 'usage':'[options] [command]',
  32. 'options': """
  33. -h, --help Print this help message
  34. -C, --coverage Produce code coverage info using trace module
  35. -d, --debug Produce debugging output (stderr from spawned script)
  36. --, --longhelp Print help message for long options (common options)
  37. -l, --list-cmds List and describe the tests and commands in this test suite
  38. -L, --list-names List the names of all tested 'mmgen-tool' commands
  39. -s, --system Test scripts and modules installed on system rather than
  40. those in the repo root
  41. -t, --type=t Specify address type (valid options: 'zcash_z')
  42. -v, --verbose Produce more verbose output
  43. """,
  44. 'notes': """
  45. If no command is given, the whole suite of tests is run.
  46. """
  47. }
  48. sys.argv = [sys.argv[0]] + ['--skip-cfg-file'] + sys.argv[1:]
  49. cmd_args = opts.init(opts_data,add_opts=['exact_output','profile'])
  50. from collections import OrderedDict
  51. cmd_data = OrderedDict([
  52. ('util', {
  53. 'desc': 'base conversion, hashing and file utilities',
  54. 'cmd_data': OrderedDict([
  55. ('strtob58', ()),
  56. ('b58tostr', ('strtob58','io')),
  57. ('hextob58', ()),
  58. ('b58tohex', ('hextob58','io')),
  59. ('b58randenc', ()),
  60. ('hextob32', ()),
  61. ('b32tohex', ('hextob32','io')),
  62. ('randhex', ()),
  63. ('id6', ()),
  64. ('id8', ()),
  65. ('str2id6', ()),
  66. ('hash160', ()),
  67. ('hash256', ()),
  68. ('hexreverse', ()),
  69. ('hexlify', ()),
  70. ('hexdump', ()),
  71. ('unhexdump', ('hexdump','io')),
  72. ('rand2file', ()),
  73. ])
  74. }
  75. ),
  76. ('cryptocoin', {
  77. 'desc': 'Cryptocoin address/key commands',
  78. 'cmd_data': OrderedDict([
  79. ('randwif', ()),
  80. ('randpair', ()), # create 4 pairs: uncomp,comp,segwit,bech32
  81. ('wif2addr', ('randpair','o4')),
  82. ('wif2hex', ('randpair','o4')),
  83. ('privhex2pubhex', ('wif2hex','o3')), # segwit only
  84. ('pubhex2addr', ('privhex2pubhex','o3')), # segwit only
  85. ('hex2wif', ('wif2hex','io2')), # uncomp, comp
  86. ('addr2hexaddr', ('randpair','o4'))] + # uncomp, comp, bech32
  87. ([],[
  88. ('pubhash2addr', ('addr2hexaddr','io4')) # uncomp, comp, bech32
  89. ])[opt.type != 'zcash_z'] +
  90. ([],[
  91. ('pubhex2redeem_script', ('privhex2pubhex','o3')),
  92. ('wif2redeem_script', ('randpair','o3')),
  93. ('wif2segwit_pair', ('randpair','o2')),
  94. ('privhex2addr', ('wif2hex','o4')), # compare with output of randpair
  95. ('pipetest', ('randpair','o3'))
  96. ])[g.coin in ('BTC','LTC')]
  97. )
  98. }
  99. ),
  100. ('mnemonic', {
  101. 'desc': 'mnemonic commands',
  102. 'cmd_data': OrderedDict([
  103. ('hex2mn', ()),
  104. ('mn2hex', ('hex2mn','io3')),
  105. ('mn_rand128', ()),
  106. ('mn_rand192', ()),
  107. ('mn_rand256', ()),
  108. ('mn_stats', ()),
  109. ('mn_printlist', ()),
  110. ])
  111. }
  112. ),
  113. ])
  114. cfg = {
  115. 'name': 'the tool utility',
  116. 'enc_passwd': 'Ten Satoshis',
  117. 'tmpdir': 'test/tmp10',
  118. 'tmpdir_num': 10,
  119. 'refdir': 'test/ref',
  120. 'txfile': {
  121. 'btc': ('0B8D5A[15.31789,14,tl=1320969600].rawtx',
  122. '0C7115[15.86255,14,tl=1320969600].testnet.rawtx'),
  123. 'bch': ('460D4D-BCH[10.19764,tl=1320969600].rawtx',
  124. '359FD5-BCH[6.68868,tl=1320969600].testnet.rawtx'),
  125. 'ltc': ('AF3CDF-LTC[620.76194,1453,tl=1320969600].rawtx',
  126. 'A5A1E0-LTC[1454.64322,1453,tl=1320969600].testnet.rawtx'),
  127. },
  128. 'addrfile': '98831F3A{}[1,31-33,500-501,1010-1011]{}.addrs',
  129. 'addrfile_chk': {
  130. 'btc': ('6FEF 6FB9 7B13 5D91','424E 4326 CFFE 5F51'),
  131. 'bch': ('6FEF 6FB9 7B13 5D91','424E 4326 CFFE 5F51'),
  132. 'ltc': ('AD52 C3FE 8924 AAF0','4EBE 2E85 E969 1B30'),
  133. }
  134. }
  135. ref_subdir = '' if g.proto.base_coin == 'BTC' else g.proto.name
  136. altcoin_pfx = '' if g.proto.base_coin == 'BTC' else '-'+g.proto.base_coin
  137. tn_ext = ('','.testnet')[g.testnet]
  138. mmgen_cmd = 'mmgen-tool'
  139. if not opt.system:
  140. os.environ['PYTHONPATH'] = repo_root
  141. mmgen_cmd = os.path.relpath(os.path.join(repo_root,'cmds',mmgen_cmd))
  142. spawn_cmd = [mmgen_cmd]
  143. if opt.coverage:
  144. d,f = init_coverage()
  145. spawn_cmd = ['python','-m','trace','--count','--coverdir='+d,'--file='+f] + spawn_cmd
  146. elif g.platform == 'win':
  147. spawn_cmd = ['python'] + spawn_cmd
  148. add_spawn_args = ['--data-dir='+cfg['tmpdir']] + ['--{}{}'.format(
  149. k.replace('_','-'),'='+getattr(opt,k) if getattr(opt,k) != True else '')
  150. for k in ('testnet','rpc_host','regtest','coin','type') if getattr(opt,k)]
  151. if opt.list_cmds:
  152. fs = ' {:<{w}} - {}'
  153. Msg('Available commands:')
  154. w = max(map(len,cmd_data))
  155. for cmd in cmd_data:
  156. Msg(fs.format(cmd,cmd_data[cmd]['desc'],w=w))
  157. Msg('\nAvailable utilities:')
  158. Msg(fs.format('clean','Clean the tmp directory',w=w))
  159. sys.exit(0)
  160. if opt.list_names:
  161. tested_in = {
  162. 'tooltest.py': [],
  163. 'test.py': (
  164. 'encrypt','decrypt','find_incog_data',
  165. 'addrfile_chksum','keyaddrfile_chksum','passwdfile_chksum',
  166. 'add_label','remove_label','remove_address','twview',
  167. 'getbalance','listaddresses','listaddress'),
  168. 'test-release.sh': ('keyaddrlist2monerowallets','syncmonerowallets'),
  169. 'tooltest2.py': subprocess.check_output(['test/tooltest2.py','--list-tested-cmds']).decode().split()
  170. }
  171. for v in cmd_data.values():
  172. tested_in['tooltest.py'] += list(v['cmd_data'].keys())
  173. msg(green("TESTED 'MMGEN-TOOL' COMMANDS"))
  174. for l in ('tooltest.py','tooltest2.py','test.py','test-release.sh'):
  175. msg(blue(l+':'))
  176. msg(' '+'\n '.join(sorted(tested_in[l])))
  177. ignore = ()
  178. from mmgen.tool import MMGenToolCmd
  179. uc = sorted(
  180. set(MMGenToolCmd.user_commands()) -
  181. set(ignore) -
  182. set(tested_in['tooltest.py']) -
  183. set(tested_in['tooltest2.py']) -
  184. set(tested_in['test.py']) -
  185. set(tested_in['test-release.sh'])
  186. )
  187. die(0,'\n{}\n {}'.format(yellow('Untested commands:'),'\n '.join(uc)))
  188. from mmgen.tx import is_wif,is_coin_addr
  189. msg_w = 33
  190. def test_msg(m):
  191. m2 = 'Testing {}'.format(m)
  192. msg_r(green(m2+'\n') if opt.verbose else '{:{w}}'.format(m2,w=msg_w+8))
  193. maybe_compressed = ('','compressed')['C' in g.proto.mmtypes]
  194. maybe_segwit = ('','segwit')['S' in g.proto.mmtypes]
  195. maybe_bech32 = ('','bech32')['B' in g.proto.mmtypes]
  196. maybe_type_compressed = ([],['--type=compressed'])['C' in g.proto.mmtypes]
  197. maybe_type_segwit = ([],['--type=segwit'])['S' in g.proto.mmtypes]
  198. maybe_type_bech32 = ([],['--type=bech32'])['B' in g.proto.mmtypes]
  199. class MMGenToolTestUtils(object):
  200. def run_cmd(self,name,tool_args,kwargs='',extra_msg='',silent=False,strip=True,add_opts=[],binary=False):
  201. sys_cmd = (
  202. spawn_cmd +
  203. add_spawn_args +
  204. ['-r0','-d',cfg['tmpdir']] +
  205. add_opts +
  206. [name.lower()] +
  207. tool_args +
  208. kwargs.split()
  209. )
  210. if extra_msg: extra_msg = '({})'.format(extra_msg)
  211. full_name = ' '.join([name.lower()]+add_opts+kwargs.split()+extra_msg.split())
  212. if not silent:
  213. if opt.verbose:
  214. sys.stderr.write(green('Testing {}\nExecuting '.format(full_name)))
  215. sys.stderr.write(cyan(' '.join(sys_cmd)+'\n'))
  216. else:
  217. msg_r('Testing {:{w}}'.format(full_name+':',w=msg_w))
  218. p = subprocess.Popen(sys_cmd,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
  219. a,b = p.communicate()
  220. if opt.debug:
  221. try: dmsg(b.decode())
  222. except: dmsg(repr(b))
  223. if not binary: a = a.decode()
  224. retcode = p.wait()
  225. if retcode != 0:
  226. msg('{}\n{}\n{}'.format(red('FAILED'),yellow('Command stderr output:'),b.decode()))
  227. rdie(1,'Called process returned with an error (retcode {})'.format(retcode))
  228. return (a,a.rstrip())[bool(strip)]
  229. def run_cmd_chk(self,name,f1,f2,kwargs='',extra_msg='',strip_hex=False,add_opts=[]):
  230. idata = read_from_file(f1).rstrip()
  231. odata = read_from_file(f2).rstrip()
  232. ret = self.run_cmd(name,[odata],kwargs=kwargs,extra_msg=extra_msg,add_opts=add_opts)
  233. vmsg('In: ' + repr(odata))
  234. vmsg('Out: ' + repr(ret))
  235. def cmp_equal(a,b):
  236. return (a.lstrip('0') == b.lstrip('0')) if strip_hex else (a == b)
  237. if cmp_equal(ret,idata): ok()
  238. else:
  239. fs = "Error: values don't match:\nIn: {!r}\nOut: {!r}"
  240. rdie(3,fs.format(idata,ret))
  241. return ret
  242. def run_cmd_nochk(self,name,f1,kwargs='',add_opts=[]):
  243. odata = read_from_file(f1).rstrip()
  244. ret = self.run_cmd(name,[odata],kwargs=kwargs,add_opts=add_opts)
  245. vmsg('In: ' + repr(odata))
  246. vmsg('Out: ' + repr(ret))
  247. return ret
  248. def run_cmd_out(self,name,carg=None,Return=False,kwargs='',fn_idx='',extra_msg='',
  249. literal=False,chkdata='',hush=False,add_opts=[]):
  250. if carg: write_to_tmpfile(cfg,'{}{}.in'.format(name,fn_idx),carg+'\n')
  251. ret = self.run_cmd(name,([],[carg])[bool(carg)],kwargs=kwargs,
  252. extra_msg=extra_msg,add_opts=add_opts)
  253. if carg: vmsg('In: ' + repr(carg))
  254. vmsg('Out: ' + (repr(ret),ret)[literal])
  255. if ret or ret == '':
  256. write_to_tmpfile(cfg,'{}{}.out'.format(name,fn_idx),ret+'\n')
  257. if chkdata:
  258. cmp_or_die(ret,chkdata)
  259. return
  260. if Return: return ret
  261. else:
  262. if not hush: ok()
  263. else:
  264. rdie(3,"Error for command '{}'".format(name))
  265. def run_cmd_randinput(self,name,strip=True,add_opts=[]):
  266. s = os.urandom(128)
  267. fn = name+'.in'
  268. write_to_tmpfile(cfg,fn,s,binary=True)
  269. ret = self.run_cmd(name,[get_tmpfile(cfg,fn)],strip=strip,add_opts=add_opts)
  270. fn = name+'.out'
  271. write_to_tmpfile(cfg,fn,ret+'\n')
  272. ok()
  273. vmsg('Returned: {}'.format(ret))
  274. tu = MMGenToolTestUtils()
  275. def ok_or_die(val,chk_func,s,skip_ok=False):
  276. try: ret = chk_func(val)
  277. except: ret = False
  278. if ret:
  279. if not skip_ok: ok()
  280. else:
  281. rdie(3,"Returned value '{}' is not a {}".format((val,s)))
  282. class MMGenToolTestCmds(object):
  283. # Util
  284. def strtob58(self,name): tu.run_cmd_out(name,getrandstr(16))
  285. def b58tostr(self,name,f1,f2): tu.run_cmd_chk(name,f1,f2)
  286. def hextob58(self,name): tu.run_cmd_out(name,getrandhex(32))
  287. def b58tohex(self,name,f1,f2): tu.run_cmd_chk(name,f1,f2,strip_hex=True)
  288. def b58randenc(self,name):
  289. ret = tu.run_cmd_out(name,Return=True)
  290. ok_or_die(ret,is_b58_str,'base 58 string')
  291. def hextob32(self,name): tu.run_cmd_out(name,getrandhex(24))
  292. def b32tohex(self,name,f1,f2): tu.run_cmd_chk(name,f1,f2,strip_hex=True)
  293. def randhex(self,name):
  294. ret = tu.run_cmd_out(name,Return=True)
  295. ok_or_die(ret,binascii.unhexlify,'hex string')
  296. def id6(self,name): tu.run_cmd_randinput(name)
  297. def id8(self,name): tu.run_cmd_randinput(name)
  298. def str2id6(self,name):
  299. s = getrandstr(120,no_space=True)
  300. s2 = ' {} {} {} {} {} '.format(s[:3],s[3:9],s[9:29],s[29:50],s[50:120])
  301. ret1 = tu.run_cmd(name,[s],extra_msg='unspaced input'); ok()
  302. ret2 = tu.run_cmd(name,[s2],extra_msg='spaced input')
  303. cmp_or_die(ret1,ret2)
  304. vmsg('Returned: {}'.format(ret1))
  305. ok()
  306. def hash160(self,name): tu.run_cmd_out(name,getrandhex(16))
  307. def hash256(self,name): tu.run_cmd_out(name,getrandstr(16))
  308. def hexreverse(self,name): tu.run_cmd_out(name,getrandhex(24))
  309. def hexlify(self,name): tu.run_cmd_out(name,getrandstr(24))
  310. def hexdump(self,name): tu.run_cmd_randinput(name,strip=False)
  311. def unhexdump(self,name,fn1,fn2):
  312. ret = tu.run_cmd(name,[fn2],strip=False,binary=True)
  313. orig = read_from_file(fn1,binary=True)
  314. cmp_or_die(orig,ret)
  315. ok()
  316. def rand2file(self,name):
  317. of = name + '.out'
  318. dlen = 1024
  319. tu.run_cmd(name,[of,str(1024),'threads=4','silent=1'],strip=False)
  320. d = read_from_tmpfile(cfg,of,binary=True)
  321. cmp_or_die(dlen,len(d))
  322. ok()
  323. # Cryptocoin
  324. def randwif(self,name):
  325. for n,k in enumerate(['',maybe_compressed]):
  326. ao = ['--type='+k] if k else []
  327. ret = tu.run_cmd_out(name,add_opts=ao,Return=True,fn_idx=n+1)
  328. ok_or_die(ret,is_wif,'WIF key')
  329. def randpair(self,name):
  330. for n,k in enumerate(['',maybe_compressed,maybe_segwit,maybe_bech32]):
  331. ao = ['--type='+k] if k else []
  332. wif,addr = tu.run_cmd_out(name,add_opts=ao,Return=True,fn_idx=n+1).split()
  333. ok_or_die(wif,is_wif,'WIF key',skip_ok=True)
  334. ok_or_die(addr,is_coin_addr,'Coin address')
  335. def wif2addr(self,name,f1,f2,f3,f4):
  336. for n,f,k,m in (
  337. (1,f1,'',''),
  338. (2,f2,'',maybe_compressed),
  339. (3,f3,maybe_segwit,''),
  340. (4,f4,maybe_bech32,'')
  341. ):
  342. ao = ['--type='+k] if k else []
  343. wif = read_from_file(f).split()[0]
  344. tu.run_cmd_out(name,wif,add_opts=ao,fn_idx=n,extra_msg=m)
  345. def wif2hex(self,name,f1,f2,f3,f4):
  346. for n,f,m in (
  347. (1,f1,''),
  348. (2,f2,maybe_compressed),
  349. (3,f3,'{} for {}'.format(maybe_compressed,maybe_segwit)),
  350. (4,f4,'{} for {}'.format(maybe_compressed,maybe_bech32))
  351. ):
  352. wif = read_from_file(f).split()[0]
  353. tu.run_cmd_out(name,wif,fn_idx=n,extra_msg=m)
  354. def privhex2addr(self,name,f1,f2,f3,f4):
  355. keys = [read_from_file(f).rstrip() for f in (f1,f2,f3,f4)]
  356. for n,k in enumerate(('',maybe_compressed,maybe_segwit,maybe_bech32)):
  357. ao = ['--type='+k] if k else []
  358. ret = tu.run_cmd(name,[keys[n]],add_opts=ao).rstrip()
  359. iaddr = read_from_tmpfile(cfg,'randpair{}.out'.format(n+1)).split()[-1]
  360. vmsg('Out: {}'.format(ret))
  361. cmp_or_die(iaddr,ret)
  362. ok()
  363. def hex2wif(self,name,f1,f2,f3,f4):
  364. for n,fi,fo,k in ((1,f1,f2,''),(2,f3,f4,maybe_compressed)):
  365. ao = ['--type='+k] if k else []
  366. ret = tu.run_cmd_chk(name,fi,fo,add_opts=ao)
  367. def addr2hexaddr(self,name,f1,f2,f3,f4):
  368. for n,f,m,ao in (
  369. (1,f1,'',[]),
  370. (2,f2,'from {}'.format(maybe_compressed),[]),
  371. (4,f4,'',maybe_type_bech32),
  372. ):
  373. addr = read_from_file(f).split()[-1]
  374. tu.run_cmd_out(name,addr,fn_idx=n,add_opts=ao,extra_msg=m)
  375. def pubhash2addr(self,name,f1,f2,f3,f4,f5,f6,f7,f8):
  376. for n,fi,fo,m,ao in (
  377. (1,f1,f2,'',[]),
  378. (2,f3,f4,'from {}'.format(maybe_compressed),[]),
  379. (4,f7,f8,'',maybe_type_bech32)
  380. ):
  381. tu.run_cmd_chk(name,fi,fo,add_opts=ao,extra_msg=m)
  382. def privhex2pubhex(self,name,f1,f2,f3): # from Hex2wif
  383. addr = read_from_file(f3).strip()
  384. tu.run_cmd_out(name,addr,add_opts=maybe_type_compressed,fn_idx=3) # what about uncompressed?
  385. def pubhex2redeem_script(self,name,f1,f2,f3): # from above
  386. addr = read_from_file(f3).strip()
  387. tu.run_cmd_out(name,addr,fn_idx=3)
  388. rs = read_from_tmpfile(cfg,name+'3.out').strip()
  389. tu.run_cmd_out('pubhex2addr',rs,add_opts=maybe_type_segwit,fn_idx=3,hush=True)
  390. addr1 = read_from_tmpfile(cfg,'pubhex2addr3.out').strip()
  391. addr2 = read_from_tmpfile(cfg,'randpair3.out').split()[1]
  392. cmp_or_die(addr1,addr2)
  393. ok()
  394. def wif2redeem_script(self,name,f1,f2,f3): # compare output with above
  395. wif = read_from_file(f3).split()[0]
  396. ret1 = tu.run_cmd_out(name,wif,add_opts=maybe_type_segwit,fn_idx=3,Return=True)
  397. ret2 = read_from_tmpfile(cfg,'pubhex2redeem_script3.out').strip()
  398. cmp_or_die(ret1,ret2)
  399. ok()
  400. def wif2segwit_pair(self,name,f1,f2): # does its own checking, so just run
  401. wif = read_from_file(f2).split()[0]
  402. tu.run_cmd_out(name,wif,add_opts=maybe_type_segwit,fn_idx=2)
  403. def pubhex2addr(self,name,f1,f2,f3):
  404. addr = read_from_file(f3).strip()
  405. tu.run_cmd_out(name,addr,add_opts=maybe_type_segwit,fn_idx=3)
  406. def pipetest(self,name,f1,f2,f3):
  407. wif = read_from_file(f3).split()[0]
  408. cmd = ( '{c} {a} wif2hex {wif} | ' +
  409. '{c} {a} --type=compressed privhex2pubhex - | ' +
  410. '{c} {a} pubhex2redeem_script - | ' +
  411. '{c} {a} --type=segwit pubhex2addr -').format(
  412. c=' '.join(spawn_cmd),
  413. a=' '.join(add_spawn_args),
  414. wif=wif)
  415. test_msg('command piping')
  416. if opt.verbose:
  417. sys.stderr.write(green('Executing ') + cyan(cmd) + '\n')
  418. p = subprocess.Popen(cmd,stdout=subprocess.PIPE,stderr=subprocess.PIPE,shell=True)
  419. res = p.stdout.read().decode().strip()
  420. addr = read_from_tmpfile(cfg,'wif2addr3.out').strip()
  421. cmp_or_die(res,addr)
  422. ok()
  423. # Mnemonic
  424. def hex2mn(self,name):
  425. for n,size,m in ((1,16,'128-bit'),(2,24,'192-bit'),(3,32,'256-bit')):
  426. hexnum = getrandhex(size)
  427. tu.run_cmd_out(name,hexnum,fn_idx=n,extra_msg=m)
  428. def mn2hex(self,name,f1,f2,f3,f4,f5,f6):
  429. for f_i,f_o,m in ((f1,f2,'128-bit'),(f3,f4,'192-bit'),(f5,f6,'256-bit')):
  430. tu.run_cmd_chk(name,f_i,f_o,extra_msg=m,strip_hex=True)
  431. def mn_rand128(self,name): tu.run_cmd_out(name)
  432. def mn_rand192(self,name): tu.run_cmd_out(name)
  433. def mn_rand256(self,name): tu.run_cmd_out(name)
  434. def mn_stats(self,name): tu.run_cmd_out(name)
  435. def mn_printlist(self,name):
  436. tu.run_cmd(name,[])
  437. ok()
  438. # main()
  439. import time
  440. start_time = int(time.time())
  441. mk_tmpdir(cfg['tmpdir'])
  442. def gen_deps_for_cmd(cmd,cdata):
  443. fns = []
  444. if cdata:
  445. name,code = cdata
  446. io,count = (code[:-1],int(code[-1])) if code[-1] in '0123456789' else (code,1)
  447. for c in range(count):
  448. fns += ['{}{}{}'.format(name,('',c+1)[count > 1],('.out','.in')[ch=='i']) for ch in io]
  449. return fns
  450. def do_cmds(cmd_group):
  451. tc = MMGenToolTestCmds()
  452. gdata = cmd_data[cmd_group]['cmd_data']
  453. for cmd in gdata:
  454. fns = gen_deps_for_cmd(cmd,gdata[cmd])
  455. cmdline = [cmd] + [os.path.join(cfg['tmpdir'],fn) for fn in fns]
  456. getattr(tc,cmd)(*cmdline)
  457. try:
  458. if cmd_args:
  459. if len(cmd_args) != 1:
  460. die(1,'Only one command may be specified')
  461. cmd = cmd_args[0]
  462. if cmd in cmd_data:
  463. msg('Running tests for {}:'.format(cmd_data[cmd]['desc']))
  464. do_cmds(cmd)
  465. elif cmd == 'clean':
  466. cleandir(cfg['tmpdir'],do_msg=True)
  467. sys.exit(0)
  468. else:
  469. die(1,"'{}': unrecognized command".format(cmd))
  470. else:
  471. cleandir(cfg['tmpdir'],do_msg=True)
  472. for cmd in cmd_data:
  473. msg('Running tests for {}:'.format(cmd_data[cmd]['desc']))
  474. do_cmds(cmd)
  475. if cmd is not list(cmd_data.keys())[-1]: msg('')
  476. except KeyboardInterrupt:
  477. die(1,green('\nExiting at user request'))
  478. t = int(time.time()) - start_time
  479. gmsg('All requested tests finished OK, elapsed time: {:02}:{:02}'.format(t//60,t%60))