remove multibackend (#3555)

* remove multibackend

* oops

* goodbye pointless tests

10 files changed, 10 insertions, 1280 deletions

diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 176ad3c0..c48b709f 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -24,6 +24,7 @@ Changelog
   This behavior was based on a poor reading of the RFC, unknown critical
   extensions only need to be rejected on certificate verification.
 * The CommonCrypto backend has been removed.
+* MultiBackend has been removed.
 
 
 1.8.1 - 2017-03-10
@@ -723,15 +724,13 @@ Changelog
 0.5.2 - 2014-07-09
 ~~~~~~~~~~~~~~~~~~
 
-* Add ``TraditionalOpenSSLSerializationBackend`` support to
-  :doc:`/hazmat/backends/multibackend`.
+* Add ``TraditionalOpenSSLSerializationBackend`` support to ``multibackend``.
 * Fix compilation error on OS X 10.8 (Mountain Lion).
 
 0.5.1 - 2014-07-07
 ~~~~~~~~~~~~~~~~~~
 
-* Add ``PKCS8SerializationBackend`` support to
-  :doc:`/hazmat/backends/multibackend`.
+* Add ``PKCS8SerializationBackend`` support to ``multibackend``.
 
 0.5 - 2014-07-07
 ~~~~~~~~~~~~~~~~
@@ -844,7 +843,7 @@ Changelog
   available, such as CentOS.
 * Added :class:`~cryptography.hazmat.primitives.kdf.pbkdf2.PBKDF2HMAC`.
 * Added :class:`~cryptography.hazmat.primitives.kdf.hkdf.HKDF`.
-* Added :doc:`/hazmat/backends/multibackend`.
+* Added ``multibackend``.
 * Set default random for the :doc:`/hazmat/backends/openssl` to the OS
   random engine.
 * Added :class:`~cryptography.hazmat.primitives.ciphers.algorithms.CAST5`
diff --git a/docs/hazmat/backends/index.rst b/docs/hazmat/backends/index.rst
index 56d18901..a8a1ff30 100644
--- a/docs/hazmat/backends/index.rst
+++ b/docs/hazmat/backends/index.rst
@@ -8,15 +8,11 @@ Getting a backend
 
 .. currentmodule:: cryptography.hazmat.backends
 
-``cryptography`` aims to support multiple backends to ensure it can provide
-the widest number of supported cryptographic algorithms as well as supporting
-platform specific implementations.
+``cryptography`` was originally designed to support multiple backends, but
+this design has been deprecated.
 
 You can get the default backend by calling :func:`~default_backend`.
 
-The default backend will change over time as we implement new backends and
-the libraries we use in those backends changes.
-
 
 .. function:: default_backend()
 
@@ -31,5 +27,4 @@ Individual backends
     :maxdepth: 1
 
     openssl
-    multibackend
     interfaces
diff --git a/docs/hazmat/backends/multibackend.rst b/docs/hazmat/backends/multibackend.rst
deleted file mode 100644
index 0aae04a7..00000000
--- a/docs/hazmat/backends/multibackend.rst
+++ /dev/null
@@ -1,45 +0,0 @@
-.. hazmat::
-
-MultiBackend
-============
-
-.. currentmodule:: cryptography.hazmat.backends.multibackend
-
-.. class:: MultiBackend(backends)
-
-    .. versionadded:: 0.2
-
-    This class allows you to combine multiple backends into a single backend
-    that offers the combined features of all of its constituents.
-
-    .. testsetup::
-
-        from cryptography import utils
-        from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
-        from cryptography.hazmat.backends.interfaces import HashBackend
-        from cryptography.hazmat.backends.openssl.backend import backend as backend2
-
-        @utils.register_interface(HashBackend)
-        class DummyHashBackend(object):
-            def hash_supported(self, algorithm):
-                return False
-
-            def create_hash_ctx(self, algorithm):
-                raise UnsupportedAlgorithm("", _Reasons.UNSUPPORTED_HASH)
-
-        backend1 = DummyHashBackend()
-
-    .. doctest::
-
-        >>> from cryptography.hazmat.backends.multibackend import MultiBackend
-        >>> from cryptography.hazmat.primitives import hashes
-        >>> backend1.hash_supported(hashes.SHA256())
-        False
-        >>> backend2.hash_supported(hashes.SHA256())
-        True
-        >>> multi_backend = MultiBackend([backend1, backend2])
-        >>> multi_backend.hash_supported(hashes.SHA256())
-        True
-
-    :param backends: A ``list`` of backend objects. Backends are checked for
-                     feature support in the order they appear in this list.
diff --git a/src/cryptography/hazmat/backends/__init__.py b/src/cryptography/hazmat/backends/__init__.py
index d90d27d8..565bde78 100644
--- a/src/cryptography/hazmat/backends/__init__.py
+++ b/src/cryptography/hazmat/backends/__init__.py
@@ -4,22 +4,6 @@
 
 from __future__ import absolute_import, division, print_function
 
-from cryptography.hazmat.backends.multibackend import MultiBackend
-
-
-_available_backends_list = None
-
-
-def _available_backends():
-    global _available_backends_list
-
-    if _available_backends_list is None:
-        from cryptography.hazmat.backends.openssl.backend import (
-            backend as be_ossl
-        )
-        _available_backends_list = [be_ossl]
-    return _available_backends_list
-
 
 _default_backend = None
 
@@ -28,6 +12,7 @@ def default_backend():
     global _default_backend
 
     if _default_backend is None:
-        _default_backend = MultiBackend(_available_backends())
+        from cryptography.hazmat.backends.openssl.backend import backend
+        _default_backend = backend
 
     return _default_backend
diff --git a/src/cryptography/hazmat/backends/multibackend.py b/src/cryptography/hazmat/backends/multibackend.py
deleted file mode 100644
index bb30c661..00000000
--- a/src/cryptography/hazmat/backends/multibackend.py
+++ /dev/null
@@ -1,514 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-from __future__ import absolute_import, division, print_function
-
-from cryptography import utils
-from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
-from cryptography.hazmat.backends.interfaces import (
-    CMACBackend, CipherBackend, DERSerializationBackend, DHBackend,
-    DSABackend, EllipticCurveBackend, HMACBackend, HashBackend,
-    PBKDF2HMACBackend, PEMSerializationBackend, RSABackend, ScryptBackend,
-    X509Backend
-)
-
-
-@utils.register_interface(CMACBackend)
-@utils.register_interface(CipherBackend)
-@utils.register_interface(DERSerializationBackend)
-@utils.register_interface(HashBackend)
-@utils.register_interface(HMACBackend)
-@utils.register_interface(PBKDF2HMACBackend)
-@utils.register_interface(RSABackend)
-@utils.register_interface(DSABackend)
-@utils.register_interface(EllipticCurveBackend)
-@utils.register_interface(PEMSerializationBackend)
-@utils.register_interface(X509Backend)
-@utils.register_interface(DHBackend)
-@utils.register_interface(ScryptBackend)
-class MultiBackend(object):
-    name = "multibackend"
-
-    def __init__(self, backends):
-        if len(backends) == 0:
-            raise ValueError(
-                "Multibackend cannot be initialized with no backends. If you "
-                "are seeing this error when trying to use default_backend() "
-                "please try uninstalling and reinstalling cryptography."
-            )
-
-        self._backends = backends
-
-    def _filtered_backends(self, interface):
-        for b in self._backends:
-            if isinstance(b, interface):
-                yield b
-
-    def cipher_supported(self, cipher, mode):
-        return any(
-            b.cipher_supported(cipher, mode)
-            for b in self._filtered_backends(CipherBackend)
-        )
-
-    def create_symmetric_encryption_ctx(self, cipher, mode):
-        for b in self._filtered_backends(CipherBackend):
-            try:
-                return b.create_symmetric_encryption_ctx(cipher, mode)
-            except UnsupportedAlgorithm:
-                pass
-        raise UnsupportedAlgorithm(
-            "cipher {0} in {1} mode is not supported by this backend.".format(
-                cipher.name, mode.name if mode else mode),
-            _Reasons.UNSUPPORTED_CIPHER
-        )
-
-    def create_symmetric_decryption_ctx(self, cipher, mode):
-        for b in self._filtered_backends(CipherBackend):
-            try:
-                return b.create_symmetric_decryption_ctx(cipher, mode)
-            except UnsupportedAlgorithm:
-                pass
-        raise UnsupportedAlgorithm(
-            "cipher {0} in {1} mode is not supported by this backend.".format(
-                cipher.name, mode.name if mode else mode),
-            _Reasons.UNSUPPORTED_CIPHER
-        )
-
-    def hash_supported(self, algorithm):
-        return any(
-            b.hash_supported(algorithm)
-            for b in self._filtered_backends(HashBackend)
-        )
-
-    def create_hash_ctx(self, algorithm):
-        for b in self._filtered_backends(HashBackend):
-            try:
-                return b.create_hash_ctx(algorithm)
-            except UnsupportedAlgorithm:
-                pass
-        raise UnsupportedAlgorithm(
-            "{0} is not a supported hash on this backend.".format(
-                algorithm.name),
-            _Reasons.UNSUPPORTED_HASH
-        )
-
-    def hmac_supported(self, algorithm):
-        return any(
-            b.hmac_supported(algorithm)
-            for b in self._filtered_backends(HMACBackend)
-        )
-
-    def create_hmac_ctx(self, key, algorithm):
-        for b in self._filtered_backends(HMACBackend):
-            try:
-                return b.create_hmac_ctx(key, algorithm)
-            except UnsupportedAlgorithm:
-                pass
-        raise UnsupportedAlgorithm(
-            "{0} is not a supported hash on this backend.".format(
-                algorithm.name),
-            _Reasons.UNSUPPORTED_HASH
-        )
-
-    def pbkdf2_hmac_supported(self, algorithm):
-        return any(
-            b.pbkdf2_hmac_supported(algorithm)
-            for b in self._filtered_backends(PBKDF2HMACBackend)
-        )
-
-    def derive_pbkdf2_hmac(self, algorithm, length, salt, iterations,
-                           key_material):
-        for b in self._filtered_backends(PBKDF2HMACBackend):
-            try:
-                return b.derive_pbkdf2_hmac(
-                    algorithm, length, salt, iterations, key_material
-                )
-            except UnsupportedAlgorithm:
-                pass
-        raise UnsupportedAlgorithm(
-            "{0} is not a supported hash on this backend.".format(
-                algorithm.name),
-            _Reasons.UNSUPPORTED_HASH
-        )
-
-    def generate_rsa_private_key(self, public_exponent, key_size):
-        for b in self._filtered_backends(RSABackend):
-            return b.generate_rsa_private_key(public_exponent, key_size)
-        raise UnsupportedAlgorithm("RSA is not supported by the backend.",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def generate_rsa_parameters_supported(self, public_exponent, key_size):
-        for b in self._filtered_backends(RSABackend):
-            return b.generate_rsa_parameters_supported(
-                public_exponent, key_size
-            )
-        raise UnsupportedAlgorithm("RSA is not supported by the backend.",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def rsa_padding_supported(self, padding):
-        for b in self._filtered_backends(RSABackend):
-            return b.rsa_padding_supported(padding)
-        raise UnsupportedAlgorithm("RSA is not supported by the backend.",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def load_rsa_private_numbers(self, numbers):
-        for b in self._filtered_backends(RSABackend):
-            return b.load_rsa_private_numbers(numbers)
-
-        raise UnsupportedAlgorithm("RSA is not supported by the backend",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def load_rsa_public_numbers(self, numbers):
-        for b in self._filtered_backends(RSABackend):
-            return b.load_rsa_public_numbers(numbers)
-
-        raise UnsupportedAlgorithm("RSA is not supported by the backend",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def generate_dsa_parameters(self, key_size):
-        for b in self._filtered_backends(DSABackend):
-            return b.generate_dsa_parameters(key_size)
-        raise UnsupportedAlgorithm("DSA is not supported by the backend.",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def generate_dsa_private_key(self, parameters):
-        for b in self._filtered_backends(DSABackend):
-            return b.generate_dsa_private_key(parameters)
-        raise UnsupportedAlgorithm("DSA is not supported by the backend.",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def generate_dsa_private_key_and_parameters(self, key_size):
-        for b in self._filtered_backends(DSABackend):
-            return b.generate_dsa_private_key_and_parameters(key_size)
-        raise UnsupportedAlgorithm("DSA is not supported by the backend.",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def dsa_hash_supported(self, algorithm):
-        for b in self._filtered_backends(DSABackend):
-            return b.dsa_hash_supported(algorithm)
-        raise UnsupportedAlgorithm("DSA is not supported by the backend.",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def dsa_parameters_supported(self, p, q, g):
-        for b in self._filtered_backends(DSABackend):
-            return b.dsa_parameters_supported(p, q, g)
-        raise UnsupportedAlgorithm("DSA is not supported by the backend.",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def load_dsa_public_numbers(self, numbers):
-        for b in self._filtered_backends(DSABackend):
-            return b.load_dsa_public_numbers(numbers)
-        raise UnsupportedAlgorithm("DSA is not supported by the backend.",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def load_dsa_private_numbers(self, numbers):
-        for b in self._filtered_backends(DSABackend):
-            return b.load_dsa_private_numbers(numbers)
-        raise UnsupportedAlgorithm("DSA is not supported by the backend.",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def load_dsa_parameter_numbers(self, numbers):
-        for b in self._filtered_backends(DSABackend):
-            return b.load_dsa_parameter_numbers(numbers)
-        raise UnsupportedAlgorithm("DSA is not supported by the backend.",
-                                   _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM)
-
-    def cmac_algorithm_supported(self, algorithm):
-        return any(
-            b.cmac_algorithm_supported(algorithm)
-            for b in self._filtered_backends(CMACBackend)
-        )
-
-    def create_cmac_ctx(self, algorithm):
-        for b in self._filtered_backends(CMACBackend):
-            try:
-                return b.create_cmac_ctx(algorithm)
-            except UnsupportedAlgorithm:
-                pass
-        raise UnsupportedAlgorithm("This backend does not support CMAC.",
-                                   _Reasons.UNSUPPORTED_CIPHER)
-
-    def elliptic_curve_supported(self, curve):
-        return any(
-            b.elliptic_curve_supported(curve)
-            for b in self._filtered_backends(EllipticCurveBackend)
-        )
-
-    def elliptic_curve_signature_algorithm_supported(
-        self, signature_algorithm, curve
-    ):
-        return any(
-            b.elliptic_curve_signature_algorithm_supported(
-                signature_algorithm, curve
-            )
-            for b in self._filtered_backends(EllipticCurveBackend)
-        )
-
-    def generate_elliptic_curve_private_key(self, curve):
-        for b in self._filtered_backends(EllipticCurveBackend):
-            try:
-                return b.generate_elliptic_curve_private_key(curve)
-            except UnsupportedAlgorithm:
-                continue
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support this elliptic curve.",
-            _Reasons.UNSUPPORTED_ELLIPTIC_CURVE
-        )
-
-    def load_elliptic_curve_private_numbers(self, numbers):
-        for b in self._filtered_backends(EllipticCurveBackend):
-            try:
-                return b.load_elliptic_curve_private_numbers(numbers)
-            except UnsupportedAlgorithm:
-                continue
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support this elliptic curve.",
-            _Reasons.UNSUPPORTED_ELLIPTIC_CURVE
-        )
-
-    def load_elliptic_curve_public_numbers(self, numbers):
-        for b in self._filtered_backends(EllipticCurveBackend):
-            try:
-                return b.load_elliptic_curve_public_numbers(numbers)
-            except UnsupportedAlgorithm:
-                continue
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support this elliptic curve.",
-            _Reasons.UNSUPPORTED_ELLIPTIC_CURVE
-        )
-
-    def derive_elliptic_curve_private_key(self, private_value, curve):
-        for b in self._filtered_backends(EllipticCurveBackend):
-            try:
-                return b.derive_elliptic_curve_private_key(private_value,
-                                                           curve)
-            except UnsupportedAlgorithm:
-                continue
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support this elliptic curve.",
-            _Reasons.UNSUPPORTED_ELLIPTIC_CURVE
-        )
-
-    def elliptic_curve_exchange_algorithm_supported(self, algorithm, curve):
-        return any(
-            b.elliptic_curve_exchange_algorithm_supported(algorithm, curve)
-            for b in self._filtered_backends(EllipticCurveBackend)
-        )
-
-    def load_pem_private_key(self, data, password):
-        for b in self._filtered_backends(PEMSerializationBackend):
-            return b.load_pem_private_key(data, password)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support this key serialization.",
-            _Reasons.UNSUPPORTED_SERIALIZATION
-        )
-
-    def load_pem_public_key(self, data):
-        for b in self._filtered_backends(PEMSerializationBackend):
-            return b.load_pem_public_key(data)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support this key serialization.",
-            _Reasons.UNSUPPORTED_SERIALIZATION
-        )
-
-    def load_der_private_key(self, data, password):
-        for b in self._filtered_backends(DERSerializationBackend):
-            return b.load_der_private_key(data, password)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support this key serialization.",
-            _Reasons.UNSUPPORTED_SERIALIZATION
-        )
-
-    def load_der_public_key(self, data):
-        for b in self._filtered_backends(DERSerializationBackend):
-            return b.load_der_public_key(data)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support this key serialization.",
-            _Reasons.UNSUPPORTED_SERIALIZATION
-        )
-
-    def load_pem_x509_certificate(self, data):
-        for b in self._filtered_backends(X509Backend):
-            return b.load_pem_x509_certificate(data)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support X.509.",
-            _Reasons.UNSUPPORTED_X509
-        )
-
-    def load_der_x509_certificate(self, data):
-        for b in self._filtered_backends(X509Backend):
-            return b.load_der_x509_certificate(data)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support X.509.",
-            _Reasons.UNSUPPORTED_X509
-        )
-
-    def load_pem_x509_crl(self, data):
-        for b in self._filtered_backends(X509Backend):
-            return b.load_pem_x509_crl(data)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support X.509.",
-            _Reasons.UNSUPPORTED_X509
-        )
-
-    def load_der_x509_crl(self, data):
-        for b in self._filtered_backends(X509Backend):
-            return b.load_der_x509_crl(data)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support X.509.",
-            _Reasons.UNSUPPORTED_X509
-        )
-
-    def load_der_x509_csr(self, data):
-        for b in self._filtered_backends(X509Backend):
-            return b.load_der_x509_csr(data)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support X.509.",
-            _Reasons.UNSUPPORTED_X509
-        )
-
-    def load_pem_x509_csr(self, data):
-        for b in self._filtered_backends(X509Backend):
-            return b.load_pem_x509_csr(data)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support X.509.",
-            _Reasons.UNSUPPORTED_X509
-        )
-
-    def create_x509_csr(self, builder, private_key, algorithm):
-        for b in self._filtered_backends(X509Backend):
-            return b.create_x509_csr(builder, private_key, algorithm)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support X.509.",
-            _Reasons.UNSUPPORTED_X509
-        )
-
-    def create_x509_certificate(self, builder, private_key, algorithm):
-        for b in self._filtered_backends(X509Backend):
-            return b.create_x509_certificate(builder, private_key, algorithm)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support X.509.",
-            _Reasons.UNSUPPORTED_X509
-        )
-
-    def create_x509_crl(self, builder, private_key, algorithm):
-        for b in self._filtered_backends(X509Backend):
-            return b.create_x509_crl(builder, private_key, algorithm)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support X.509.",
-            _Reasons.UNSUPPORTED_X509
-        )
-
-    def create_x509_revoked_certificate(self, builder):
-        for b in self._filtered_backends(X509Backend):
-            return b.create_x509_revoked_certificate(builder)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support X.509.",
-            _Reasons.UNSUPPORTED_X509
-        )
-
-    def generate_dh_parameters(self, generator, key_size):
-        for b in self._filtered_backends(DHBackend):
-            return b.generate_dh_parameters(generator, key_size)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support Diffie-Hellman",
-            _Reasons.UNSUPPORTED_DIFFIE_HELLMAN
-        )
-
-    def load_dh_parameter_numbers(self, numbers):
-        for b in self._filtered_backends(DHBackend):
-            return b.load_dh_parameter_numbers(numbers)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support Diffie-Hellman",
-            _Reasons.UNSUPPORTED_DIFFIE_HELLMAN
-        )
-
-    def generate_dh_private_key(self, parameters):
-        for b in self._filtered_backends(DHBackend):
-            return b.generate_dh_private_key(parameters)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support Diffie-Hellman",
-            _Reasons.UNSUPPORTED_DIFFIE_HELLMAN
-        )
-
-    def load_dh_private_numbers(self, numbers):
-        for b in self._filtered_backends(DHBackend):
-            return b.load_dh_private_numbers(numbers)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support Diffie-Hellman",
-            _Reasons.UNSUPPORTED_DIFFIE_HELLMAN
-        )
-
-    def load_dh_public_numbers(self, numbers):
-        for b in self._filtered_backends(DHBackend):
-            return b.load_dh_public_numbers(numbers)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support Diffie-Hellman",
-            _Reasons.UNSUPPORTED_DIFFIE_HELLMAN
-        )
-
-    def generate_dh_private_key_and_parameters(self, generator, key_size):
-        for b in self._filtered_backends(DHBackend):
-            return b.generate_dh_private_key_and_parameters(generator,
-                                                            key_size)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support Diffie-Hellman",
-            _Reasons.UNSUPPORTED_DIFFIE_HELLMAN
-        )
-
-    def dh_parameters_supported(self, p, g, q=None):
-        for b in self._filtered_backends(DHBackend):
-            return b.dh_parameters_supported(p, g, q)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support Diffie-Hellman",
-            _Reasons.UNSUPPORTED_DIFFIE_HELLMAN
-        )
-
-    def dh_x942_serialization_supported(self):
-        for b in self._filtered_backends(DHBackend):
-            return b.dh_x942_serialization_supported()
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support Diffie-Hellman",
-            _Reasons.UNSUPPORTED_DIFFIE_HELLMAN
-        )
-
-    def x509_name_bytes(self, name):
-        for b in self._filtered_backends(X509Backend):
-            return b.x509_name_bytes(name)
-
-        raise UnsupportedAlgorithm(
-            "This backend does not support X.509.",
-            _Reasons.UNSUPPORTED_X509
-        )
-
-    def derive_scrypt(self, key_material, salt, length, n, r, p):
-        for b in self._filtered_backends(ScryptBackend):
-            return b.derive_scrypt(key_material, salt, length, n, r, p)
-        raise UnsupportedAlgorithm("This backend does not support scrypt.")
diff --git a/tests/conftest.py b/tests/conftest.py
index 1952ec16..8605f3ae 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -6,7 +6,6 @@ from __future__ import absolute_import, division, print_function
 
 import pytest
 
