diff --git a/lang/python/tests/initial.py b/lang/python/tests/initial.py
index 4a02762b..49e4f82e 100755
--- a/lang/python/tests/initial.py
+++ b/lang/python/tests/initial.py
@@ -1,44 +1,42 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import os
 import subprocess
 import gpg
 import support
 
 print("Using gpg module from {0!r}.".format(os.path.dirname(gpg.__file__)))
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
-
 subprocess.check_call([os.path.join(os.getenv('top_srcdir'),
                                     "tests", "start-stop-agent"), "--start"])
 
 with gpg.Context() as c:
     alpha = c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False)
     bob = c.get_key("D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", False)
 
     # Mark alpha as trusted.  The signature verification tests expect
     # this.
     support.mark_key_trusted(c, alpha)
 
     c.op_import(open(support.in_srcdir("encrypt-only.asc")))
     c.op_import(open(support.in_srcdir("sign-only.asc")))
diff --git a/lang/python/tests/support.py b/lang/python/tests/support.py
index 69aa7a40..80c3a4bf 100644
--- a/lang/python/tests/support.py
+++ b/lang/python/tests/support.py
@@ -1,110 +1,107 @@
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import contextlib
 import shutil
 import sys
 import os
 import tempfile
 import time
 import gpg
 
 # known keys
 alpha = "A0FF4590BB6122EDEF6E3C542D727CC768697734"
 bob = "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2"
 encrypt_only = "F52770D5C4DB41408D918C9F920572769B9FE19C"
 sign_only = "7CCA20CCDE5394CEE71C9F0BFED153F12F18F45D"
 no_such_key = "A" * 40
 
 def make_filename(name):
     return os.path.join(os.environ['top_srcdir'], 'tests', 'gpg', name)
 
 def in_srcdir(name):
     return os.path.join(os.environ['srcdir'], name)
 
-def init_gpgme(proto):
-    gpg.core.engine_check_version(proto)
-
 verbose = int(os.environ.get('verbose', 0)) > 1
 def print_data(data):
     if verbose:
         try:
             # See if it is a file-like object.
             data.seek(0, os.SEEK_SET)
             data = data.read()
         except:
             # Hope for the best.
             pass
 
         if hasattr(sys.stdout, "buffer"):
             sys.stdout.buffer.write(data)
         else:
             sys.stdout.write(data)
 
 def mark_key_trusted(ctx, key):
     class Editor(object):
         def __init__(self):
             self.steps = ["trust", "save"]
         def edit(self, status, args, out):
             if args == "keyedit.prompt":
                 result = self.steps.pop(0)
             elif args == "edit_ownertrust.value":
                 result = "5"
             elif args == "edit_ownertrust.set_ultimate.okay":
                 result = "Y"
             elif args == "keyedit.save.okay":
                 result = "Y"
             else:
                 result = None
             return result
     with gpg.Data() as sink:
         ctx.op_edit(key, Editor().edit, sink, sink)
 
 
 # Python3.2 and up has tempfile.TemporaryDirectory, but we cannot use
 # that, because there shutil.rmtree is used without
 # ignore_errors=True, and that races against gpg-agent deleting its
 # sockets.
 class TemporaryDirectory(object):
     def __enter__(self):
         self.path = tempfile.mkdtemp()
         return self.path
     def __exit__(self, *args):
         shutil.rmtree(self.path, ignore_errors=True)
 
 @contextlib.contextmanager
 def EphemeralContext():
     with TemporaryDirectory() as tmp:
         home = os.environ['GNUPGHOME']
         shutil.copy(os.path.join(home, "gpg.conf"), tmp)
         shutil.copy(os.path.join(home, "gpg-agent.conf"), tmp)
 
         with gpg.Context(home_dir=tmp) as ctx:
             yield ctx
 
             # Ask the agent to quit.
             agent_socket = os.path.join(tmp, "S.gpg-agent")
             ctx.protocol = gpg.constants.protocol.ASSUAN
             ctx.set_engine_info(ctx.protocol, file_name=agent_socket)
             ctx.assuan_transact(["KILLAGENT"])
 
             # Block until it is really gone.
             while os.path.exists(agent_socket):
                 time.sleep(.01)
diff --git a/lang/python/tests/t-callbacks.py b/lang/python/tests/t-callbacks.py
index eed50bc4..ae157878 100755
--- a/lang/python/tests/t-callbacks.py
+++ b/lang/python/tests/t-callbacks.py
@@ -1,257 +1,255 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
-
 c = gpg.Context()
 c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
 
 source = gpg.Data("Hallo Leute\n")
 sink = gpg.Data()
 
 # Valid passphrases, both as string and bytes.
 for passphrase in ('foo', b'foo'):
     def passphrase_cb(hint, desc, prev_bad, hook=None):
         assert hook == passphrase
         return hook
 
     c.set_passphrase_cb(passphrase_cb, passphrase)
     c.op_encrypt([], 0, source, sink)
 
 # Returning an invalid type.
 def passphrase_cb(hint, desc, prev_bad, hook=None):
     return 0
 
 c.set_passphrase_cb(passphrase_cb, None)
 try:
     c.op_encrypt([], 0, source, sink)
 except Exception as e:
     assert type(e) == TypeError
     assert str(e) == "expected str or bytes from passphrase callback, got int"
 else:
     assert False, "Expected an error, got none"
 
 # Raising an exception inside callback.
 myException = Exception()
 def passphrase_cb(hint, desc, prev_bad, hook=None):
     raise myException
 
 c.set_passphrase_cb(passphrase_cb, None)
 try:
     c.op_encrypt([], 0, source, sink)
 except Exception as e:
     assert e == myException
 else:
     assert False, "Expected an error, got none"
 
 # Wrong kind of callback function.
 def bad_passphrase_cb():
     pass
 
 c.set_passphrase_cb(bad_passphrase_cb, None)
 try:
     c.op_encrypt([], 0, source, sink)
 except Exception as e:
     assert type(e) == TypeError
 else:
     assert False, "Expected an error, got none"
 
 
 
 # Test the progress callback.
 parms = """<GnupgKeyParms format="internal">
 Key-Type: RSA
 Key-Length: 1024
 Name-Real: Joe Tester
 Name-Comment: with stupid passphrase
 Name-Email: joe+gpg@example.org
 Passphrase: Crypt0R0cks
 Expire-Date: 2020-12-31
 </GnupgKeyParms>
 """
 
 messages = []
 def progress_cb(what, typ, current, total, hook=None):
     assert hook == messages
     messages.append(
         "PROGRESS UPDATE: what = {}, type = {}, current = {}, total = {}"
         .format(what, typ, current, total))
 
 c = gpg.Context()
 c.set_progress_cb(progress_cb, messages)
 c.op_genkey(parms, None, None)
 assert len(messages) > 0
 
 # Test exception handling.
 def progress_cb(what, typ, current, total, hook=None):
     raise myException
 
 c = gpg.Context()
 c.set_progress_cb(progress_cb, None)
 try:
     c.op_genkey(parms, None, None)
 except Exception as e:
     assert e == myException
 else:
     assert False, "Expected an error, got none"
 
 
 # Test the edit callback.
 c = gpg.Context()
 c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
 c.set_passphrase_cb(lambda *args: "abc")
 sink = gpg.Data()
 alpha = c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False)
 
 cookie = object()
 edit_cb_called = False
 def edit_cb(status, args, hook):
     global edit_cb_called
     edit_cb_called = True
     assert hook == cookie
     return "quit" if args == "keyedit.prompt" else None
 c.op_edit(alpha, edit_cb, cookie, sink)
 assert edit_cb_called
 
 # Test exceptions.
 c = gpg.Context()
 c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
 c.set_passphrase_cb(lambda *args: "abc")
 sink = gpg.Data()
 
 def edit_cb(status, args):
     raise myException
 try:
     c.op_edit(alpha, edit_cb, None, sink)
 except Exception as e:
     assert e == myException
 else:
     assert False, "Expected an error, got none"
 
 
 
 # Test the status callback.
 source = gpg.Data("Hallo Leute\n")
 sink = gpg.Data()
 
 status_cb_called = False
 def status_cb(keyword, args, hook=None):
     global status_cb_called
     status_cb_called = True
     assert hook == cookie
 
 c = gpg.Context()
 c.set_status_cb(status_cb, cookie)
 c.set_ctx_flag("full-status", "1")
 c.op_encrypt([alpha], gpg.constants.ENCRYPT_ALWAYS_TRUST, source, sink)
 assert status_cb_called
 
 # Test exceptions.
 source = gpg.Data("Hallo Leute\n")
 sink = gpg.Data()
 
 def status_cb(keyword, args):
     raise myException
 
 c = gpg.Context()
 c.set_status_cb(status_cb, None)
 c.set_ctx_flag("full-status", "1")
 try:
     c.op_encrypt([alpha], gpg.constants.ENCRYPT_ALWAYS_TRUST, source, sink)
 except Exception as e:
     assert e == myException
 else:
     assert False, "Expected an error, got none"
 
 
 
 # Test the data callbacks.
 def read_cb(amount, hook=None):
     assert hook == cookie
     return 0
 def release_cb(hook=None):
     assert hook == cookie
 data = gpg.Data(cbs=(read_cb, None, None, release_cb, cookie))
 try:
     data.read()
 except Exception as e:
     assert type(e) == TypeError
 else:
     assert False, "Expected an error, got none"
 
 def read_cb(amount):
     raise myException
 data = gpg.Data(cbs=(read_cb, None, None, lambda: None))
 try:
     data.read()
 except Exception as e:
     assert e == myException
 else:
     assert False, "Expected an error, got none"
 
 
 def write_cb(what, hook=None):
     assert hook == cookie
     return "wrong type"
 data = gpg.Data(cbs=(None, write_cb, None, release_cb, cookie))
 try:
     data.write(b'stuff')
 except Exception as e:
     assert type(e) == TypeError
 else:
     assert False, "Expected an error, got none"
 
 def write_cb(what):
     raise myException
 data = gpg.Data(cbs=(None, write_cb, None, lambda: None))
 try:
     data.write(b'stuff')
 except Exception as e:
     assert e == myException
 else:
     assert False, "Expected an error, got none"
 
 
 def seek_cb(offset, whence, hook=None):
     assert hook == cookie
     return "wrong type"
 data = gpg.Data(cbs=(None, None, seek_cb, release_cb, cookie))
 try:
     data.seek(0, os.SEEK_SET)
 except Exception as e:
     assert type(e) == TypeError
 else:
     assert False, "Expected an error, got none"
 
 def seek_cb(offset, whence):
     raise myException
 data = gpg.Data(cbs=(None, None, seek_cb, lambda: None))
 try:
     data.seek(0, os.SEEK_SET)
 except Exception as e:
     assert e == myException
 else:
     assert False, "Expected an error, got none"
