diff --git a/pa193mnemonicslytherin/mnemoniccli.py b/pa193mnemonicslytherin/mnemoniccli.py
index 4d27521..5774fa6 100644
--- a/pa193mnemonicslytherin/mnemoniccli.py
+++ b/pa193mnemonicslytherin/mnemoniccli.py
@@ -19,6 +19,7 @@ from binascii import unhexlify, hexlify, Error
 from enum import Enum, unique
 from pprint import saferepr
 from typing import Sequence
+from unicodedata import normalize
 
 from pa193mnemonicslytherin import Entropy, Mnemonic, Seed
 from pa193mnemonicslytherin import generate, recover, verify
@@ -79,6 +80,10 @@ class Config(object):
         def write_mode(self):
             return 'wb' if self is Config.Format.BINARY else 'w'
 
+        @property
+        def encoding(self):
+            return 'utf-8' if self is Config.Format.TEXT_HEXADECIMAL else None
+
     PROGRAM_NAME = 'mnemoniccli'
     PROGRAM_DESCRIPTION = 'BIP39 Mnemonic Phrase Generator and Verifier'
     LOGGING_LEVELS_DICT = {'debug': logging.DEBUG,
@@ -122,6 +127,12 @@ class Config(object):
             if len(password) > MAX_SEED_PASSWORD_LENGTH:
                 raise argparse.ArgumentTypeError("password is longer than {} characters".format(
                     MAX_SEED_PASSWORD_LENGTH))
+            try:
+                # to raise UnicodeError for invalid UTF-8
+                password.encode('utf-8')
+                password = normalize('NFKD', password)
+            except UnicodeError as e:
+                raise argparse.ArgumentTypeError("password is not valid UTF-8: {}".format(e)) from e
             return password
         parser = argparse.ArgumentParser(
             prog=cls.PROGRAM_NAME,
@@ -158,7 +169,7 @@ class Config(object):
                             help='select input and output format (default: %(default)s)'
                             )
         parser.add_argument('-p', '--password',
-                            help='password for protection of seed',
+                            help='password for protection of seed (UTF-8)',
                             default='',
                             type=valid_password
                             )
@@ -238,9 +249,8 @@ def cli_entry_point(argv=sys.argv):
 
 
 def action_generate(config: Config) -> ExitCode:
-    # TODO Check file size before reading?
     try:
-        with open(config.entropy_filepath, config.format.read_mode) as file:
+        with open(config.entropy_filepath, config.format.read_mode, encoding=config.format.encoding) as file:
             entropy = file.read()  # type: typing.Union[bytes, str]
     except FileNotFoundError as e:
         logger.critical(str(e))
@@ -263,16 +273,11 @@ def action_generate(config: Config) -> ExitCode:
         logger.critical(str(e))
         print(str(e), file=sys.stderr)
         return ExitCode.EX_DATAERR
-    try:
-        mnemonic, seed = generate(entropy, config.password)
-    except UnicodeError as e:
-        logger.critical(str(e))
-        print(str(e), file=sys.stderr)
-        return ExitCode.EX_DATAERR
-    with open(config.mnemonic_filepath, 'w') as file:
+    mnemonic, seed = generate(entropy, config.password)
+    with open(config.mnemonic_filepath, 'w', encoding='utf-8') as file:
         file.write(mnemonic)
     logger.info('Mnemonic written to {}.'.format(config.mnemonic_filepath))
-    with open(config.seed_filepath, config.format.write_mode) as file:
+    with open(config.seed_filepath, config.format.write_mode, encoding=config.format.encoding) as file:
         if config.format is Config.Format.TEXT_HEXADECIMAL:
             seed = str(hexlify(seed), 'ascii')
         file.write(seed)
@@ -282,7 +287,6 @@ def action_generate(config: Config) -> ExitCode:
 
 
 def action_recover(config: Config) -> ExitCode:
-    # TODO Check file size before reading?
     try:
         with open(config.mnemonic_filepath, 'r', encoding='utf-8') as file:
             mnemonic = file.read()  # type: str
@@ -300,18 +304,13 @@ def action_recover(config: Config) -> ExitCode:
         logger.critical(str(e))
         print(str(e), file=sys.stderr)
         return ExitCode.EX_DATAERR
-    try:
-        entropy, seed = recover(mnemonic, config.password)
-    except UnicodeError as e:
-        logger.critical(str(e))
-        print(str(e), file=sys.stderr)
-        return ExitCode.EX_DATAERR
-    with open(config.entropy_filepath, config.format.write_mode) as file:
+    entropy, seed = recover(mnemonic, config.password)
+    with open(config.entropy_filepath, config.format.write_mode, encoding=config.format.encoding) as file:
         if config.format is Config.Format.TEXT_HEXADECIMAL:
             entropy = str(hexlify(entropy), 'ascii')
         file.write(entropy)
     logger.info('Entropy written to {}.'.format(config.entropy_filepath))
-    with open(config.seed_filepath, config.format.write_mode) as file:
+    with open(config.seed_filepath, config.format.write_mode, encoding=config.format.encoding) as file:
         if config.format is Config.Format.TEXT_HEXADECIMAL:
             seed = str(hexlify(seed), 'ascii')
         file.write(seed)
@@ -321,7 +320,6 @@ def action_recover(config: Config) -> ExitCode:
 
 
 def action_verify(config: Config) -> ExitCode:
-    # TODO Check file size before reading?
     try:
         with open(config.mnemonic_filepath, 'r', encoding='utf-8') as file:
             mnemonic = file.read()  # type: str
@@ -339,9 +337,8 @@ def action_verify(config: Config) -> ExitCode:
         logger.critical(str(e))
         print(str(e), file=sys.stderr)
         return ExitCode.EX_DATAERR
-    # TODO Check file size before reading?
     try:
-        with open(config.seed_filepath, config.format.read_mode) as file:
+        with open(config.seed_filepath, config.format.read_mode, encoding=config.format.encoding) as file:
             seed = file.read()  # type: typing.Union[bytes, str]
     except FileNotFoundError as e:
         logger.critical(str(e))
@@ -364,12 +361,7 @@ def action_verify(config: Config) -> ExitCode:
         logger.critical(str(e))
         print(str(e), file=sys.stderr)
         return ExitCode.EX_DATAERR
-    try:
-        match = verify(mnemonic, seed, config.password)
-    except UnicodeError as e:
-        logger.critical(str(e))
-        print(str(e), file=sys.stderr)
-        return ExitCode.EX_DATAERR
+    match = verify(mnemonic, seed, config.password)
     if not match:
         msg = 'Seeds do not match.'
         logger.info(msg)
@@ -382,7 +374,6 @@ def action_verify(config: Config) -> ExitCode:
 
 
 def main(argv) -> ExitCode:
-    # TODO check for errors related to file IO
     logging.captureWarnings(True)
     warnings.simplefilter('always', ResourceWarning)
 
@@ -397,7 +388,7 @@ def main(argv) -> ExitCode:
         logging.disable(logging.CRITICAL)
     logger.debug('Config parsed from args.')
 
-    # region # TODO What types of errors/exceptions can happen here?
+    # region #
     exitcode = ExitCode.EX_OK
     if config.generate:
         exitcode = action_generate(config)

Report invalid UTF-8 sequence in input mnemonic as `EX_DATAERR = 65`
~~~
'utf-8' codec can't decode byte 0xca in position 151: invalid continuation byte
'utf-8' codec can't decode byte 0xa5 in   position 85: invalid start byte
'utf-8' codec can't decode byte 0x96 in   position 89: invalid start byte
'utf-8' codec can't decode byte 0xc2 in   position 39: invalid continuation byte
'utf-8' codec can't decode byte 0xdb in   position 111: invalid continuation byte
'utf-8' codec can't decode byte 0xc6 in   position 352: invalid continuation byte
'utf-8' codec can't decode byte 0xf3 in   position 56: invalid continuation byte
'utf-8' codec can't decode byte 0xc0 in   position 58: invalid start byte
'utf-8' codec can't decode byte 0xd0 in   position 56: invalid continuation byte
'utf-8' codec can't decode byte 0x84 in   position 123: invalid start byte
'utf-8' codec can't decode byte 0xb5 in   position 140: invalid start byte
'utf-8' codec can't decode byte 0xfe in   position 138: invalid start byte
'utf-8' codec can't decode byte 0x88 in   position 237: invalid start byte
'utf-8' codec can't decode byte 0xc0 in   position 175: invalid start byte
'utf-8' codec can't decode byte 0xfb in   position 132: invalid start byte
'utf-8' codec can't decode byte 0xed in   position 71: invalid continuation byte
'utf-8' codec can't decode byte 0xf7 in   position 53: invalid start byte
'utf-8' codec can't decode byte 0xfe in   position 197: invalid start byte
'utf-8' codec can't decode bytes in   position 2-4: invalid continuation byte
'utf-8' codec can't decode byte 0xbe in   position 66: invalid start byte
'utf-8' codec can't decode byte 0xe4 in   position 7: invalid continuation byte
~~~
Is currently reported as `UNKNOWN_FAILURE = 1`. Would be better to report it as `EX_DATAERR = 65` from `mnemoniccli.ExitCode.EX_DATAERR`.

Already mentioned in https://github.com/mvondracek/PA193_mnemonic_Slytherin/issues/12#issuecomment-543391802.

Errors with UTF-8 apply to dictionary, too. (https://github.com/mvondracek/PA193_mnemonic_Slytherin/pull/21#discussion_r336257567)
diff --git a/pa193mnemonicslytherin/test_mnemonic.py b/pa193mnemonicslytherin/test_mnemonic.py
index b48ff70..bfbe8e8 100644
--- a/pa193mnemonicslytherin/test_mnemonic.py
+++ b/pa193mnemonicslytherin/test_mnemonic.py
@@ -182,6 +182,8 @@ VALID_SEED_TREZOR = Seed(unhexlify(TREZOR_TEST_VECTORS['english'][0][2]))
 VALID_SEED_HEX_TREZOR = TREZOR_TEST_VECTORS['english'][0][2]
 VALID_PASSWORD_TREZOR = TREZOR_PASSWORD
 
+INVALID_MNEMONIC_PHRASE_INVALID_UTF8 = "mn3\n\udcd6 " * 12
+INVALID_PASSWORD_INVALID_UTF8 = "icpa\u202e\U000e0ec1\udcaassword1"
 
 def extract_checksum(mnemonic_phrase: str, dictionary_name: str = ENGLISH_DICTIONARY_NAME) -> int:
     """Extract checksum based on words from the mnemonic phrase and given dictionary.
@@ -300,11 +302,9 @@ class TestInternalTestHelpers(TestCase):
                                             r'current dictionary'):
                     extract_checksum(test_input)
 
-    def test_extract_checksum_non_utf8_mnemonic(self):
-        words = ["mn3\n\udcd6"] * 12
-        mnemonic_non_utf8 = ' '.join(words)
+    def test_extract_checksum_invalid_mnemonic_invalid_utf8(self):
         with self.assertRaises(UnicodeError):
-            extract_checksum(mnemonic_non_utf8)
+            extract_checksum(INVALID_MNEMONIC_PHRASE_INVALID_UTF8)
 
     def test_extract_checksum_invalid_dictionary_name(self):
         for test_input in Test_DictionaryAccess.INVALID_DICTIONARY_NAMES:
@@ -341,7 +341,6 @@ class TestPublicFunctions(TestCase):
     """Tests for public functions of mnemonic module.
     Tests for `generate`, `recover`, and `verify` are similar, but we want to
     test each function separately.
-    TODO add testing for incorrect inputs
     """
     TESTING_TYPES = [
         None,
@@ -373,10 +372,9 @@ class TestPublicFunctions(TestCase):
         with self.assertRaises(ValueError):
             generate(VALID_ENTROPY_TREZOR, password)
 
-    def test_generate_invalid_encoding(self):
-        password_non_utf8 = "icpa\u202e\U000e0ec1\udcaassword1"
+    def test_generate_invalid_password_invalid_utf8(self):
         with self.assertRaises(UnicodeError):
-            generate(VALID_ENTROPY_TREZOR, password_non_utf8)
+            generate(VALID_ENTROPY_TREZOR, INVALID_PASSWORD_INVALID_UTF8)
 
     def test_recover(self):
         for test_vector in TREZOR_TEST_VECTORS['english']:
@@ -399,10 +397,9 @@ class TestPublicFunctions(TestCase):
         with self.assertRaises(ValueError):
             recover(VALID_MNEMONIC_TREZOR, password)
 
-    def test_recover_invalid_encoding(self):
-        password_non_utf8 = "icpa\u202e\U000e0ec1\udcaassword1"
+    def test_recover_invalid_password_invalid_utf8(self):
         with self.assertRaises(UnicodeError):
-            recover(VALID_MNEMONIC_TREZOR, password_non_utf8)
+            recover(VALID_MNEMONIC_TREZOR, INVALID_PASSWORD_INVALID_UTF8)
 
     def test_verify(self):
         for test_vector in TREZOR_TEST_VECTORS['english']:
@@ -427,13 +424,11 @@ class TestPublicFunctions(TestCase):
         with self.assertRaises(ValueError):
             verify(VALID_MNEMONIC_TREZOR, VALID_SEED_TREZOR, password)
 
-    def test_verify_invalid_encoding(self):
-        non_utf8 = "icpa\u202e\U000e0ec1\udcaassword1"
+    def test_verify_invalid_password_invalid_utf8(self):
         with self.assertRaises(UnicodeError):
-            verify(VALID_MNEMONIC_TREZOR, VALID_SEED_TREZOR, non_utf8)
+            verify(VALID_MNEMONIC_TREZOR, VALID_SEED_TREZOR, INVALID_PASSWORD_INVALID_UTF8)
 
 
-# TODO add more tests (different from Trezor vector)
 class TestMnemonic(TestCase):
     """Tests Mnemonic"""
 
@@ -492,12 +487,10 @@ class TestMnemonic(TestCase):
         with self.assertRaises(ValueError):
             Mnemonic('a' * 1024 * 1024)  # 1 MB
 
-    def test___init___invalid_encoding(self):
+    def test___init___invalid_utf8(self):
         """Input string isn't UTF-8 encoded."""
-        words = ["mn3\n\udcd6"] * 12
-        mnemonic_non_utf8 = ' '.join(words)
         with self.assertRaises(UnicodeError):
-            Mnemonic(mnemonic_non_utf8)
+            Mnemonic(INVALID_MNEMONIC_PHRASE_INVALID_UTF8)
 
     def test_to_seed(self):
         for test_vector in TREZOR_TEST_VECTORS['english']:
@@ -518,10 +511,9 @@ class TestMnemonic(TestCase):
         with self.assertRaises(ValueError):
             VALID_MNEMONIC_TREZOR.to_seed(password)
 
-    def test_to_seed_password_invalid_encoding(self):
-        password_non_utf8 = "icpa\u202e\U000e0ec1\udcaassword1"
+    def test_to_seed_invalid_password_invalid_utf8(self):
         with self.assertRaises(UnicodeError):
-            VALID_MNEMONIC_TREZOR.to_seed(password_non_utf8)
+            VALID_MNEMONIC_TREZOR.to_seed(INVALID_PASSWORD_INVALID_UTF8)
 
     def test_to_entropy(self):
         for test_vector in TREZOR_TEST_VECTORS['english']:
@@ -696,4 +688,4 @@ class Test_DictionaryAccess(TestCase):
             b'\xff\xff\xff\n' * self.VALID_DICTIONARY_LINE_COUNT)
         with patch.object(pkg_resources, 'resource_stream', return_value=dictionary_mock):
             with self.assertRaises(UnicodeError):
-                _DictionaryAccess()
\ No newline at end of file
+                _DictionaryAccess()
diff --git a/pa193mnemonicslytherin/test_mnemoniccli.py b/pa193mnemonicslytherin/test_mnemoniccli.py
index 1dd8432..68fa81b 100644
--- a/pa193mnemonicslytherin/test_mnemoniccli.py
+++ b/pa193mnemonicslytherin/test_mnemoniccli.py
@@ -21,7 +21,7 @@ from typing import Optional, List, Tuple, Union
 from pa193mnemonicslytherin.mnemonic import MAX_SEED_PASSWORD_LENGTH, SEED_LEN
 from pa193mnemonicslytherin.mnemoniccli import ExitCode, cli_entry_point, Config
 from pa193mnemonicslytherin.test_mnemonic import TREZOR_TEST_VECTORS, TREZOR_PASSWORD, \
-    VALID_SEED_HEX_TREZOR, VALID_MNEMONIC_PHRASE_TREZOR
+    VALID_SEED_HEX_TREZOR, VALID_MNEMONIC_PHRASE_TREZOR, INVALID_PASSWORD_INVALID_UTF8
 
 
 def get_invalid_entropies() -> List[Tuple[Union[str, bytes], Config.Format, Optional[str]]]:
@@ -45,16 +45,17 @@ def get_invalid_entropies() -> List[Tuple[Union[str, bytes], Config.Format, Opti
             invalid_entropies.append((str(hexlify(entropy_byte * entropy_bytes_length), 'ascii'),
                                       Config.Format.TEXT_HEXADECIMAL, None))
     # endregion
-    # TODO invalid characters in hex string
+
     # Cases: non-Unicode, non-ascii, non-hex, odd-length
     # odd-length should be covered by the previous region?
     # for non-UTF-8 be a separate test function
     entropy_non_ascii = "1122334455667ЫЫ899ЩЩBBCCDDEEFF00"
     entropy_non_hex = "Z" * 16
-    invalid_entropies.extend([(entropy_non_ascii,
-                              Config.Format.TEXT_HEXADECIMAL, None),
-                              (entropy_non_hex,
-                              Config.Format.TEXT_HEXADECIMAL, None)])
+    entropy_odd_length = "aaF"
+    invalid_entropies.extend([(entropy_non_ascii, Config.Format.TEXT_HEXADECIMAL, None),
+                              (entropy_non_hex, Config.Format.TEXT_HEXADECIMAL, None),
+                              (entropy_odd_length, Config.Format.TEXT_HEXADECIMAL, None),
+                              ])
     return invalid_entropies
 
 
@@ -64,18 +65,15 @@ def get_invalid_mnemonics() -> List[Tuple[str, Optional[str]]]:
              and second is optional error message to be checked on
              program's stderr.
     """
-    invalid_mnemonics = [('this is invalid mnemonic', None)]  # TODO gather invalid mnemonics from tests
-    # TODO invalid UTF-8 sequences
+    invalid_mnemonics = [('this is invalid mnemonic', None)]
     return invalid_mnemonics
 
 
-def get_non_unicode_mnemonics() -> List[Tuple[bytes, Optional[str]]]:
+def get_invalid_mnemonics_invalid_utf8() -> List[Tuple[bytes, Optional[str]]]:
     """
     :return: non-Unicode mnemonics as byte string, which should be written to file in a binary mode
     """
-    words = [b"\xff\xff\xff\xff"] * 12
-    mnemonic = b'\x20'.join(words)
-    non_unicode_mnemonics = [(mnemonic, None)]
+    non_unicode_mnemonics = [(b"\xff\xff\xff\xff " * 12, None)]
     return non_unicode_mnemonics
 
 
@@ -94,29 +92,17 @@ def get_invalid_seeds() -> List[Tuple[Union[str, bytes], Config.Format, Optional
             invalid_seeds.append((str(hexlify(seed_byte * seed_bytes_length), 'ascii'),
                                   Config.Format.TEXT_HEXADECIMAL, None))
     # endregion
-    # TODO invalid characters in hex string
-    # Cases: non-Unicode, non-ASCII, non-hex
-    # non-Unicode test be in a separate function
+    # Cases: non-ASCII, non-hex
     seed_non_ascii = "Ы" * SEED_LEN
     seed_non_hex = "Z" * SEED_LEN
+    seed_odd_length = "aaF"
     invalid_seeds.extend([(seed_non_ascii, Config.Format.TEXT_HEXADECIMAL, None),
-                          (seed_non_hex, Config.Format.TEXT_HEXADECIMAL, None)])
+                          (seed_non_hex, Config.Format.TEXT_HEXADECIMAL, None),
+                          (seed_odd_length, Config.Format.TEXT_HEXADECIMAL, None),
+                          ])
     return invalid_seeds
 
 
-def get_invalid_passwords() -> List[Tuple[str, Optional[str]]]:
-    """
-    :return: List of invalid examples as tuples, where first is invalid input,
-             and second is optional error message to be checked on
-             program's stderr.
-    """
-    psw_non_utf8 = "icpa\u202e\U000e0ec1\udcaassword1"
-    invalid_passwords = [(psw_non_utf8, None)]
-    # Cases: invalid UTF-8 sequences, too long passwords
-    # TODO: long passwords raise argparse.ArgumentTypeError, need separate test
-    return invalid_passwords
-
-
 class TestMain(unittest.TestCase):
     """Integration tests for CLI tool."""
     TIMEOUT = 10  # seconds until we terminate the program
@@ -137,14 +123,14 @@ class TestMain(unittest.TestCase):
         :param stderr_check: String with which `stderr` should be compared, `None` if `stderr` should not be empty.
         """
         cli = self.execute_cli(args)
-        if stdout_check is not None:
-            self.assertEqual(stdout_check, cli.stdout)
-        else:
-            self.assertNotEqual('', cli.stdout)
         if stderr_check is not None:
             self.assertEqual(stderr_check, cli.stderr)
         else:
             self.assertNotEqual('', cli.stderr)
+        if stdout_check is not None:
+            self.assertEqual(stdout_check, cli.stdout)
+        else:
+            self.assertNotEqual('', cli.stdout)
         self.assertEqual(exitcode.value, cli.returncode)
 
     def assert_program_entry_point(self, args: List[str], exitcode: ExitCode,
@@ -202,6 +188,7 @@ class TestMain(unittest.TestCase):
         self.assert_program_error([self.SCRIPT, '-s'], ExitCode.ARGUMENTS)
         self.assert_program_error([self.SCRIPT, '-p'], ExitCode.ARGUMENTS)
         self.assert_program_error([self.SCRIPT, '-p', 'a' * (MAX_SEED_PASSWORD_LENGTH + 1)], ExitCode.ARGUMENTS)
+        self.assert_program_error([self.SCRIPT, '-p', INVALID_PASSWORD_INVALID_UTF8], ExitCode.ARGUMENTS)
         self.assert_program_error([self.SCRIPT, '-v', '-m'], ExitCode.ARGUMENTS)
         self.assert_program_error([self.SCRIPT, '-v', '-s'], ExitCode.ARGUMENTS)
         self.assert_program_error([self.SCRIPT, '-g', '-r', '-v'], ExitCode.ARGUMENTS)
@@ -253,7 +240,7 @@ class TestMain(unittest.TestCase):
                 [self.SCRIPT, '-v', '-m', non_existing_filepath, '-s', non_existing_filepath],
                 ExitCode.EX_NOINPUT)
 
-            with open(os.path.join(tmpdir, '__this_file_exists__.txt'), 'w') as f:
+            with open(os.path.join(tmpdir, '__this_file_exists__.txt'), 'w', encoding='utf-8') as f:
                 f.write('foo bar')
             self.assert_program_error([self.SCRIPT, '-v', '-m', non_existing_filepath, '-s', f.name],
                                       ExitCode.EX_NOINPUT)
@@ -266,7 +253,7 @@ class TestMain(unittest.TestCase):
                         seed_path = os.path.join(tmpdir, '__seed__')
                         mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
                         entropy_path = os.path.join(tmpdir, '__entropy__')
-                        with open(entropy_path, io_format.write_mode) as entropy_file:
+                        with open(entropy_path, io_format.write_mode, encoding=io_format.encoding) as entropy_file:
                             entropy_file.write(
                                 unhexlify(test_vector[0]) if io_format is Config.Format.BINARY else test_vector[0])
                         self.assert_program([self.SCRIPT, '-g', '--format', io_format.value, '-p', TREZOR_PASSWORD,
@@ -276,12 +263,12 @@ class TestMain(unittest.TestCase):
                                             stdout_check='[DONE] Generate, mnemonic in {}, seed in {}.\n'.format(
                                                 mnemonic_path, seed_path),
                                             stderr_check='')
-                        with open(seed_path, io_format.read_mode) as seed_file:
+                        with open(seed_path, io_format.read_mode, encoding=io_format.encoding) as seed_file:
                             content = seed_file.read()
                             if io_format is Config.Format.BINARY:
                                 seed = str(hexlify(content), 'ascii')
                             self.assertEqual(test_vector[2], seed)
-                        with open(mnemonic_path, 'r') as mnemonic_file:
+                        with open(mnemonic_path, 'r', encoding='utf-8') as mnemonic_file:
                             self.assertEqual(test_vector[1], mnemonic_file.read())
 
     def test_generate_invalid_entropy(self):
@@ -291,7 +278,7 @@ class TestMain(unittest.TestCase):
                     seed_path = os.path.join(tmpdir, '__seed__')
                     mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
                     entropy_path = os.path.join(tmpdir, '__entropy__')
-                    with open(entropy_path, io_format.write_mode) as entropy_file:
+                    with open(entropy_path, io_format.write_mode, encoding=io_format.encoding) as entropy_file:
                         entropy_file.write(entropy)
                     self.assert_program([self.SCRIPT, '-g', '--format', io_format.value,
                                          '-e', entropy_path,
@@ -300,11 +287,8 @@ class TestMain(unittest.TestCase):
                                         stdout_check='',
                                         stderr_check=stderr)
 
-    @unittest.skip("cannot generate non-UTF-8 entropy file")
-    def test_generate_non_unicode_entropy(self):
+    def test_generate_invalid_entropy_invalid_utf8(self):
         entropy = b'\x86' * 16
-        # currently not working: exception occurs after hexlify
-        # it should occur just after reading attempt
         with TemporaryDirectory() as tmpdir:
             seed_path = os.path.join(tmpdir, '__seed__')
             mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
@@ -320,26 +304,6 @@ class TestMain(unittest.TestCase):
                                 stdout_check='',
                                 stderr_check=None)
 
-    def test_generate_invalid_password(self):
-        entropy = TREZOR_TEST_VECTORS['english'][0][0]
-        with TemporaryDirectory() as tmpdir:
-            for password, stderr in get_invalid_passwords():
-                with self.subTest(password=password):
-                    seed_path = os.path.join(tmpdir, '__seed__')
-                    mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
-                    entropy_path = os.path.join(tmpdir, '__entropy__')
-                    with open(entropy_path, 'w') as entropy_file:
-                        entropy_file.write(entropy)
-                    self.assert_program([self.SCRIPT, '-g',
-                                         '-e', entropy_path,
-                                         '-m', mnemonic_path,
-                                         '-s', seed_path,
-                                         '--format', Config.Format.TEXT_HEXADECIMAL.value,
-                                         '-p', password],
-                                        ExitCode.EX_DATAERR,
-                                        stdout_check='',
-                                        stderr_check=stderr)
-
     def test_recover(self):
         with TemporaryDirectory() as tmpdir:
             for test_vector in TREZOR_TEST_VECTORS['english']:
@@ -348,7 +312,7 @@ class TestMain(unittest.TestCase):
                         seed_path = os.path.join(tmpdir, '__seed__')
                         mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
                         entropy_path = os.path.join(tmpdir, '__entropy__')
-                        with open(mnemonic_path, 'w') as mnemonic_file:
+                        with open(mnemonic_path, 'w', encoding='utf-8') as mnemonic_file:
                             mnemonic_file.write(test_vector[1])
                         self.assert_program([self.SCRIPT, '-r', '--format', io_format.value, '-p', TREZOR_PASSWORD,
                                              '-e', entropy_path,
@@ -357,12 +321,12 @@ class TestMain(unittest.TestCase):
                                             stdout_check='[DONE] Recover, entropy in {}, seed in {}.\n'.format(
                                                 entropy_path, seed_path),
                                             stderr_check='')
-                        with open(seed_path, io_format.read_mode) as seed_file:
+                        with open(seed_path, io_format.read_mode, encoding=io_format.encoding) as seed_file:
                             content = seed_file.read()
                             if io_format is Config.Format.BINARY:
                                 seed = str(hexlify(content), 'ascii')
                             self.assertEqual(test_vector[2], seed)
-                        with open(entropy_path, io_format.read_mode) as entropy_file:
+                        with open(entropy_path, io_format.read_mode, encoding=io_format.encoding) as entropy_file:
                             content = entropy_file.read()
                             if io_format is Config.Format.BINARY:
                                 entropy = str(hexlify(content), 'ascii')
@@ -375,7 +339,7 @@ class TestMain(unittest.TestCase):
                     seed_path = os.path.join(tmpdir, '__seed__')
                     mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
                     entropy_path = os.path.join(tmpdir, '__entropy__')
-                    with open(mnemonic_path, 'w') as mnemonic_file:
+                    with open(mnemonic_path, 'w', encoding='utf-8') as mnemonic_file:
                         mnemonic_file.write(mnemonic)
                     self.assert_program([self.SCRIPT, '-r',
                                          '-e', entropy_path,
@@ -384,16 +348,16 @@ class TestMain(unittest.TestCase):
                                         stdout_check='',
                                         stderr_check=stderr)
 
-    def test_recover_non_unicode_mnemonic(self):
+    def test_recover_invalid_mnemonic_invalid_utf8(self):
         with TemporaryDirectory() as tmpdir:
-            for mnemonic, stderr in get_non_unicode_mnemonics():
+            for mnemonic, stderr in get_invalid_mnemonics_invalid_utf8():
                 with self.subTest(mnemonic=mnemonic):
                     seed_path = os.path.join(tmpdir, '__seed__')
                     mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
                     entropy_path = os.path.join(tmpdir, '__entropy__')
                     with open(mnemonic_path, 'wb') as mnemonic_file:
                         mnemonic_file.write(mnemonic)
-                    self.assert_program([self.SCRIPT, '-r',
+                    self.assert_program([self.SCRIPT, '-r', '--format', Config.Format.TEXT_HEXADECIMAL.value,
                                          '-e', entropy_path,
                                          '-m', mnemonic_path,
                                          '-s', seed_path],
@@ -401,25 +365,6 @@ class TestMain(unittest.TestCase):
                                         stdout_check='',
                                         stderr_check=stderr)
 
-    def test_recover_non_unicode_password(self):
-        mnemonic = TREZOR_TEST_VECTORS['english'][0][1]
-        with TemporaryDirectory() as tmpdir:
-            for password, stderr in get_invalid_passwords():
-                with self.subTest(password=password):
-                    seed_path = os.path.join(tmpdir, '__seed__')
-                    mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
-                    entropy_path = os.path.join(tmpdir, '__entropy__')
-                    with open(mnemonic_path, 'w') as mnemonic_file:
-                        mnemonic_file.write(mnemonic)
-                    self.assert_program([self.SCRIPT, '-r',
-                                         '-e', entropy_path,
-                                         '-m', mnemonic_path,
-                                         '-s', seed_path,
-                                         '-p', password],
-                                        ExitCode.EX_DATAERR,
-                                        stdout_check='',
-                                        stderr_check=stderr)
-
     def test_verify(self):
         with TemporaryDirectory() as tmpdir:
             for test_vector in TREZOR_TEST_VECTORS['english']:
@@ -427,9 +372,9 @@ class TestMain(unittest.TestCase):
                     with self.subTest(mnemonic=test_vector[1], seed=test_vector[2]):
                         seed_path = os.path.join(tmpdir, '__seed__')
                         mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
-                        with open(mnemonic_path, 'w') as mnemonic_file:
+                        with open(mnemonic_path, 'w', encoding='utf-8') as mnemonic_file:
                             mnemonic_file.write(test_vector[1])
-                        with open(seed_path, io_format.write_mode) as seed_file:
+                        with open(seed_path, io_format.write_mode, encoding=io_format.encoding) as seed_file:
                             seed_file.write(
                                 unhexlify(test_vector[2]) if io_format is Config.Format.BINARY else test_vector[2])
                         self.assert_program([self.SCRIPT, '-v', '--format', io_format.value, '-p', TREZOR_PASSWORD,
@@ -450,9 +395,9 @@ class TestMain(unittest.TestCase):
                 with self.subTest(mnemonic=mnemonic, seed=seed, io_format=io_format):
                     seed_path = os.path.join(tmpdir, '__seed__')
                     mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
-                    with open(mnemonic_path, 'w') as mnemonic_file:
+                    with open(mnemonic_path, 'w', encoding='utf-8') as mnemonic_file:
                         mnemonic_file.write(mnemonic)
-                    with open(seed_path, io_format.write_mode) as seed_file:
+                    with open(seed_path, io_format.write_mode, encoding=io_format.encoding) as seed_file:
                         seed_file.write(seed)
                     self.assert_program([self.SCRIPT, '-v', '--format', io_format.value,
                                          '-m', mnemonic_path,
@@ -471,9 +416,9 @@ class TestMain(unittest.TestCase):
                     with self.subTest(mnemonic=mnemonic, seed=seed, io_format=io_format):
                         seed_path = os.path.join(tmpdir, '__seed__')
                         mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
-                        with open(mnemonic_path, 'w') as mnemonic_file:
+                        with open(mnemonic_path, 'w', encoding='utf-8') as mnemonic_file:
                             mnemonic_file.write(mnemonic)
-                        with open(seed_path, io_format.write_mode) as seed_file:
+                        with open(seed_path, io_format.write_mode, encoding=io_format.encoding) as seed_file:
                             seed_file.write(seed)
                         self.assert_program([self.SCRIPT, '-v', '--format', io_format.value,
                                              '-m', mnemonic_path,
@@ -481,20 +426,20 @@ class TestMain(unittest.TestCase):
                                             stdout_check='',
                                             stderr_check=stderr)
 
-    def test_verify_non_unicode_mnemonic(self):
+    def test_verify_invalid_mnemonic_invalid_utf8(self):
         valid_seeds = [
             (unhexlify(VALID_SEED_HEX_TREZOR), Config.Format.BINARY),
             (VALID_SEED_HEX_TREZOR, Config.Format.TEXT_HEXADECIMAL),
         ]
         with TemporaryDirectory() as tmpdir:
             for seed, io_format in valid_seeds:
-                for mnemonic, stderr in get_non_unicode_mnemonics():
+                for mnemonic, stderr in get_invalid_mnemonics_invalid_utf8():
                     with self.subTest(mnemonic=mnemonic, seed=seed, io_format=io_format):
                         seed_path = os.path.join(tmpdir, '__seed__')
                         mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
                         with open(mnemonic_path, 'wb') as mnemonic_file:
                             mnemonic_file.write(mnemonic)
-                        with open(seed_path, io_format.write_mode) as seed_file:
+                        with open(seed_path, io_format.write_mode, encoding=io_format.encoding) as seed_file:
                             seed_file.write(seed)
                         self.assert_program([self.SCRIPT, '-v', '--format', io_format.value,
                                              '-m', mnemonic_path,
@@ -508,9 +453,9 @@ class TestMain(unittest.TestCase):
                 with self.subTest(mnemonic=VALID_MNEMONIC_PHRASE_TREZOR, seed=seed, io_format=io_format):
                     seed_path = os.path.join(tmpdir, '__seed__')
                     mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
-                    with open(mnemonic_path, 'w') as mnemonic_file:
+                    with open(mnemonic_path, 'w', encoding='utf-8') as mnemonic_file:
                         mnemonic_file.write(VALID_MNEMONIC_PHRASE_TREZOR)
-                    with open(seed_path, io_format.write_mode) as seed_file:
+                    with open(seed_path, io_format.write_mode, encoding=io_format.encoding) as seed_file:
                         seed_file.write(seed)
                     self.assert_program([self.SCRIPT, '-v', '--format', io_format.value,
                                          '-m', mnemonic_path,
@@ -518,15 +463,12 @@ class TestMain(unittest.TestCase):
                                         stdout_check='',
                                         stderr_check=stderr)
 
-    @unittest.skip("cannot generate non-UTF-8 seed file")
-    def test_verify_non_unicode_seed(self):
-        # currently not working: exception occurs after hexlify
-        # it should occur just after reading attempt
+    def test_verify_invalid_seed_invalid_utf8(self):
         seed = b'\xff' * SEED_LEN
         with TemporaryDirectory() as tmpdir:
             seed_path = os.path.join(tmpdir, '__seed__')
             mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
-            with open(mnemonic_path, 'w') as mnemonic_file:
+            with open(mnemonic_path, 'w', encoding='utf-8') as mnemonic_file:
                 mnemonic_file.write(VALID_MNEMONIC_PHRASE_TREZOR)
             with open(seed_path, 'wb') as seed_file:
                 seed_file.write(seed)
@@ -537,34 +479,12 @@ class TestMain(unittest.TestCase):
                                 stdout_check='',
                                 stderr_check=None)
 
-    def test_verify_non_unicode_password(self):
-        valid_seeds = [
-            (unhexlify(VALID_SEED_HEX_TREZOR), Config.Format.BINARY),
-            (VALID_SEED_HEX_TREZOR, Config.Format.TEXT_HEXADECIMAL),
-        ]
-        with TemporaryDirectory() as tmpdir:
-            for seed, io_format in valid_seeds:
-                for password, stderr in get_invalid_passwords():
-                    with self.subTest(seed=seed, io_format=io_format, password=password):
-                        seed_path = os.path.join(tmpdir, '__seed__')
-                        mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
-                        with open(mnemonic_path, 'w') as mnemonic_file:
-                            mnemonic_file.write(VALID_MNEMONIC_PHRASE_TREZOR)
-                        with open(seed_path, io_format.write_mode) as seed_file:
-                            seed_file.write(seed)
-                        self.assert_program([self.SCRIPT, '-v', '--format', io_format.value,
-                                             '-m', mnemonic_path,
-                                             '-s', seed_path,
-                                             '-p', password], ExitCode.EX_DATAERR,
-                                            stdout_check='',
-                                            stderr_check=stderr)
-
     def test_verify_missing_seed_file(self):
         with TemporaryDirectory() as tmpdir:
             non_existing_filepath = os.path.join(tmpdir, '__this_file_does_not_exist__')
             for io_format in Config.Format:
                 mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
-                with open(mnemonic_path, 'w') as mnemonic_file:
+                with open(mnemonic_path, 'w', encoding='utf-8') as mnemonic_file:
                     mnemonic_file.write(VALID_MNEMONIC_PHRASE_TREZOR)
                 self.assert_program([self.SCRIPT, '-v', '--format', io_format.value,
                                      '-m', mnemonic_path,
@@ -581,7 +501,7 @@ class TestMain(unittest.TestCase):
             for seed, io_format in valid_seeds:
                 seed_path = os.path.join(tmpdir, '__seed__')
                 mnemonic_path = os.path.join(tmpdir, '__mnemonic__')
-                with open(seed_path, io_format.write_mode) as seed_file:
+                with open(seed_path, io_format.write_mode, encoding=io_format.encoding) as seed_file:
                     seed_file.write(seed)
                 self.assert_program([self.SCRIPT, '-v', '--format', io_format.value,
                                      '-m', mnemonic_path,

pip install -e .
parse_log_pytest
pytest
pytest pytest-cov
apt-get update apt-get install -y gcc
3.7
pytest --no-header -rA --tb=line --color=no -p no:cacheprovider -W ignore::DeprecationWarning
attrs @ file:///croot/attrs_1668696182826/work
certifi @ file:///croot/certifi_1671487769961/work/certifi
coverage==7.2.7
flit_core @ file:///opt/conda/conda-bld/flit-core_1644941570762/work/source/flit_core
importlib-metadata @ file:///tmp/build/80754af9/importlib-metadata_1648562407465/work
iniconfig @ file:///home/linux1/recipes/ci/iniconfig_1610983019677/work
-e git+https://github.com/mvondracek/PA193_mnemonic_Slytherin.git@a23ee44909ca5f930478e0d7ead02b4bae6a0715#egg=pa193mnemonicslytherin
packaging @ file:///croot/packaging_1671697413597/work
pluggy @ file:///tmp/build/80754af9/pluggy_1648042572264/work
py @ file:///opt/conda/conda-bld/py_1644396412707/work
pytest==7.1.2
pytest-cov==4.1.0
tomli @ file:///opt/conda/conda-bld/tomli_1657175507142/work
typing_extensions @ file:///croot/typing_extensions_1669924550328/work
zipp @ file:///croot/zipp_1672387121353/work

name: PA193_mnemonic_Slytherin
channels:
  - defaults
  - https://repo.anaconda.com/pkgs/main
  - https://repo.anaconda.com/pkgs/r
  - conda-forge
dependencies:
  - _libgcc_mutex=0.1=main
  - _openmp_mutex=5.1=1_gnu
  - attrs=22.1.0=py37h06a4308_0
  - ca-certificates=2025.2.25=h06a4308_0
  - certifi=2022.12.7=py37h06a4308_0
  - flit-core=3.6.0=pyhd3eb1b0_0
  - importlib-metadata=4.11.3=py37h06a4308_0
  - importlib_metadata=4.11.3=hd3eb1b0_0
  - iniconfig=1.1.1=pyhd3eb1b0_0
  - ld_impl_linux-64=2.40=h12ee557_0
  - libffi=3.4.4=h6a678d5_1
  - libgcc-ng=11.2.0=h1234567_1
  - libgomp=11.2.0=h1234567_1
  - libstdcxx-ng=11.2.0=h1234567_1
  - ncurses=6.4=h6a678d5_0
  - openssl=1.1.1w=h7f8727e_0
  - packaging=22.0=py37h06a4308_0
  - pip=22.3.1=py37h06a4308_0
  - pluggy=1.0.0=py37h06a4308_1
  - py=1.11.0=pyhd3eb1b0_0
  - pytest=7.1.2=py37h06a4308_0
  - python=3.7.16=h7a1cb2a_0
  - readline=8.2=h5eee18b_0
  - setuptools=65.6.3=py37h06a4308_0
  - sqlite=3.45.3=h5eee18b_0
  - tk=8.6.14=h39e8969_0
  - tomli=2.0.1=py37h06a4308_0
  - typing_extensions=4.4.0=py37h06a4308_0
  - wheel=0.38.4=py37h06a4308_0
  - xz=5.6.4=h5eee18b_1
  - zipp=3.11.0=py37h06a4308_0
  - zlib=1.2.13=h5eee18b_1
  - pip:
      - coverage==7.2.7
      - pytest-cov==4.1.0
prefix: /opt/conda/envs/PA193_mnemonic_Slytherin

pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_generate pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_generate_invalid_entropy pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_recover pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_verify pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_verify_invalid_mnemonic pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_verify_invalid_mnemonic_invalid_utf8 pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_verify_invalid_seed pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_verify_missing_mnemonic_file pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_verify_seeds_do_not_match
pa193mnemonicslytherin/test_mnemonic.py::TestInternalTestHelpers::test_extract_checksum pa193mnemonicslytherin/test_mnemonic.py::TestInternalTestHelpers::test_extract_checksum_invalid_dictionary_lines pa193mnemonicslytherin/test_mnemonic.py::TestInternalTestHelpers::test_extract_checksum_invalid_dictionary_long_word pa193mnemonicslytherin/test_mnemonic.py::TestInternalTestHelpers::test_extract_checksum_invalid_dictionary_name pa193mnemonicslytherin/test_mnemonic.py::TestInternalTestHelpers::test_extract_checksum_invalid_dictionary_name_unsupported pa193mnemonicslytherin/test_mnemonic.py::TestInternalTestHelpers::test_extract_checksum_invalid_dictionary_words_on_line pa193mnemonicslytherin/test_mnemonic.py::TestInternalTestHelpers::test_extract_checksum_invalid_mnemonic pa193mnemonicslytherin/test_mnemonic.py::TestInternalTestHelpers::test_extract_checksum_invalid_mnemonic_invalid_utf8 pa193mnemonicslytherin/test_mnemonic.py::TestPublicFunctions::test_generate pa193mnemonicslytherin/test_mnemonic.py::TestPublicFunctions::test_generate_invalid_arguments pa193mnemonicslytherin/test_mnemonic.py::TestPublicFunctions::test_generate_invalid_password_invalid_utf8 pa193mnemonicslytherin/test_mnemonic.py::TestPublicFunctions::test_generate_invalid_password_too_long pa193mnemonicslytherin/test_mnemonic.py::TestPublicFunctions::test_recover pa193mnemonicslytherin/test_mnemonic.py::TestPublicFunctions::test_recover_invalid_arguments pa193mnemonicslytherin/test_mnemonic.py::TestPublicFunctions::test_recover_invalid_password_invalid_utf8 pa193mnemonicslytherin/test_mnemonic.py::TestPublicFunctions::test_recover_invalid_password_too_long pa193mnemonicslytherin/test_mnemonic.py::TestPublicFunctions::test_verify pa193mnemonicslytherin/test_mnemonic.py::TestPublicFunctions::test_verify_invalid_arguments pa193mnemonicslytherin/test_mnemonic.py::TestPublicFunctions::test_verify_invalid_password_invalid_utf8 pa193mnemonicslytherin/test_mnemonic.py::TestPublicFunctions::test_verify_invalid_password_too_long pa193mnemonicslytherin/test_mnemonic.py::TestMnemonic::test___init__ pa193mnemonicslytherin/test_mnemonic.py::TestMnemonic::test___init___invalid_argument pa193mnemonicslytherin/test_mnemonic.py::TestMnemonic::test___init___invalid_utf8 pa193mnemonicslytherin/test_mnemonic.py::TestMnemonic::test___init___too_long_str pa193mnemonicslytherin/test_mnemonic.py::TestMnemonic::test_to_entropy pa193mnemonicslytherin/test_mnemonic.py::TestMnemonic::test_to_entropy_deep_copy pa193mnemonicslytherin/test_mnemonic.py::TestMnemonic::test_to_seed pa193mnemonicslytherin/test_mnemonic.py::TestMnemonic::test_to_seed_invalid_password pa193mnemonicslytherin/test_mnemonic.py::TestMnemonic::test_to_seed_invalid_password_invalid_utf8 pa193mnemonicslytherin/test_mnemonic.py::TestMnemonic::test_to_seed_invalid_password_too_long pa193mnemonicslytherin/test_mnemonic.py::TestSeed::test___eq__ pa193mnemonicslytherin/test_mnemonic.py::TestSeed::test___init__ pa193mnemonicslytherin/test_mnemonic.py::TestSeed::test___init___invalid_argument pa193mnemonicslytherin/test_mnemonic.py::TestSeed::test__ne__ pa193mnemonicslytherin/test_mnemonic.py::TestEntropy::test___init__ pa193mnemonicslytherin/test_mnemonic.py::TestEntropy::test___init___invalid_argument pa193mnemonicslytherin/test_mnemonic.py::TestEntropy::test_checksum pa193mnemonicslytherin/test_mnemonic.py::TestEntropy::test_to_mnemonic pa193mnemonicslytherin/test_mnemonic.py::TestEntropy::test_to_mnemonic_deep_copy pa193mnemonicslytherin/test_mnemonic.py::Test_DictionaryAccess::test___init___invalid_dictionary_lines pa193mnemonicslytherin/test_mnemonic.py::Test_DictionaryAccess::test___init___invalid_dictionary_long_word pa193mnemonicslytherin/test_mnemonic.py::Test_DictionaryAccess::test___init___invalid_dictionary_name pa193mnemonicslytherin/test_mnemonic.py::Test_DictionaryAccess::test___init___invalid_dictionary_name_unsupported pa193mnemonicslytherin/test_mnemonic.py::Test_DictionaryAccess::test___init___invalid_dictionary_non_utf8 pa193mnemonicslytherin/test_mnemonic.py::Test_DictionaryAccess::test___init___invalid_dictionary_words_on_line pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_arguments_EX_NOINPUT pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_arguments_error pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_arguments_ok_terminated pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_generate_invalid_entropy_invalid_utf8 pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_recover_invalid_mnemonic pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_recover_invalid_mnemonic_invalid_utf8 pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_verify_invalid_seed_invalid_utf8 pa193mnemonicslytherin/test_mnemoniccli.py::TestMain::test_verify_missing_seed_file
pa193mnemonicslytherin/mnemoniccli.py
pa193mnemonicslytherin/mnemoniccli.py