-from cryptography.hazmat.backends import _available_backends
 from cryptography.hazmat.backends.openssl import backend as openssl_backend
 
 from .utils import check_backend_support, select_backends, skip_if_empty
@@ -19,7 +18,7 @@ def pytest_report_header(config):
 def pytest_generate_tests(metafunc):
     if "backend" in metafunc.fixturenames:
         names = metafunc.config.getoption("--backend")
-        selected_backends = select_backends(names, _available_backends())
+        selected_backends = select_backends(names, [openssl_backend])
 
         filtered_backends = []
         required = metafunc.function.requires_backend_interface
diff --git a/tests/hazmat/backends/test_multibackend.py b/tests/hazmat/backends/test_multibackend.py
deleted file mode 100644
index 10c9dc97..00000000
--- a/tests/hazmat/backends/test_multibackend.py
+++ /dev/null
@@ -1,654 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-from __future__ import absolute_import, division, print_function
-
-import pytest
-
-from cryptography import utils
-from cryptography.exceptions import (
-    UnsupportedAlgorithm, _Reasons
-)
-from cryptography.hazmat.backends.interfaces import (
-    CMACBackend, CipherBackend, DERSerializationBackend, DHBackend,
-    DSABackend, EllipticCurveBackend, HMACBackend, HashBackend,
-    PBKDF2HMACBackend, PEMSerializationBackend, RSABackend, ScryptBackend,
-    X509Backend
-)
-from cryptography.hazmat.backends.multibackend import MultiBackend
-from cryptography.hazmat.primitives import cmac, hashes, hmac
-from cryptography.hazmat.primitives.asymmetric import ec, padding
-from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-
-from ...utils import raises_unsupported_algorithm
-
-
-class DummyBackend(object):
-    pass
-
-
-@utils.register_interface(ec.EllipticCurve)
-class DummyCurve(object):
-    name = "dummy-curve"
-    key_size = 1
-
-
-@utils.register_interface(CipherBackend)
-class DummyCipherBackend(object):
-    def __init__(self, supported_ciphers):
-        self._ciphers = supported_ciphers
-
-    def cipher_supported(self, cipher, mode):
-        return (type(cipher), type(mode)) in self._ciphers
-
-    def create_symmetric_encryption_ctx(self, cipher, mode):
-        if not self.cipher_supported(cipher, mode):
-            raise UnsupportedAlgorithm("", _Reasons.UNSUPPORTED_CIPHER)
-
-    def create_symmetric_decryption_ctx(self, cipher, mode):
-        if not self.cipher_supported(cipher, mode):
-            raise UnsupportedAlgorithm("", _Reasons.UNSUPPORTED_CIPHER)
-
-
-@utils.register_interface(HashBackend)
-class DummyHashBackend(object):
-    def __init__(self, supported_algorithms):
-        self._algorithms = supported_algorithms
-
-    def hash_supported(self, algorithm):
-        return type(algorithm) in self._algorithms
-
-    def create_hash_ctx(self, algorithm):
-        if not self.hash_supported(algorithm):
-            raise UnsupportedAlgorithm("", _Reasons.UNSUPPORTED_HASH)
-
-
-@utils.register_interface(HMACBackend)
-class DummyHMACBackend(object):
-    def __init__(self, supported_algorithms):
-        self._algorithms = supported_algorithms
-
-    def hmac_supported(self, algorithm):
-        return type(algorithm) in self._algorithms
-
-    def create_hmac_ctx(self, key, algorithm):
-        if not self.hmac_supported(algorithm):
-            raise UnsupportedAlgorithm("", _Reasons.UNSUPPORTED_HASH)
-
-
-@utils.register_interface(PBKDF2HMACBackend)
-class DummyPBKDF2HMACBackend(object):
-    def __init__(self, supported_algorithms):
-        self._algorithms = supported_algorithms
-
-    def pbkdf2_hmac_supported(self, algorithm):
-        return type(algorithm) in self._algorithms
-
-    def derive_pbkdf2_hmac(self, algorithm, length, salt, iterations,
-                           key_material):
-        if not self.pbkdf2_hmac_supported(algorithm):
-            raise UnsupportedAlgorithm("", _Reasons.UNSUPPORTED_HASH)
-
-
-@utils.register_interface(RSABackend)
-class DummyRSABackend(object):
-    def generate_rsa_private_key(self, public_exponent, key_size):
-        pass
-
-    def rsa_padding_supported(self, padding):
-        pass
-
-    def generate_rsa_parameters_supported(self, public_exponent, key_size):
-        pass
-
-    def load_rsa_private_numbers(self, numbers):
-        pass
-
-    def load_rsa_public_numbers(self, numbers):
-        pass
-
-
-@utils.register_interface(DSABackend)
-class DummyDSABackend(object):
-    def generate_dsa_parameters(self, key_size):
-        pass
-
-    def generate_dsa_private_key(self, parameters):
-        pass
-
-    def generate_dsa_private_key_and_parameters(self, key_size):
-        pass
-
-    def dsa_hash_supported(self, algorithm):
-        pass
-
-    def dsa_parameters_supported(self, p, q, g):
-        pass
-
-    def load_dsa_private_numbers(self, numbers):
-        pass
-
-    def load_dsa_public_numbers(self, numbers):
-        pass
-
-    def load_dsa_parameter_numbers(self, numbers):
-        pass
-
-
-@utils.register_interface(CMACBackend)
-class DummyCMACBackend(object):
-    def __init__(self, supported_algorithms):
-        self._algorithms = supported_algorithms
-
-    def cmac_algorithm_supported(self, algorithm):
-        return type(algorithm) in self._algorithms
-
-    def create_cmac_ctx(self, algorithm):
-        if not self.cmac_algorithm_supported(algorithm):
-            raise UnsupportedAlgorithm("", _Reasons.UNSUPPORTED_CIPHER)
-
-
-@utils.register_interface(EllipticCurveBackend)
-class DummyEllipticCurveBackend(object):
-    def __init__(self, supported_curves):
-        self._curves = supported_curves
-
-    def elliptic_curve_supported(self, curve):
-        return any(
-            isinstance(curve, curve_type)
-            for curve_type in self._curves
-        )
-
-    def elliptic_curve_signature_algorithm_supported(
-        self, signature_algorithm, curve
-    ):
-        return (
-            isinstance(signature_algorithm, ec.ECDSA) and
-            self.elliptic_curve_supported(curve)
-        )
-
-    def generate_elliptic_curve_private_key(self, curve):
-        if not self.elliptic_curve_supported(curve):
-            raise UnsupportedAlgorithm(_Reasons.UNSUPPORTED_ELLIPTIC_CURVE)
-
-    def load_elliptic_curve_private_numbers(self, numbers):
-        if not self.elliptic_curve_supported(numbers.public_numbers.curve):
-            raise UnsupportedAlgorithm(_Reasons.UNSUPPORTED_ELLIPTIC_CURVE)
-
-    def load_elliptic_curve_public_numbers(self, numbers):
-        if not self.elliptic_curve_supported(numbers.curve):
-            raise UnsupportedAlgorithm(_Reasons.UNSUPPORTED_ELLIPTIC_CURVE)
-
-    def elliptic_curve_exchange_algorithm_supported(self, algorithm, curve):
-        return (
-            isinstance(algorithm, ec.ECDH) and
-            self.elliptic_curve_supported(curve)
-        )
-
-    def derive_elliptic_curve_private_key(self, private_value, curve):
-        if not self.elliptic_curve_supported(curve):
-            raise UnsupportedAlgorithm(_Reasons.UNSUPPORTED_ELLIPTIC_CURVE)
-
-
-@utils.register_interface(PEMSerializationBackend)
-class DummyPEMSerializationBackend(object):
-    def load_pem_private_key(self, data, password):
-        pass
-
-    def load_pem_public_key(self, data):
-        pass
-
-
-@utils.register_interface(DERSerializationBackend)
-class DummyDERSerializationBackend(object):
-    def load_der_private_key(self, data, password):
-        pass
-
-    def load_der_public_key(self, data):
-        pass
-
-
-@utils.register_interface(X509Backend)
-class DummyX509Backend(object):
-    def load_pem_x509_certificate(self, data):
-        pass
-
-    def load_der_x509_certificate(self, data):
-        pass
-
-    def load_pem_x509_crl(self, data):
-        pass
-
-    def load_der_x509_crl(self, data):
-        pass
-
-    def load_pem_x509_csr(self, data):
-        pass
-
-    def load_der_x509_csr(self, data):
-        pass
-
-    def create_x509_csr(self, builder, private_key, algorithm):
-        pass
-
-    def create_x509_certificate(self, builder, private_key, algorithm):
-        pass
-
-    def create_x509_crl(self, builder, private_key, algorithm):
-        pass
-
-    def create_x509_revoked_certificate(self, builder):
-        pass
-
-    def x509_name_bytes(self, name):
-        pass
-
-
-@utils.register_interface(DHBackend)
-class DummyDHBackend(object):
-    def generate_dh_parameters(self, generator, key_size):
-        pass
-
-    def load_dh_parameter_numbers(self, numbers):
-        pass
-
-    def generate_dh_private_key(self, parameters):
-        pass
-
-    def load_dh_private_numbers(self, numbers):
-        pass
-
-    def load_dh_public_numbers(self, numbers):
-        pass
-
-    def generate_dh_private_key_and_parameters(self, generator, key_size):
-        pass
-
-    def dh_parameters_supported(self, p, g, q=None):
-        pass
-
-    def dh_x942_serialization_supported(self):
-        pass
-
-
-@utils.register_interface(ScryptBackend)
-class DummyScryptBackend(object):
-    def derive_scrypt(self, key_material, salt, length, n, r, p):
-        pass
-
-
-class TestMultiBackend(object):
-    def test_raises_error_with_empty_list(self):
-        with pytest.raises(ValueError):
-            MultiBackend([])
-
-    def test_ciphers(self):
-        backend = MultiBackend([
-            DummyHashBackend([]),
-            DummyCipherBackend([
-                (algorithms.AES, modes.CBC),
-            ])
-        ])
-        assert backend.cipher_supported(
-            algorithms.AES(b"\x00" * 16), modes.CBC(b"\x00" * 16)
-        )
-        assert not backend.cipher_supported(
-            algorithms.TripleDES(b"\x00" * 16), modes.CBC(b"\x00" * 16)
-        )
-
-        cipher = Cipher(
-            algorithms.AES(b"\x00" * 16),
-            modes.CBC(b"\x00" * 16),
-            backend=backend
-        )
-        cipher.encryptor()
-        cipher.decryptor()
-
-        cipher = Cipher(
-            algorithms.Camellia(b"\x00" * 16),
-            modes.CBC(b"\x00" * 16),
-            backend=backend
-        )
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_CIPHER):
-            cipher.encryptor()
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_CIPHER):
-            cipher.decryptor()
-
-    def test_hashes(self):
-        backend = MultiBackend([
-            DummyHashBackend([hashes.MD5])
-        ])
-        assert backend.hash_supported(hashes.MD5())
-        assert not backend.hash_supported(hashes.SHA256())
-
-        hashes.Hash(hashes.MD5(), backend=backend)
-
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_HASH):
-            hashes.Hash(hashes.SHA1(), backend=backend)
-
-    def test_hmac(self):
-        backend = MultiBackend([
-            DummyHMACBackend([hashes.MD5])
-        ])
-        assert backend.hmac_supported(hashes.MD5())
-        assert not backend.hmac_supported(hashes.SHA256())
-
-        hmac.HMAC(b"", hashes.MD5(), backend=backend)
-
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_HASH):
-            hmac.HMAC(b"", hashes.SHA1(), backend=backend)
-
-    def test_pbkdf2(self):
-        backend = MultiBackend([
-            DummyPBKDF2HMACBackend([hashes.MD5])
-        ])
-        assert backend.pbkdf2_hmac_supported(hashes.MD5())
-
-        backend.derive_pbkdf2_hmac(hashes.MD5(), 10, b"", 10, b"")
-
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_HASH):
-            backend.derive_pbkdf2_hmac(hashes.SHA1(), 10, b"", 10, b"")
-
-    def test_rsa(self):
-        backend = MultiBackend([
-            DummyRSABackend()
-        ])
-
-        backend.generate_rsa_private_key(
-            key_size=1024, public_exponent=65537
-        )
-
-        backend.rsa_padding_supported(padding.PKCS1v15())
-
-        backend.generate_rsa_parameters_supported(65537, 1024)
-
-        backend.load_rsa_private_numbers("private_numbers")
-
-        backend.load_rsa_public_numbers("public_numbers")
-
-        backend = MultiBackend([DummyBackend()])
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.generate_rsa_private_key(key_size=1024, public_exponent=3)
-
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.rsa_padding_supported(padding.PKCS1v15())
-
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.generate_rsa_parameters_supported(65537, 1024)
-
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.load_rsa_private_numbers("private_numbers")
-
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.load_rsa_public_numbers("public_numbers")
-
-    def test_dsa(self):
-        backend = MultiBackend([
-            DummyDSABackend()
-        ])
-
-        backend.generate_dsa_parameters(key_size=1024)
-
-        parameters = object()
-        backend.generate_dsa_private_key(parameters)
-        backend.generate_dsa_private_key_and_parameters(key_size=1024)
-
-        backend.dsa_hash_supported(hashes.SHA1())
-        backend.dsa_parameters_supported(1, 2, 3)
-        backend.load_dsa_private_numbers("numbers")
-        backend.load_dsa_public_numbers("numbers")
-        backend.load_dsa_parameter_numbers("numbers")
-
-        backend = MultiBackend([DummyBackend()])
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.generate_dsa_parameters(key_size=1024)
-
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.generate_dsa_private_key(parameters)
-
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.generate_dsa_private_key_and_parameters(key_size=1024)
-
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.dsa_hash_supported(hashes.SHA1())
-
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.dsa_parameters_supported('p', 'q', 'g')
-
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.load_dsa_private_numbers("numbers")
-
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.load_dsa_public_numbers("numbers")
-
-        with raises_unsupported_algorithm(
-            _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM
-        ):
-            backend.load_dsa_parameter_numbers("numbers")
-
-    def test_cmac(self):
-        backend = MultiBackend([
-            DummyCMACBackend([algorithms.AES])
-        ])
-
-        fake_key = b"\x00" * 16
-
-        assert backend.cmac_algorithm_supported(algorithms.AES(fake_key))
-        assert not backend.cmac_algorithm_supported(
-            algorithms.TripleDES(fake_key)
-        )
-
-        cmac.CMAC(algorithms.AES(fake_key), backend)
-
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_CIPHER):
-            cmac.CMAC(algorithms.TripleDES(fake_key), backend)
-
-    def test_elliptic_curve(self):
-        backend = MultiBackend([
-            DummyEllipticCurveBackend([
-                ec.SECT283K1
-            ])
-        ])
-
-        assert backend.elliptic_curve_supported(ec.SECT283K1()) is True
-
-        assert backend.elliptic_curve_signature_algorithm_supported(
-            ec.ECDSA(hashes.SHA256()),
-            ec.SECT283K1()
-        ) is True
-
-        backend.generate_elliptic_curve_private_key(ec.SECT283K1())
-
-        backend.load_elliptic_curve_private_numbers(
-            ec.EllipticCurvePrivateNumbers(
-                1,
-                ec.EllipticCurvePublicNumbers(
-                    2,
-                    3,
-                    ec.SECT283K1()
-                )
-            )
-        )
-
-        backend.load_elliptic_curve_public_numbers(
-            ec.EllipticCurvePublicNumbers(
-                2,
-                3,
-                ec.SECT283K1()
-            )
-        )
-
-        assert backend.elliptic_curve_supported(ec.SECT163K1()) is False
-
-        assert backend.elliptic_curve_signature_algorithm_supported(
-            ec.ECDSA(hashes.SHA256()),
-            ec.SECT163K1()
-        ) is False
-
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_ELLIPTIC_CURVE):
-            backend.generate_elliptic_curve_private_key(ec.SECT163K1())
-
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_ELLIPTIC_CURVE):
-            backend.load_elliptic_curve_private_numbers(
-                ec.EllipticCurvePrivateNumbers(
-                    1,
-                    ec.EllipticCurvePublicNumbers(
-                        2,
-                        3,
-                        ec.SECT163K1()
-                    )
-                )
-            )
-
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_ELLIPTIC_CURVE):
-            backend.load_elliptic_curve_public_numbers(
-                ec.EllipticCurvePublicNumbers(
-                    2,
-                    3,
-                    ec.SECT163K1()
-                )
-            )
-
-        assert backend.elliptic_curve_exchange_algorithm_supported(
-            ec.ECDH(), ec.SECT283K1()
-        )
-        backend2 = MultiBackend([DummyEllipticCurveBackend([])])
-        assert not backend2.elliptic_curve_exchange_algorithm_supported(
-            ec.ECDH(), ec.SECT163K1()
-        )
-
-        with pytest.raises(UnsupportedAlgorithm):
-            backend.derive_elliptic_curve_private_key(123, DummyCurve())
-
-        assert backend.derive_elliptic_curve_private_key(
-            123, ec.SECT283K1()) is None
-
-    def test_pem_serialization_backend(self):
-        backend = MultiBackend([DummyPEMSerializationBackend()])
-
-        backend.load_pem_private_key(b"keydata", None)
-        backend.load_pem_public_key(b"keydata")
-
-        backend = MultiBackend([DummyBackend()])
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_SERIALIZATION):
-            backend.load_pem_private_key(b"keydata", None)
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_SERIALIZATION):
-            backend.load_pem_public_key(b"keydata")
-
-    def test_der_serialization_backend(self):
-        backend = MultiBackend([DummyDERSerializationBackend()])
-
-        backend.load_der_private_key(b"keydata", None)
-        backend.load_der_public_key(b"keydata")
-
-        backend = MultiBackend([DummyBackend()])
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_SERIALIZATION):
-            backend.load_der_private_key(b"keydata", None)
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_SERIALIZATION):
-            backend.load_der_public_key(b"keydata")
-
-    def test_x509_backend(self):
-        backend = MultiBackend([DummyX509Backend()])
-
-        backend.load_pem_x509_certificate(b"certdata")
-        backend.load_der_x509_certificate(b"certdata")
-        backend.load_pem_x509_crl(b"crldata")
-        backend.load_der_x509_crl(b"crldata")
-        backend.load_pem_x509_csr(b"reqdata")
-        backend.load_der_x509_csr(b"reqdata")
-        backend.create_x509_csr(object(), b"privatekey", hashes.SHA1())
-        backend.create_x509_certificate(object(), b"privatekey", hashes.SHA1())
-        backend.create_x509_crl(object(), b"privatekey", hashes.SHA1())
-        backend.create_x509_revoked_certificate(object())
-        backend.x509_name_bytes(object())
-
-        backend = MultiBackend([DummyBackend()])
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_X509):
-            backend.load_pem_x509_certificate(b"certdata")
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_X509):
-            backend.load_der_x509_certificate(b"certdata")
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_X509):
-            backend.load_pem_x509_crl(b"crldata")
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_X509):
-            backend.load_der_x509_crl(b"crldata")
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_X509):
-            backend.load_pem_x509_csr(b"reqdata")
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_X509):
-            backend.load_der_x509_csr(b"reqdata")
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_X509):
-            backend.create_x509_csr(object(), b"privatekey", hashes.SHA1())
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_X509):
-            backend.create_x509_certificate(
-                object(), b"privatekey", hashes.SHA1()
-            )
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_X509):
-            backend.create_x509_crl(
-                object(), b"privatekey", hashes.SHA1()
-            )
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_X509):
-            backend.create_x509_revoked_certificate(object())
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_X509):
-            backend.x509_name_bytes(object())
-
-    def test_dh_backend(self):
-        backend = MultiBackend([DummyDHBackend()])
-
-        backend.generate_dh_parameters(2, 512)
-        backend.load_dh_parameter_numbers(object())
-        backend.generate_dh_private_key(object())
-        backend.load_dh_private_numbers(object())
-        backend.load_dh_public_numbers(object())
-        backend.generate_dh_private_key_and_parameters(2, 512)
-        backend.dh_parameters_supported(2, 3)
-        backend.dh_x942_serialization_supported()
-
-        backend = MultiBackend([DummyBackend()])
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_DIFFIE_HELLMAN):
-            backend.generate_dh_parameters(2, 512)
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_DIFFIE_HELLMAN):
-            backend.load_dh_parameter_numbers(object())
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_DIFFIE_HELLMAN):
-            backend.generate_dh_private_key(object())
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_DIFFIE_HELLMAN):
-            backend.load_dh_private_numbers(object())
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_DIFFIE_HELLMAN):
-            backend.load_dh_public_numbers(object())
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_DIFFIE_HELLMAN):
-            backend.generate_dh_private_key_and_parameters(2, 512)
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_DIFFIE_HELLMAN):
-            backend.dh_parameters_supported(2, 3)
-        with raises_unsupported_algorithm(_Reasons.UNSUPPORTED_DIFFIE_HELLMAN):
-            backend.dh_x942_serialization_supported()
-
-    def test_scrypt(self):
-        backend = MultiBackend([DummyScryptBackend()])
-        backend.derive_scrypt(b"key", b"salt", 1, 1, 1, 1)
-
-        backend = MultiBackend([DummyBackend])
-        with pytest.raises(UnsupportedAlgorithm):
-            backend.derive_scrypt(b"key", b"salt", 1, 1, 1, 1)
diff --git a/tests/hazmat/primitives/test_cmac.py b/tests/hazmat/primitives/test_cmac.py
index 08b6bf5d..2ca05d6d 100644
--- a/tests/hazmat/primitives/test_cmac.py
+++ b/tests/hazmat/primitives/test_cmac.py
@@ -6,8 +6,6 @@ from __future__ import absolute_import, division, print_function
 
 import binascii
 