diff --git a/lang/python/tests/t-decrypt-verify.py b/lang/python/tests/t-decrypt-verify.py
index 62431671..03bbc4b5 100755
--- a/lang/python/tests/t-decrypt-verify.py
+++ b/lang/python/tests/t-decrypt-verify.py
@@ -1,76 +1,75 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
 def check_verify_result(result, summary, fpr, status):
     assert len(result.signatures) == 1, "Unexpected number of signatures"
     sig = result.signatures[0]
     assert sig.summary == summary, "Unexpected signature summary"
     assert sig.fpr == fpr
     assert gpg.errors.GPGMEError(sig.status).getcode() == status
     assert len(sig.notations) == 0
     assert not sig.wrong_key_usage
     assert sig.validity == gpg.constants.validity.FULL
     assert gpg.errors.GPGMEError(sig.validity_reason).getcode() == gpg.errors.NO_ERROR
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 
 source = gpg.Data(file=support.make_filename("cipher-2.asc"))
 sink = gpg.Data()
 
 c.op_decrypt_verify(source, sink)
 result = c.op_decrypt_result()
 assert not result.unsupported_algorithm, \
     "Unsupported algorithm: {}".format(result.unsupported_algorithm)
 
 support.print_data(sink)
 
 verify_result = c.op_verify_result()
 check_verify_result(verify_result,
                     gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
                     "A0FF4590BB6122EDEF6E3C542D727CC768697734",
                     gpg.errors.NO_ERROR)
 
 # Idiomatic interface.
 with gpg.Context() as c:
     alpha = c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False)
     bob = c.get_key("D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", False)
     plaintext, _, verify_result = \
         c.decrypt(open(support.make_filename("cipher-2.asc")), verify=[alpha])
     assert plaintext.find(b'Wenn Sie dies lesen k') >= 0, \
         'Plaintext not found'
     check_verify_result(verify_result,
                         gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
                         "A0FF4590BB6122EDEF6E3C542D727CC768697734",
                         gpg.errors.NO_ERROR)
 
     try:
         c.decrypt(open(support.make_filename("cipher-2.asc")),
                   verify=[alpha, bob])
     except gpg.errors.MissingSignatures as e:
         assert len(e.missing) == 1
         assert e.missing[0] == bob
     else:
         assert False, "Expected an error, got none"
diff --git a/lang/python/tests/t-decrypt.py b/lang/python/tests/t-decrypt.py
index 1af05626..05b6d8b0 100755
--- a/lang/python/tests/t-decrypt.py
+++ b/lang/python/tests/t-decrypt.py
@@ -1,44 +1,43 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 
 source = gpg.Data(file=support.make_filename("cipher-1.asc"))
 sink = gpg.Data()
 
 c.op_decrypt(source, sink)
 result = c.op_decrypt_result()
 assert not result.unsupported_algorithm, \
     "Unsupported algorithm: {}".format(result.unsupported_algorithm)
 
 support.print_data(sink)
 
 # Idiomatic interface.
 with gpg.Context() as c:
     plaintext, _, _ = c.decrypt(open(support.make_filename("cipher-1.asc")))
     assert len(plaintext) > 0
     assert plaintext.find(b'Wenn Sie dies lesen k') >= 0, \
         'Plaintext not found'
diff --git a/lang/python/tests/t-edit.py b/lang/python/tests/t-edit.py
index bd70e7ee..7ac3626f 100755
--- a/lang/python/tests/t-edit.py
+++ b/lang/python/tests/t-edit.py
@@ -1,72 +1,70 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2005 Igor Belyi <belyi@users.sourceforge.net>
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import sys
 import os
 import gpg
 import support
 
 class KeyEditor(object):
     def __init__(self):
         self.steps = ["fpr", "expire", "1", "primary", "quit"]
         self.step = 0
         self.done = False
         self.verbose = int(os.environ.get('verbose', 0)) > 1
 
     def edit_fnc(self, status, args, out=None):
         if args == "keyedit.prompt":
             result = self.steps[self.step]
             self.step += 1
         elif args == "keyedit.save.okay":
             result = "Y"
             self.done = self.step == len(self.steps)
         elif args == "keygen.valid":
             result = "0"
         else:
             result = None
 
         if self.verbose:
             sys.stderr.write("Code: {}, args: {!r}, Returning: {!r}\n"
                              .format(status, args, result))
 
         return result
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
-
 c = gpg.Context()
 c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
 c.set_passphrase_cb(lambda *args: "abc")
 c.set_armor(True)
 
 # The deprecated interface.
 editor = KeyEditor()
 c.interact(c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False),
            editor.edit_fnc)
 assert editor.done
 
 # The deprecated interface.
 sink = gpg.Data()
 editor = KeyEditor()
 c.op_edit(c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False),
           editor.edit_fnc, sink, sink)
 assert editor.done
