diff --git a/src/crypto/pkey.c b/src/crypto/pkey.c
index 201960f..07fe423 100644
--- a/src/crypto/pkey.c
+++ b/src/crypto/pkey.c
@@ -69,8 +69,7 @@
     }
 
     PyErr_SetString(crypto_Error, "No such key type");
-    Py_INCREF(Py_None);
-    return Py_None;
+    return NULL;
 }
 
 static char crypto_PKey_bits_doc[] = "\n\
diff --git a/test/__init__.py b/test/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/__init__.py
diff --git a/test/test_crypto.py b/test/test_crypto.py
new file mode 100644
index 0000000..b9dd562
--- /dev/null
+++ b/test/test_crypto.py
@@ -0,0 +1,96 @@
+
+"""
+Unit tests for L{OpenSSL.crypto}.
+"""
+
+from unittest import TestCase
+
+from OpenSSL.crypto import TYPE_RSA, TYPE_DSA, Error, PKey, PKeyType
+
+
+class PKeyTests(TestCase):
+    """
+    Unit tests for L{OpenSSL.crypto.PKey}.
+    """
+    def test_construction(self):
+        """
+        L{PKey} takes no arguments and returns a new L{PKeyType} instance.
+        """
+        self.assertRaises(TypeError, PKey, None)
+        key = PKey()
+        self.assertTrue(
+            isinstance(key, PKeyType),
+            "%r is of type %r, should be %r" % (key, type(key), PKeyType))
+
+
+    def test_pregeneration(self):
+        """
+        L{PKeyType.bits} and L{PKeyType.type} return C{0} before the key is
+        generated.
+        """
+        key = PKey()
+        self.assertEqual(key.type(), 0)
+        self.assertEqual(key.bits(), 0)
+
+
+    def test_failedGeneration(self):
+        """
+        L{PKeyType.generate_key} takes two arguments, the first giving the
+        key type as one of L{TYPE_RSA} or L{TYPE_DSA} and the second giving
+        the number of bits to generate.  If an invalid type is specified or
+        generation fails, L{Error} is raised.
+        """
+        key = PKey()
+        self.assertRaises(TypeError, key.generate_key)
+        self.assertRaises(TypeError, key.generate_key, 1, 2, 3)
+        self.assertRaises(TypeError, key.generate_key, "foo", "bar")
+        self.assertRaises(Error, key.generate_key, -1, 0)
+        self.assertRaises(Error, key.generate_key, TYPE_RSA, 0)
+
+        # XXX DSA generation seems happy with any number of bits.  The DSS
+        # says bits must be between 512 and 1024 inclusive.  OpenSSL's DSA
+        # generator doesn't seem to care about the upper limit at all.  For
+        # the lower limit, it uses 512 if anything smaller is specified. 
+        # So, it doesn't seem possible to make generate_key fail for
+        # TYPE_DSA with a bits argument which is at least an int.
+
+        # self.assertRaises(Error, key.generate_key, TYPE_DSA, -7)
+
+
+    def test_rsaGeneration(self):
+        """
+        L{PKeyType.generate_key} generates an RSA key when passed
+        L{TYPE_RSA} as a type and a reasonable number of bits.
+        """
+        bits = 128
+        key = PKey()
+        key.generate_key(TYPE_RSA, bits)
+        self.assertEqual(key.type(), TYPE_RSA)
+        self.assertEqual(key.bits(), bits)
+
+
+    def test_dsaGeneration(self):
+        """
+        L{PKeyType.generate_key} generates a DSA key when passed
+        L{TYPE_DSA} as a type and a reasonable number of bits.
+        """
+        # 512 is a magic number.  The DSS (Digital Signature Standard)
+        # allows a minimum of 512 bits for DSA.  DSA_generate_parameters
+        # will silently promote any value below 512 to 512.
+        bits = 512
+        key = PKey()
+        key.generate_key(TYPE_DSA, bits)
+        self.assertEqual(key.type(), TYPE_DSA)
+        self.assertEqual(key.bits(), bits)
+
+
+    def test_regeneration(self):
+        """
+        L{PKeyType.generate_key} can be called multiple times on the same
+        key to generate new keys.
+        """
+        key = PKey()
+        for type, bits in [(TYPE_RSA, 512), (TYPE_DSA, 576)]:
+             key.generate_key(type, bits)
+             self.assertEqual(key.type(), type)
+             self.assertEqual(key.bits(), bits)