-import pretend
-
 import pytest
 
 from cryptography.exceptions import (
@@ -19,11 +17,11 @@ from cryptography.hazmat.primitives.ciphers.algorithms import (
 )
 from cryptography.hazmat.primitives.cmac import CMAC
 
-from ..backends.test_multibackend import DummyCMACBackend
 from ...utils import (
     load_nist_vectors, load_vectors_from_file, raises_unsupported_algorithm
 )
 
+
 vectors_aes128 = load_vectors_from_file(
     "CMAC/nist-800-38b-aes128.txt", load_nist_vectors)
 
@@ -186,17 +184,6 @@ class TestCMAC(object):
         assert cmac.finalize() == copy_cmac.finalize()
 
 
-def test_copy():
-    backend = DummyCMACBackend([AES])
-    copied_ctx = pretend.stub()
-    pretend_ctx = pretend.stub(copy=lambda: copied_ctx)
-    key = b"2b7e151628aed2a6abf7158809cf4f3c"
-    cmac = CMAC(AES(key), backend=backend, ctx=pretend_ctx)
-
-    assert cmac._backend is backend
-    assert cmac.copy()._backend is backend
-
-
 def test_invalid_backend():
     key = b"2b7e151628aed2a6abf7158809cf4f3c"
     pretend_backend = object()
diff --git a/tests/hazmat/primitives/test_hashes.py b/tests/hazmat/primitives/test_hashes.py
index fe96b322..0e817666 100644
--- a/tests/hazmat/primitives/test_hashes.py
+++ b/tests/hazmat/primitives/test_hashes.py
@@ -4,8 +4,6 @@
 
 from __future__ import absolute_import, division, print_function
 
-import pretend
-
 import pytest
 
 from cryptography.exceptions import AlreadyFinalized, _Reasons
@@ -13,7 +11,6 @@ from cryptography.hazmat.backends.interfaces import HashBackend
 from cryptography.hazmat.primitives import hashes
 
 from .utils import generate_base_hash_test
-from ..backends.test_multibackend import DummyHashBackend
 from ...doubles import DummyHashAlgorithm
 from ...utils import raises_unsupported_algorithm
 
@@ -25,14 +22,6 @@ class TestHashContext(object):
         with pytest.raises(TypeError):
             m.update(u"\u00FC")
 
-    def test_copy_backend_object(self):
-        backend = DummyHashBackend([hashes.SHA1])
-        copied_ctx = pretend.stub()
-        pretend_ctx = pretend.stub(copy=lambda: copied_ctx)
-        h = hashes.Hash(hashes.SHA1(), backend=backend, ctx=pretend_ctx)
-        assert h._backend is backend
-        assert h.copy()._backend is h._backend
-
     def test_hash_algorithm_instance(self, backend):
         with pytest.raises(TypeError):
             hashes.Hash(hashes.SHA1, backend=backend)
diff --git a/tests/hazmat/primitives/test_hmac.py b/tests/hazmat/primitives/test_hmac.py
index 82082a2d..50aa9cc2 100644
--- a/tests/hazmat/primitives/test_hmac.py
+++ b/tests/hazmat/primitives/test_hmac.py
@@ -4,8 +4,6 @@
 
 from __future__ import absolute_import, division, print_function
 
-import pretend
-
 import pytest
 
 from cryptography.exceptions import (
@@ -15,7 +13,6 @@ from cryptography.hazmat.backends.interfaces import HMACBackend
 from cryptography.hazmat.primitives import hashes, hmac
 
 from .utils import generate_base_hmac_test
-from ..backends.test_multibackend import DummyHMACBackend
 from ...doubles import DummyHashAlgorithm
 from ...utils import raises_unsupported_algorithm
 
@@ -38,14 +35,6 @@ class TestHMAC(object):
         with pytest.raises(TypeError):
             h.update(u"\u00FC")
 
-    def test_copy_backend_object(self):
-        backend = DummyHMACBackend([hashes.SHA1])
-        copied_ctx = pretend.stub()
-        pretend_ctx = pretend.stub(copy=lambda: copied_ctx)
-        h = hmac.HMAC(b"key", hashes.SHA1(), backend=backend, ctx=pretend_ctx)
-        assert h._backend is backend
-        assert h.copy()._backend is backend
-
     def test_hmac_algorithm_instance(self, backend):
         with pytest.raises(TypeError):
             hmac.HMAC(b"key", hashes.SHA1, backend=backend)