diff --git a/lang/python/tests/t-encrypt-large.py b/lang/python/tests/t-encrypt-large.py
index cdb4a32a..56460851 100755
--- a/lang/python/tests/t-encrypt-large.py
+++ b/lang/python/tests/t-encrypt-large.py
@@ -1,66 +1,65 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import sys
 import random
 import gpg
 import support
 
 if len(sys.argv) == 2:
     nbytes = int(sys.argv[1])
 else:
     nbytes = 100000
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 
 ntoread = nbytes
 def read_cb(amount):
     global ntoread
     chunk = ntoread if ntoread < amount else amount
     ntoread -= chunk
     assert ntoread >= 0
     assert chunk >= 0
     return bytes(bytearray(random.randrange(256) for i in range(chunk)))
 
 nwritten = 0
 def write_cb(data):
     global nwritten
     nwritten += len(data)
     return len(data)
 
 source = gpg.Data(cbs=(read_cb, None, None, lambda: None))
 sink = gpg.Data(cbs=(None, write_cb, None, lambda: None))
 
 keys = []
 keys.append(c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False))
 keys.append(c.get_key("D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", False))
 
 c.op_encrypt(keys, gpg.constants.ENCRYPT_ALWAYS_TRUST, source, sink)
 result = c.op_encrypt_result()
 assert not result.invalid_recipients, \
     "Invalid recipient encountered: {}".format(result.invalid_recipients.fpr)
 assert ntoread == 0
 
 if support.verbose:
     sys.stderr.write(
         "plaintext={} bytes, ciphertext={} bytes\n".format(nbytes, nwritten))
diff --git a/lang/python/tests/t-encrypt-sign.py b/lang/python/tests/t-encrypt-sign.py
index 094a2b00..f04783f4 100755
--- a/lang/python/tests/t-encrypt-sign.py
+++ b/lang/python/tests/t-encrypt-sign.py
@@ -1,97 +1,96 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import sys
 import gpg
 import support
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 c.set_armor(True)
 
 def check_result(r, typ):
     if r.invalid_signers:
         sys.exit("Invalid signer found: {}".format(r.invalid_signers.fpr))
 
     if len(r.signatures) != 1:
         sys.exit("Unexpected number of signatures created")
 
     signature = r.signatures[0]
     if signature.type != typ:
         sys.exit("Wrong type of signature created")
 
     if signature.pubkey_algo != gpg.constants.pk.DSA:
         sys.exit("Wrong pubkey algorithm reported: {}".format(
             signature.pubkey_algo))
 
     if signature.hash_algo not in (gpg.constants.md.SHA1, gpg.constants.md.RMD160):
         sys.exit("Wrong hash algorithm reported: {}".format(
             signature.hash_algo))
 
     if signature.sig_class != 0:
         sys.exit("Wrong signature class reported: {}".format(
             signature.sig_class))
 
     if signature.fpr != "A0FF4590BB6122EDEF6E3C542D727CC768697734":
         sys.exit("Wrong fingerprint reported: {}".format(signature.fpr))
 
 keys = []
 keys.append(c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False))
 keys.append(c.get_key("D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", False))
 
 for recipients in (keys, []):
     source = gpg.Data("Hallo Leute\n")
     sink = gpg.Data()
 
     c.op_encrypt_sign(recipients, gpg.constants.ENCRYPT_ALWAYS_TRUST, source, sink)
     result = c.op_encrypt_result()
     assert not result.invalid_recipients, \
         "Invalid recipient encountered: {}".format(
             result.invalid_recipients.fpr)
 
     result = c.op_sign_result()
     check_result(result, gpg.constants.sig.mode.NORMAL)
 
     support.print_data(sink)
 
 
 # Idiomatic interface.
 with gpg.Context(armor=True) as c:
     message = "Hallo Leute\n".encode()
     ciphertext, _, sig_result = c.encrypt(message,
                                           recipients=keys,
                                           always_trust=True)
     assert len(ciphertext) > 0
     assert ciphertext.find(b'BEGIN PGP MESSAGE') > 0, 'Marker not found'
     check_result(sig_result, gpg.constants.sig.mode.NORMAL)
 
     c.signers = [c.get_key(support.sign_only, True)]
     c.encrypt(message, recipients=keys, always_trust=True)
 
     c.signers = [c.get_key(support.encrypt_only, True)]
     try:
         c.encrypt(message, recipients=keys, always_trust=True)
     except gpg.errors.InvalidSigners as e:
         assert len(e.signers) == 1
         assert support.encrypt_only.endswith(e.signers[0].fpr)
     else:
         assert False, "Expected an InvalidSigners error, got none"
diff --git a/lang/python/tests/t-encrypt-sym.py b/lang/python/tests/t-encrypt-sym.py
index 07e6b62c..c15955a9 100755
--- a/lang/python/tests/t-encrypt-sym.py
+++ b/lang/python/tests/t-encrypt-sym.py
@@ -1,85 +1,83 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
-
 for passphrase in ("abc", b"abc"):
     c = gpg.Context()
     c.set_armor(True)
     c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
 
     source = gpg.Data("Hallo Leute\n")
     cipher = gpg.Data()
 
     passphrase_cb_called = 0
     def passphrase_cb(hint, desc, prev_bad, hook=None):
         global passphrase_cb_called
         passphrase_cb_called += 1
         return passphrase
 
     c.set_passphrase_cb(passphrase_cb, None)
 
     c.op_encrypt([], 0, source, cipher)
     assert passphrase_cb_called == 1, \
         "Callback called {} times".format(passphrase_cb_called)
     support.print_data(cipher)
 
     c = gpg.Context()
     c.set_armor(True)
     c.set_pinentry_mode(gpg.constants.PINENTRY_MODE_LOOPBACK)
     c.set_passphrase_cb(passphrase_cb, None)
     plain = gpg.Data()
     cipher.seek(0, os.SEEK_SET)
 
     c.op_decrypt(cipher, plain)
     # Seems like the passphrase is cached.
     #assert passphrase_cb_called == 2, \
     #    "Callback called {} times".format(passphrase_cb_called)
     support.print_data(plain)
 
     plain.seek(0, os.SEEK_SET)
     plaintext = plain.read()
     assert plaintext == b"Hallo Leute\n", \
         "Wrong plaintext {!r}".format(plaintext)
 
 # Idiomatic interface.
 for passphrase in ("abc", b"abc"):
     with gpg.Context(armor=True) as c:
         # Check that the passphrase callback is not altered.
         def f(*args):
             assert False
         c.set_passphrase_cb(f)
 
         message = "Hallo Leute\n".encode()
         ciphertext, _, _ = c.encrypt(message,
                                      passphrase=passphrase,
                                      sign=False)
         assert ciphertext.find(b'BEGIN PGP MESSAGE') > 0, 'Marker not found'
 
         plaintext, _, _ = c.decrypt(ciphertext, passphrase=passphrase)
         assert plaintext == message, 'Message body not recovered'
 
         assert c._passphrase_cb[1] == f, "Passphrase callback not restored"
diff --git a/lang/python/tests/t-encrypt.py b/lang/python/tests/t-encrypt.py
index 3cbe8f2f..921502a7 100755
--- a/lang/python/tests/t-encrypt.py
+++ b/lang/python/tests/t-encrypt.py
@@ -1,79 +1,78 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 c.set_armor(True)
 
 source = gpg.Data("Hallo Leute\n")
 sink = gpg.Data()
 
 keys = []
 keys.append(c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False))
 keys.append(c.get_key("D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", False))
 
 c.op_encrypt(keys, gpg.constants.ENCRYPT_ALWAYS_TRUST, source, sink)
 result = c.op_encrypt_result()
 assert not result.invalid_recipients, \
   "Invalid recipients: {}".format(", ".join(r.fpr for r in result.recipients))
 support.print_data(sink)
 
 # Idiomatic interface.
 with gpg.Context(armor=True) as c:
     ciphertext, _, _ = c.encrypt("Hallo Leute\n".encode(),
                                  recipients=keys,
                                  sign=False,
                                  always_trust=True)
     assert len(ciphertext) > 0
     assert ciphertext.find(b'BEGIN PGP MESSAGE') > 0, 'Marker not found'
 
     c.encrypt("Hallo Leute\n".encode(),
               recipients=[c.get_key(support.encrypt_only, False)],
               sign=False, always_trust=True)
 
     try:
         c.encrypt("Hallo Leute\n".encode(),
                   recipients=[c.get_key(support.sign_only, False)],
                   sign=False, always_trust=True)
     except gpg.errors.InvalidRecipients as e:
         assert len(e.recipients) == 1
         assert support.sign_only.endswith(e.recipients[0].fpr)
     else:
         assert False, "Expected an InvalidRecipients error, got none"
 
 
 
     try:
         # People might be tempted to provide strings.
         # We should raise something useful.
         ciphertext, _, _ = c.encrypt("Hallo Leute\n",
                                      recipients=keys,
                                      sign=False,
                                      always_trust=True)
     except TypeError as e:
         # This test is a bit fragile, because the message
         # may very well change. So if the behaviour will change
         # this test can easily be deleted.
         assert "encode" in str(e)
diff --git a/lang/python/tests/t-export.py b/lang/python/tests/t-export.py
index 4927beb0..b9d52048 100755
--- a/lang/python/tests/t-export.py
+++ b/lang/python/tests/t-export.py
@@ -1,40 +1,39 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 c.set_armor(True)
 
 sink = gpg.Data()
 c.op_export_ext(['Alpha', 'Bob'], 0, sink)
 support.print_data(sink)
 
 # Again. Now using a key array.
 keys = []
 keys.append(c.get_key("0x68697734", False)) # Alpha
 keys.append(c.get_key("0xA9E3B0B2", False)) # Bob
 sink = gpg.Data()
 c.op_export_keys(keys, 0, sink)
 support.print_data(sink)
diff --git a/lang/python/tests/t-file-name.py b/lang/python/tests/t-file-name.py
index d12afb86..aab56802 100755
--- a/lang/python/tests/t-file-name.py
+++ b/lang/python/tests/t-file-name.py
@@ -1,45 +1,44 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
 
 testname = "abcde12345"
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 c.set_armor(True)
 
 source = gpg.Data("Hallo Leute\n")
 source.set_file_name(testname)
 cipher = gpg.Data()
 plain = gpg.Data()
 
 keys = []
 keys.append(c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False))
 
 c.op_encrypt(keys, gpg.constants.ENCRYPT_ALWAYS_TRUST, source, cipher)
 cipher.seek(0, os.SEEK_SET)
 c.op_decrypt(cipher, plain)
 result = c.op_decrypt_result()
 assert result.file_name == testname
diff --git a/lang/python/tests/t-idiomatic.py b/lang/python/tests/t-idiomatic.py
index 485f0486..826bc23c 100755
--- a/lang/python/tests/t-idiomatic.py
+++ b/lang/python/tests/t-idiomatic.py
@@ -1,84 +1,82 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import sys
 import io
 import os
 import tempfile
 import gpg
 import support
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
-
 # Both Context and Data can be used as context manager:
 with gpg.Context() as c, gpg.Data() as d:
     c.get_engine_info()
     d.write(b"Halloechen")
     leak_c = c
     leak_d = d
 assert leak_c.wrapped == None
 assert leak_d.wrapped == None
 
 def sign_and_verify(source, signed, sink):
     with gpg.Context() as c:
         c.op_sign(source, signed, gpg.constants.sig.mode.NORMAL)
         signed.seek(0, os.SEEK_SET)
         c.op_verify(signed, None, sink)
         result = c.op_verify_result()
 
     assert len(result.signatures) == 1, "Unexpected number of signatures"
     sig = result.signatures[0]
     assert sig.summary == (gpg.constants.sigsum.VALID |
                            gpg.constants.sigsum.GREEN)
     assert gpg.errors.GPGMEError(sig.status).getcode() == gpg.errors.NO_ERROR
 
     sink.seek(0, os.SEEK_SET)
     assert sink.read() == b"Hallo Leute\n"
 
 # Demonstrate automatic wrapping of file-like objects with 'fileno'
 # method.
 with tempfile.TemporaryFile() as source, \
      tempfile.TemporaryFile() as signed, \
      tempfile.TemporaryFile() as sink:
     source.write(b"Hallo Leute\n")
     source.seek(0, os.SEEK_SET)
 
     sign_and_verify(source, signed, sink)
 
 if sys.version_info[0] == 3:
     # Python2's io.BytesIO does not implement the buffer interface,
     # hence we cannot use it as sink.
 
     # XXX: Python's io.BytesIo.truncate does not work as advertised.
     # http://bugs.python.org/issue27261
     bio = io.BytesIO()
     bio.truncate(1)
     if len(bio.getvalue()) != 1:
         # This version of Python is affected, preallocate buffer.
         preallocate = 128*b'\x00'
     else:
         preallocate = b''
 
     # Demonstrate automatic wrapping of objects implementing the buffer
     # interface, and the use of data objects with the 'with' statement.
     with io.BytesIO(preallocate) as signed, gpg.Data() as sink:
         sign_and_verify(b"Hallo Leute\n", signed, sink)
diff --git a/lang/python/tests/t-import.py b/lang/python/tests/t-import.py
index 5b0576f2..e2edf5a2 100755
--- a/lang/python/tests/t-import.py
+++ b/lang/python/tests/t-import.py
@@ -1,79 +1,78 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
 def check_result(result, fpr, secret):
     assert result.considered == 1 or (secret and result.considered == 3)
     assert result.no_user_id == 0
     assert not ((secret and result.imported != 0)
                 or (not secret and (result.imported != 0
                                     and result.imported != 1)))
     assert result.imported_rsa == 0
     assert not ((secret and (result.unchanged != 0 and result.unchanged != 1))
                 or (not secret and ((result.imported == 0
                                      and result.unchanged != 1)
                                  or (result.imported == 1
                                      and result.unchanged != 0))))
     assert result.new_user_ids == 0
     assert result.new_sub_keys == 0
     assert not ((secret
                  and ((result.secret_imported == 0
                        and result.new_signatures != 0)
                       or (result.secret_imported == 1
                           and result.new_signatures > 1)))
                 or (not secret and result.new_signatures != 0))
     assert result.new_revocations == 0
     assert not ((secret and result.secret_read != 1 and result.secret_read != 3)
                 or (not secret and result.secret_read != 0))
     assert not ((secret and result.secret_imported != 0
                  and result.secret_imported != 1
                  and result.secret_imported != 2)
                 or (not secret and result.secret_imported != 0))
     assert not ((secret
                  and ((result.secret_imported == 0
                        and result.secret_unchanged != 1
                        and result.secret_unchanged != 2)
                       or (result.secret_imported == 1
                           and result.secret_unchanged != 0)))
                 or (not secret and result.secret_unchanged != 0))
     assert result.not_imported == 0
     if secret:
         assert not (len(result.imports) in (0, 3))
     else:
         assert not (len(result.imports) in (0, 2))
 
     assert fpr == result.imports[0].fpr
     assert len(result.imports) == 1 or fpr == result.imports[1].fpr
     assert result.imports[0].result == 0
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 
 c.op_import(gpg.Data(file=support.make_filename("pubkey-1.asc")))
 result = c.op_import_result()
 check_result(result, "ADAB7FCC1F4DE2616ECFA402AF82244F9CD9FD55", False)
 
 c.op_import(gpg.Data(file=support.make_filename("seckey-1.asc")))
 result = c.op_import_result()
 check_result(result, "ADAB7FCC1F4DE2616ECFA402AF82244F9CD9FD55", True)
diff --git a/lang/python/tests/t-keylist.py b/lang/python/tests/t-keylist.py
index 5077ca69..76c793e7 100755
--- a/lang/python/tests/t-keylist.py
+++ b/lang/python/tests/t-keylist.py
@@ -1,280 +1,279 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 
 # Check expration of keys.  This test assumes three subkeys of which
 # 2 are expired; it is used with the "Whisky" test key.  It has
 # already been checked that these 3 subkeys are available.
 def check_whisky(name, key):
   sub1 = key.subkeys[2]
   sub2 = key.subkeys[3]
 
   assert sub1.expired and sub2.expired, \
       "Subkey of `{}' not flagged as expired".format(name)
   assert sub1.expires == 1129636886 and sub2.expires == 1129636939, \
       "Subkey of `{}' has wrong expiration date".format(name)
 
 keys = [
     [ "A0FF4590BB6122EDEF6E3C542D727CC768697734", "6AE6D7EE46A871F8",
       [ [ "Alfa Test", "demo key", "alfa@example.net" ],
         [ "Alpha Test", "demo key", "alpha@example.net" ],
 	[ "Alice", "demo key", "" ] ], 1 ],
     [ "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", "5381EA4EE29BA37F",
       [ [ "Bob", "demo key", "" ],
 	[ "Bravo Test", "demo key", "bravo@example.net" ] ], 1 ],
     [ "61EE841A2A27EB983B3B3C26413F4AF31AFDAB6C", "E71E72ACBC43DA60",
       [ [ "Charlie Test", "demo key", "charlie@example.net" ] ], 1 ],
     [ "6560C59C43D031C54D7C588EEBA9F240EB9DC9E6", "06F22880B0C45424",
       [ [ "Delta Test", "demo key", "delta@example.net" ] ], 1 ],
     [ "3531152DE293E26A07F504BC318C1FAEFAEF6D1B", "B5C79E1A7272144D",
       [ [ "Echelon", "demo key", "" ],
 	[ "Echo Test", "demo key", "echo@example.net" ],
 	[ "Eve", "demo key", "" ] ], 1 ],
     [ "56D33268F7FE693FBB594762D4BF57F37372E243", "0A32EE79EE45198E",
       [ [ "Foxtrot Test", "demo key", "foxtrot@example.net" ] ], 1 ],
     [ "C9C07DCC6621B9FB8D071B1D168410A48FC282E6", "247491CC9DCAD354",
       [ [ "Golf Test", "demo key", "golf@example.net" ] ], 1 ],
     [ "9E91CBB11E4D4135583EF90513DB965534C6E3F1", "76E26537D622AD0A",
       [ [ "Hotel Test", "demo key", "hotel@example.net" ] ], 1 ],
     [ "CD538D6CC9FB3D745ECDA5201FE8FC6F04259677", "C1C8EFDE61F76C73",
       [ [ "India Test", "demo key", "india@example.net" ] ], 1 ],
     [ "F8F1EDC73995AB739AD54B380C820C71D2699313", "BD0B108735F8F136",
       [ [ "Juliet Test", "demo key", "juliet@example.net" ] ], 1 ],
     [ "3FD11083779196C2ECDD9594AD1B0FAD43C2D0C7", "86CBB34A9AF64D02",
       [ [ "Kilo Test", "demo key", "kilo@example.net" ] ], 1 ],
     [ "1DDD28CEF714F5B03B8C246937CAB51FB79103F8", "0363B449FE56350C",
       [ [ "Lima Test", "demo key", "lima@example.net" ] ], 1 ],
     [ "2686AA191A278013992C72EBBE794852BE5CF886", "5F600A834F31EAE8",
       [ [ "Mallory", "demo key", "" ],
 	[ "Mike Test", "demo key", "mike@example.net" ] ], 1 ],
     [ "5AB9D6D7BAA1C95B3BAA3D9425B00FD430CEC684", "4C1D63308B70E472",
       [ [ "November Test", "demo key", "november@example.net" ] ], 1 ],
     [ "43929E89F8F79381678CAE515F6356BA6D9732AC", "FF0785712681619F",
       [ [ "Oscar Test", "demo key", "oscar@example.net" ] ], 1 ],
     [ "6FAA9C201E5E26DCBAEC39FD5D15E01D3FF13206", "2764E18263330D9C",
       [ [ "Papa test", "demo key", "papa@example.net" ] ], 1 ],
     [ "A7969DA1C3297AA96D49843F1C67EC133C661C84", "6CDCFC44A029ACF4",
       [ [ "Quebec Test", "demo key", "quebec@example.net" ] ], 1 ],
     [ "38FBE1E4BF6A5E1242C8F6A13BDBEDB1777FBED3", "9FAB805A11D102EA",
       [ [ "Romeo Test", "demo key", "romeo@example.net" ] ], 1 ],
     [ "045B2334ADD69FC221076841A5E67F7FA3AE3EA1", "93B88B0F0F1B50B4",
       [ [ "Sierra Test", "demo key", "sierra@example.net" ] ], 1 ],
     [ "ECAC774F4EEEB0620767044A58CB9A4C85A81F38", "97B60E01101C0402",
       [ [ "Tango Test", "demo key", "tango@example.net" ] ], 1 ],
     [ "0DBCAD3F08843B9557C6C4D4A94C0F75653244D6", "93079B915522BDB9",
       [ [ "Uniform Test", "demo key", "uniform@example.net" ] ], 1 ],
     [ "E8143C489C8D41124DC40D0B47AF4B6961F04784", "04071FB807287134",
       [ [ "Victor Test", "demo key", "victor@example.org" ] ], 1 ],
     [ "E8D6C90B683B0982BD557A99DEF0F7B8EC67DBDE", "D7FBB421FD6E27F6",
       [ [ "Whisky Test", "demo key", "whisky@example.net" ] ], 3,
       check_whisky ],
     [ "04C1DF62EFA0EBB00519B06A8979A6C5567FB34A", "5CC6F87F41E408BE",
       [ [ "XRay Test", "demo key", "xray@example.net" ] ], 1 ],
     [ "ED9B316F78644A58D042655A9EEF34CD4B11B25F", "5ADFD255F7B080AD",
       [ [ "Yankee Test", "demo key", "yankee@example.net" ] ], 1 ],
     [ "23FD347A419429BACCD5E72D6BC4778054ACD246", "EF9DC276A172C881",
       [ [ "Zulu Test", "demo key", "zulu@example.net" ] ], 1 ],
 ]
 
 def check_global(key, uids, n_subkeys):
     assert not key.revoked, "Key unexpectedly revoked"
     assert not key.expired, "Key unexpectedly expired"
     assert not key.disabled, "Key unexpectedly disabled"
     assert not key.invalid, "Key unexpectedly invalid"
     assert key.can_sign, "Key unexpectedly unusable for signing"
     assert key.can_certify, "Key unexpectedly unusable for certifications"
     assert not key.secret, "Key unexpectedly secret"
     assert not key.protocol != gpg.constants.protocol.OpenPGP, \
         "Key has unexpected protocol: {}".format(key.protocol)
     assert not key.issuer_serial, \
         "Key unexpectedly carries issuer serial: {}".format(key.issuer_serial)
     assert not key.issuer_name, \
         "Key unexpectedly carries issuer name: {}".format(key.issuer_name)
     assert not key.chain_id, \
         "Key unexpectedly carries chain ID: {}".format(key.chain_id)
 
     # Only key Alfa is trusted
     assert key.uids[0].name == 'Alfa Test' \
       or key.owner_trust == gpg.constants.validity.UNKNOWN, \
         "Key has unexpected owner trust: {}".format(key.owner_trust)
     assert key.uids[0].name != 'Alfa Test' \
       or key.owner_trust == gpg.constants.validity.ULTIMATE, \
         "Key has unexpected owner trust: {}".format(key.owner_trust)
 
     assert len(key.subkeys) - 1 == n_subkeys, \
         "Key `{}' has unexpected number of subkeys".format(uids[0][0])
 
 
 def check_subkey(fpr, which, subkey):
     assert not subkey.revoked, which + " key unexpectedly revoked"
     assert not subkey.expired, which + " key unexpectedly expired"
     assert not subkey.disabled, which + " key unexpectedly disabled"
     assert not subkey.invalid, which + " key unexpectedly invalid"
 
     if which == "Primary":
         assert not subkey.can_encrypt, \
             which + " key unexpectedly usable for encryption"
         assert subkey.can_sign, \
             which + " key unexpectedly unusable for signing"
         assert subkey.can_certify, \
             which + " key unexpectedly unusable for certifications"
     else:
         assert subkey.can_encrypt, \
             which + " key unexpectedly unusable for encryption"
         assert not subkey.can_sign, \
             which + " key unexpectedly usable for signing"
         assert not subkey.can_certify, \
             which + " key unexpectedly usable for certifications"
 
     assert not subkey.secret, which + " key unexpectedly secret"
     assert not subkey.is_cardkey, "Public key marked as card key"
     assert not subkey.card_number, "Public key with card number set"
     assert not subkey.pubkey_algo != (gpg.constants.pk.DSA if which == "Primary"
                                       else gpg.constants.pk.ELG_E), \
         which + " key has unexpected public key algo: {}".\
             format(subkey.pubkey_algo)
     assert subkey.length == 1024, \
         which + " key has unexpected length: {}".format(subkey.length)
     assert fpr.endswith(subkey.keyid), \
         which + " key has unexpected key ID: {}".format(subkey.keyid)
     assert which == "Secondary" or subkey.fpr == fpr, \
         which + " key has unexpected fingerprint: {}".format(subkey.fpr)
     assert not subkey.expires, \
         which + " key unexpectedly expires: {}".format(subkey.expires)
 
 def check_uid(which, ref, uid):
     assert not uid.revoked, which + " user ID unexpectedly revoked"
     assert not uid.invalid, which + " user ID unexpectedly invalid"
     assert uid.validity == (gpg.constants.validity.UNKNOWN
                             if uid.name.split()[0]
                             not in {'Alfa', 'Alpha', 'Alice'} else
                             gpg.constants.validity.ULTIMATE), \
       which + " user ID has unexpectedly validity: {}".format(uid.validity)
     assert not uid.signatures, which + " user ID unexpectedly signed"
     assert uid.name == ref[0], \
       "Unexpected name in {} user ID: {!r}".format(which.lower(), uid.name)
     assert uid.comment == ref[1], \
       "Unexpected comment in {} user ID: {!r}".format(which.lower(),
                                                       uid.comment)
     assert uid.email == ref[2], \
       "Unexpected email in {} user ID: {!r}".format(which.lower(), uid.email)
 
 i = 0
 c.op_keylist_start(None, False)
 key = c.op_keylist_next ()
 while key:
     try:
         if len(keys[i]) == 4:
             fpr, sec_keyid, uids, n_subkeys = keys[i]
             misc_check = None
         else:
             fpr, sec_keyid, uids, n_subkeys, misc_check = keys[i]
     except IndexError:
         # There are more keys.  We don't check for that.
         break
 
     # Global key flags.
     check_global(key, uids, n_subkeys)
     check_subkey(fpr, "Primary", key.subkeys[0])
     check_subkey(sec_keyid, "Secondary", key.subkeys[1])
 
     assert len(key.uids) == len(uids)
     check_uid("First", uids[0], key.uids[0])
     if len(key.uids) > 1:
       check_uid("Second", uids[1], key.uids[1])
     if len(key.uids) > 2:
       check_uid("Third", uids[2], key.uids[2])
 
     if misc_check:
         misc_check (uids[0][0], key)
     key = c.op_keylist_next ()
     i += 1
 
 c.op_keylist_end()
 result = c.op_keylist_result()
 assert not result.truncated, "Key listing unexpectedly truncated"
 
 
 # We test for a parameter-less keylist
 keyring_length = len(list(c.op_keylist_all()))
 assert keyring_length > 1,\
                 "Expected to find some keys, but got %r" % keyring_length
 
 # Then we do want to call with a pattern, only
 # i.e. without giving secret=0
 alpha_keys = list(c.op_keylist_all(b"Alpha"))
 assert len(alpha_keys) == 1, "Expected only one key for 'Alpha', got %r" % len(alpha_keys)
 
 
 
 for i, key in enumerate(c.keylist()):
     try:
         if len(keys[i]) == 4:
             fpr, sec_keyid, uids, n_subkeys = keys[i]
             misc_check = None
         else:
             fpr, sec_keyid, uids, n_subkeys, misc_check = keys[i]
     except IndexError:
         # There are more keys.  We don't check for that.
         break
 
     # Global key flags.
     check_global(key, uids, n_subkeys)
     check_subkey(fpr, "Primary", key.subkeys[0])
     check_subkey(sec_keyid, "Secondary", key.subkeys[1])
 
     assert len(key.uids) == len(uids)
     check_uid("First", uids[0], key.uids[0])
     if len(key.uids) > 1:
       check_uid("Second", uids[1], key.uids[1])
     if len(key.uids) > 2:
       check_uid("Third", uids[2], key.uids[2])
 
     if misc_check:
         misc_check (uids[0][0], key)
 
 
 # check get_key()
 with gpg.Context() as c:
   c.get_key(support.alpha)
   c.get_key(support.alpha, secret=True)
 
   c.get_key(support.bob)
   try:
     c.get_key(support.bob, secret=True)
   except KeyError:
     pass
   else:
     assert False, "Expected KeyError"
 
   # Legacy error
   try:
     c.get_key(support.no_such_key)
   except gpg.errors.GPGMEError:
     pass
   else:
     assert False, "Expected GPGMEError"
diff --git a/lang/python/tests/t-sig-notation.py b/lang/python/tests/t-sig-notation.py
index f1342b1f..22774974 100755
--- a/lang/python/tests/t-sig-notation.py
+++ b/lang/python/tests/t-sig-notation.py
@@ -1,80 +1,78 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
 
 expected_notations = {
     "laughing@me": ("Just Squeeze Me", gpg.constants.sig.notation.HUMAN_READABLE),
     "preferred-email-encoding@pgp.com": ("pgpmime",
                                          gpg.constants.sig.notation.HUMAN_READABLE
                                          | gpg.constants.sig.notation.CRITICAL),
     None: ("http://www.gnu.org/policy/", 0),
 }
 
 # GnuPG prior to 2.1.13 did not report the critical flag correctly.
 with gpg.Context() as c:
     version = c.engine_info.version
     have_correct_sig_data = not (version.startswith("1.")
                                  or version.startswith("2.0.")
                                  or version == "2.1.1"
                                  or (version.startswith("2.1.1")
                                      and version[5] < '3'))
 
 def check_result(result):
     assert len(result.signatures) == 1, "Unexpected number of signatures"
     sig = result.signatures[0]
     assert len(sig.notations) == len(expected_notations)
 
     for r in sig.notations:
         assert not 'name_len' in dir(r)
         assert not 'value_len' in dir(r)
         assert r.name in expected_notations
         value, flags = expected_notations.pop(r.name)
 
         assert r.value == value, \
             "Expected {!r}, got {!r}".format(value, r.value)
         assert r.human_readable \
             == bool(flags & gpg.constants.sig.notation.HUMAN_READABLE)
         assert r.critical \
             == (bool(flags & gpg.constants.sig.notation.CRITICAL)
                 if have_correct_sig_data else False)
 
     assert len(expected_notations) == 0
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
-
 source = gpg.Data("Hallo Leute\n")
 signed = gpg.Data()
 
 c = gpg.Context()
 for name, (value, flags) in expected_notations.items():
     c.sig_notation_add(name, value, flags)
 
 c.op_sign(source, signed, gpg.constants.sig.mode.NORMAL)
 
 signed.seek(0, os.SEEK_SET)
 sink = gpg.Data()
 c.op_verify(signed, None, sink)
 result = c.op_verify_result()
 check_result(result)
diff --git a/lang/python/tests/t-sign.py b/lang/python/tests/t-sign.py
index 9418ed88..d3757294 100755
--- a/lang/python/tests/t-sign.py
+++ b/lang/python/tests/t-sign.py
@@ -1,121 +1,119 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import os
 import gpg
 import support
 
 def fail(msg):
     raise RuntimeError(msg)
 
 def check_result(r, typ):
     if r.invalid_signers:
         fail("Invalid signer found: {}".format(r.invalid_signers.fpr))
 
     if len(r.signatures) != 1:
         fail("Unexpected number of signatures created")
 
     signature = r.signatures[0]
     if signature.type != typ:
         fail("Wrong type of signature created")
 
     if signature.pubkey_algo != gpg.constants.pk.DSA:
         fail("Wrong pubkey algorithm reported: {}".format(
             signature.pubkey_algo))
 
     if signature.hash_algo != gpg.constants.md.SHA1:
         fail("Wrong hash algorithm reported: {}".format(
             signature.hash_algo))
 
     if signature.sig_class != 1:
         fail("Wrong signature class reported: {}".format(
             signature.sig_class))
 
     if signature.fpr != "A0FF4590BB6122EDEF6E3C542D727CC768697734":
         fail("Wrong fingerprint reported: {}".format(signature.fpr))
 
-
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 c.set_textmode(True)
 c.set_armor(True)
 
 source = gpg.Data("Hallo Leute\n")
 sink = gpg.Data()
 
 c.op_sign(source, sink, gpg.constants.sig.mode.NORMAL)
 
 result = c.op_sign_result()
 check_result(result, gpg.constants.sig.mode.NORMAL)
 support.print_data(sink)
 
 # Now a detached signature.
 source.seek(0, os.SEEK_SET)
 sink = gpg.Data()
 
 c.op_sign(source, sink, gpg.constants.sig.mode.DETACH)
 
 result = c.op_sign_result()
 check_result(result, gpg.constants.sig.mode.DETACH)
 support.print_data(sink)
 
 # And finally a cleartext signature.  */
 source.seek(0, os.SEEK_SET)
 sink = gpg.Data()
 
 c.op_sign(source, sink, gpg.constants.sig.mode.CLEAR)
 
 result = c.op_sign_result()
 check_result(result, gpg.constants.sig.mode.CLEAR)
 support.print_data(sink)
 
 # Idiomatic interface.
 with gpg.Context(armor=True, textmode=True) as c:
     message = "Hallo Leute\n".encode()
     signed, _ = c.sign(message)
     assert len(signed) > 0
     assert signed.find(b'BEGIN PGP MESSAGE') > 0, 'Message not found'
 
     signed, _ = c.sign(message, mode=gpg.constants.sig.mode.DETACH)
     assert len(signed) > 0
     assert signed.find(b'BEGIN PGP SIGNATURE') > 0, 'Signature not found'
 
     signed, _ = c.sign(message, mode=gpg.constants.sig.mode.CLEAR)
     assert len(signed) > 0
     assert signed.find(b'BEGIN PGP SIGNED MESSAGE') > 0, 'Message not found'
     assert signed.find(message) > 0, 'Message content not found'
     assert signed.find(b'BEGIN PGP SIGNATURE') > 0, 'Signature not found'
 
 with gpg.Context() as c:
     message = "Hallo Leute\n".encode()
 
     c.signers = [c.get_key(support.sign_only, True)]
     c.sign(message)
 
     c.signers = [c.get_key(support.encrypt_only, True)]
     try:
         c.sign(message)
     except gpg.errors.InvalidSigners as e:
         assert len(e.signers) == 1
         assert support.encrypt_only.endswith(e.signers[0].fpr)
     else:
         assert False, "Expected an InvalidSigners error, got none"
diff --git a/lang/python/tests/t-signers.py b/lang/python/tests/t-signers.py
index 80e797c9..5864ee5f 100755
--- a/lang/python/tests/t-signers.py
+++ b/lang/python/tests/t-signers.py
@@ -1,97 +1,95 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
 def fail(msg):
     raise RuntimeError(msg)
 
 def check_result(r, typ):
     if r.invalid_signers:
         fail("Invalid signer found: {}".format(r.invalid_signers.fpr))
 
     if len(r.signatures) != 2:
         fail("Unexpected number of signatures created")
 
     for signature in r.signatures:
         if signature.type != typ:
             fail("Wrong type of signature created")
 
         if signature.pubkey_algo != gpg.constants.pk.DSA:
             fail("Wrong pubkey algorithm reported: {}".format(
                 signature.pubkey_algo))
 
         if signature.hash_algo != gpg.constants.md.SHA1:
             fail("Wrong hash algorithm reported: {}".format(
                 signature.hash_algo))
 
         if signature.sig_class != 1:
             fail("Wrong signature class reported: got {}, want {}".format(
                 signature.sig_class, 1))
 
         if signature.fpr not in ("A0FF4590BB6122EDEF6E3C542D727CC768697734",
                                  "23FD347A419429BACCD5E72D6BC4778054ACD246"):
             fail("Wrong fingerprint reported: {}".format(signature.fpr))
 
-
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 c.set_textmode(True)
 c.set_armor(True)
 
 keys = []
 c.op_keylist_start('', True)
 keys.append(c.op_keylist_next())
 keys.append(c.op_keylist_next())
 c.op_keylist_end()
 
 c.signers_add(keys[0])
 c.signers_add(keys[1])
 
 for mode in (gpg.constants.sig.mode.NORMAL, gpg.constants.sig.mode.DETACH,
              gpg.constants.sig.mode.CLEAR):
     source = gpg.Data("Hallo Leute\n")
     sink = gpg.Data()
 
     c.op_sign(source, sink, mode)
 
     result = c.op_sign_result()
     check_result(result, mode)
     support.print_data(sink)
 
 # Idiomatic interface.
 with gpg.Context(armor=True, textmode=True, signers=keys) as c:
     message = "Hallo Leute\n".encode()
     signed, result = c.sign(message)
     check_result(result, gpg.constants.sig.mode.NORMAL)
     assert signed.find(b'BEGIN PGP MESSAGE') > 0, 'Message not found'
 
     signed, result = c.sign(message, mode=gpg.constants.sig.mode.DETACH)
     check_result(result, gpg.constants.sig.mode.DETACH)
     assert signed.find(b'BEGIN PGP SIGNATURE') > 0, 'Signature not found'
 
     signed, result = c.sign(message, mode=gpg.constants.sig.mode.CLEAR)
     check_result(result, gpg.constants.sig.mode.CLEAR)
     assert signed.find(b'BEGIN PGP SIGNED MESSAGE') > 0, 'Message not found'
     assert signed.find(message) > 0, 'Message content not found'
     assert signed.find(b'BEGIN PGP SIGNATURE') > 0, 'Signature not found'
diff --git a/lang/python/tests/t-trustlist.py b/lang/python/tests/t-trustlist.py
index 8c5e2143..85865965 100755
--- a/lang/python/tests/t-trustlist.py
+++ b/lang/python/tests/t-trustlist.py
@@ -1,43 +1,42 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import gpg
 import support
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 
 def dump_item(item):
     print("l={} k={} t={} o={} v={} u={}".format(
         item.level, item.keyid, item.type, item.owner_trust,
         item.validity, item.name))
 
 c.op_trustlist_start("alice", 0)
 while True:
     item = c.op_trustlist_next()
     if not item:
         break
     dump_item(item)
 c.op_trustlist_end()
 
 for item in c.op_trustlist_all("alice", 0):
     dump_item(item)
diff --git a/lang/python/tests/t-verify.py b/lang/python/tests/t-verify.py
index f18e1ddc..03476382 100755
--- a/lang/python/tests/t-verify.py
+++ b/lang/python/tests/t-verify.py
@@ -1,194 +1,192 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import sys
 import os
 import gpg
 import support
 
 test_text1 = b"Just GNU it!\n"
 test_text1f= b"Just GNU it?\n"
 test_sig1 = b"""-----BEGIN PGP SIGNATURE-----
 
 iN0EABECAJ0FAjoS+i9FFIAAAAAAAwA5YmFyw7bDpMO8w58gZGFzIHdhcmVuIFVt
 bGF1dGUgdW5kIGpldHp0IGVpbiBwcm96ZW50JS1aZWljaGVuNRSAAAAAAAgAJGZv
 b2Jhci4xdGhpcyBpcyBhIG5vdGF0aW9uIGRhdGEgd2l0aCAyIGxpbmVzGhpodHRw
 Oi8vd3d3Lmd1Lm9yZy9wb2xpY3kvAAoJEC1yfMdoaXc0JBIAoIiLlUsvpMDOyGEc
 dADGKXF/Hcb+AKCJWPphZCphduxSvrzH0hgzHdeQaA==
 =nts1
 -----END PGP SIGNATURE-----
 """
 
 test_sig2 = b"""-----BEGIN PGP MESSAGE-----
 
 owGbwMvMwCSoW1RzPCOz3IRxjXQSR0lqcYleSUWJTZOvjVdpcYmCu1+oQmaJIleH
 GwuDIBMDGysTSIqBi1MApi+nlGGuwDeHao53HBr+FoVGP3xX+kvuu9fCMJvl6IOf
 y1kvP4y+8D5a11ang0udywsA
 =Crq6
 -----END PGP MESSAGE-----
 """
 
 # A message with a prepended but unsigned plaintext packet.
 double_plaintext_sig = b"""-----BEGIN PGP MESSAGE-----
 
 rDRiCmZvb2Jhci50eHRF4pxNVGhpcyBpcyBteSBzbmVha3kgcGxhaW50ZXh0IG1l
 c3NhZ2UKowGbwMvMwCSoW1RzPCOz3IRxTWISa6JebnG666MFD1wzSzJSixQ81XMV
 UlITUxTyixRyKxXKE0uSMxQyEosVikvyCwpSU/S4FNCArq6Ce1F+aXJGvoJvYlGF
 erFCTmJxiUJ5flFKMVeHGwuDIBMDGysTyA4GLk4BmO036xgWzMgzt9V85jCtfDFn
 UqVooWlGXHwNw/xg/fVzt9VNbtjtJ/fhUqYo0/LyCGEA
 =6+AK
 -----END PGP MESSAGE-----
 """
 
 def check_result(result, summary, validity, fpr, status, notation):
     assert len(result.signatures) == 1, "Unexpected number of signatures"
     sig = result.signatures[0]
     assert sig.summary == summary, \
         "Unexpected signature summary: {}, want: {}".format(sig.summary,
                                                             summary)
     assert sig.fpr == fpr
     assert gpg.errors.GPGMEError(sig.status).getcode() == status
 
     if notation:
         expected_notations = {
             "bar": (b"\xc3\xb6\xc3\xa4\xc3\xbc\xc3\x9f" +
                     b" das waren Umlaute und jetzt ein prozent%-Zeichen"
                     if sys.version_info[0] < 3 else
                     b"\xc3\xb6\xc3\xa4\xc3\xbc\xc3\x9f".decode() +
                     " das waren Umlaute und jetzt ein prozent%-Zeichen"),
             "foobar.1":  "this is a notation data with 2 lines",
             None: "http://www.gu.org/policy/",
         }
         assert len(sig.notations) == len(expected_notations)
 
         for r in sig.notations:
             assert not 'name_len' in dir(r)
             assert not 'value_len' in dir(r)
             assert r.name in expected_notations
             assert r.value == expected_notations[r.name], \
                 "Expected {!r}, got {!r}".format(expected_notations[r.name],
                                                  r.value)
             expected_notations.pop(r.name)
 
         assert len(expected_notations) == 0
 
     assert not sig.wrong_key_usage
     assert sig.validity == validity, \
         "Unexpected signature validity: {}, want: {}".format(
             sig.validity, validity)
     assert gpg.errors.GPGMEError(sig.validity_reason).getcode() == gpg.errors.NO_ERROR
 
-
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 c.set_armor(True)
 
 # Checking a valid message.
 text = gpg.Data(test_text1)
 sig = gpg.Data(test_sig1)
 c.op_verify(sig, text, None)
 result = c.op_verify_result()
 check_result(result, gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
              gpg.constants.validity.FULL,
              "A0FF4590BB6122EDEF6E3C542D727CC768697734",
              gpg.errors.NO_ERROR, True)
 
 
 # Checking a manipulated message.
 text = gpg.Data(test_text1f)
 sig.seek(0, os.SEEK_SET)
 c.op_verify(sig, text, None)
 result = c.op_verify_result()
 check_result(result, gpg.constants.sigsum.RED, gpg.constants.validity.UNKNOWN,
              "2D727CC768697734", gpg.errors.BAD_SIGNATURE, False)
 
 # Checking a normal signature.
 text = gpg.Data()
 sig = gpg.Data(test_sig2)
 c.op_verify(sig, None, text)
 result = c.op_verify_result()
 check_result(result, gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
              gpg.constants.validity.FULL,
              "A0FF4590BB6122EDEF6E3C542D727CC768697734",
              gpg.errors.NO_ERROR, False)
 
 # Checking an invalid message.
 text = gpg.Data()
 sig = gpg.Data(double_plaintext_sig)
 try:
     c.op_verify(sig, None, text)
 except Exception as e:
     assert type(e) == gpg.errors.GPGMEError
     assert e.getcode() == gpg.errors.BAD_DATA
 else:
     assert False, "Expected an error but got none."
 
 
 # Idiomatic interface.
 with gpg.Context(armor=True) as c:
     # Checking a valid message.
     _, result = c.verify(test_text1, test_sig1)
     check_result(result, gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
                  gpg.constants.validity.FULL,
                  "A0FF4590BB6122EDEF6E3C542D727CC768697734",
                  gpg.errors.NO_ERROR, True)
 
     # Checking a manipulated message.
     try:
         c.verify(test_text1f, test_sig1)
     except gpg.errors.BadSignatures as e:
         check_result(e.result, gpg.constants.sigsum.RED,
                      gpg.constants.validity.UNKNOWN,
                      "2D727CC768697734", gpg.errors.BAD_SIGNATURE, False)
     else:
         assert False, "Expected an error but got none."
 
     # Checking a normal signature.
     sig = gpg.Data(test_sig2)
     data, result = c.verify(test_sig2)
     check_result(result, gpg.constants.sigsum.VALID | gpg.constants.sigsum.GREEN,
                  gpg.constants.validity.FULL,
                  "A0FF4590BB6122EDEF6E3C542D727CC768697734",
                  gpg.errors.NO_ERROR, False)
     assert data == test_text1
 
     # Checking an invalid message.
     try:
         c.verify(double_plaintext_sig)
     except gpg.errors.GPGMEError as e:
         assert e.getcode() == gpg.errors.BAD_DATA
     else:
         assert False, "Expected an error but got none."
 
     alpha = c.get_key("A0FF4590BB6122EDEF6E3C542D727CC768697734", False)
     bob = c.get_key("D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", False)
 
     # Checking a valid message.
     c.verify(test_text1, test_sig1, verify=[alpha])
 
     try:
         c.verify(test_text1, test_sig1, verify=[alpha, bob])
     except gpg.errors.MissingSignatures as e:
         assert len(e.missing) == 1
         assert e.missing[0] == bob
     else:
         assert False, "Expected an error, got none"
diff --git a/lang/python/tests/t-wait.py b/lang/python/tests/t-wait.py
index b1f2043f..0c403fa6 100755
--- a/lang/python/tests/t-wait.py
+++ b/lang/python/tests/t-wait.py
@@ -1,45 +1,44 @@
 #!/usr/bin/env python
 
 # Copyright (C) 2016 g10 Code GmbH
 #
 # This file is part of GPGME.
 #
 # GPGME is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # GPGME is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 # or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
 # Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public
 # License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 from __future__ import absolute_import, print_function, unicode_literals
 del absolute_import, print_function, unicode_literals
 
 import time
 import gpg
 import support
 
-support.init_gpgme(gpg.constants.protocol.OpenPGP)
 c = gpg.Context()
 c.set_armor(True)
 
 # Checking a message without a signature.
 sig = gpg.Data("foo\n")
 text = gpg.Data()
 c.op_verify_start(sig, None, text)
 
 try:
     while True:
         err = c.wait(False)
         if err:
             break
         time.sleep(0.1)
 except Exception as e:
     assert e.getcode() == gpg.errors.NO_DATA
 else:
     assert False, "Expected an error, got none"