Add more mock-module implementation

 * Move mock code into the common/ directory to be used by multiple
   components of p11-kit

5 files changed, 14 insertions, 1243 deletions

diff --git a/p11-kit/tests/Makefile.am b/p11-kit/tests/Makefile.am
index 026111c..e39ac8f 100644
--- a/p11-kit/tests/Makefile.am
+++ b/p11-kit/tests/Makefile.am
@@ -11,6 +11,9 @@ INCLUDES = \
 
 LDADD = \
 	$(top_builddir)/p11-kit/libp11-kit-testable.la \
+	$(top_builddir)/common/libp11-mock.la \
+	$(top_builddir)/common/libp11-library.la \
+	$(top_builddir)/common/libp11-compat.la \
 	$(CUTEST_LIBS) \
 	$(LTLIBINTL)
 
@@ -26,10 +29,6 @@ noinst_PROGRAMS = \
 	print-messages \
 	$(CHECK_PROGS)
 
-test_init_SOURCES = test-init.c \
-	mock-module.c mock-module.h
-test_init_CFLAGS = $(AM_CFLAGS)
-
 TESTS = $(CHECK_PROGS:=$(EXEEXT))
 
 noinst_LTLIBRARIES = \
@@ -39,10 +38,13 @@ noinst_LTLIBRARIES = \
 	mock-four.la
 
 mock_one_la_SOURCES = \
-	mock-module.c mock-module.h \
 	mock-module-ep.c
 
+mock_one_la_CFLAGS = \
+	$(AM_CFLAGS)
+
 mock_one_la_LIBADD = \
+	$(top_builddir)/common/libp11-mock.la \
 	$(top_builddir)/common/libp11-library.la \
 	$(top_builddir)/common/libp11-compat.la \
 	$(NULL)
@@ -52,10 +54,12 @@ mock_one_la_LDFLAGS = \
 	-no-undefined -export-symbols-regex 'C_GetFunctionList'
 
 mock_two_la_SOURCES = $(mock_one_la_SOURCES)
+mock_two_la_CFLAGS = $(mock_one_la_CFLAGS)
 mock_two_la_LDFLAGS = $(mock_one_la_LDFLAGS)
 mock_two_la_LIBADD = $(mock_one_la_LIBADD)
 
 mock_three_la_SOURCES = $(mock_one_la_SOURCES)
+mock_three_la_CFLAGS = $(mock_one_la_CFLAGS)
 mock_three_la_LDFLAGS = $(mock_one_la_LDFLAGS)
 mock_three_la_LIBADD = $(mock_one_la_LIBADD)
 
diff --git a/p11-kit/tests/mock-module-ep.c b/p11-kit/tests/mock-module-ep.c
index 7440a74..89b31f6 100644
--- a/p11-kit/tests/mock-module-ep.c
+++ b/p11-kit/tests/mock-module-ep.c
@@ -36,7 +36,8 @@
 
 #define CRYPTOKI_EXPORTS 1
 #include "pkcs11.h"
-#include "mock-module.h"
+
+#include "mock.h"
 
 #ifdef OS_WIN32
 __declspec(dllexport)
@@ -45,6 +46,7 @@ CK_RV
 C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
 {
 	mock_module_init ();
+	mock_module_no_slots.C_GetFunctionList = C_GetFunctionList;
 	if (list == NULL)
 		return CKR_ARGUMENTS_BAD;
 	*list = &mock_module_no_slots;
diff --git a/p11-kit/tests/mock-module.c b/p11-kit/tests/mock-module.c
deleted file mode 100644
index 15db600..0000000
--- a/p11-kit/tests/mock-module.c
+++ /dev/null
@@ -1,898 +0,0 @@
-/*
- * Copyright (c) 2011, Collabora Ltd.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- *     * Redistributions of source code must retain the above
- *       copyright notice, this list of conditions and the
- *       following disclaimer.
- *     * Redistributions in binary form must reproduce the
- *       above copyright notice, this list of conditions and
- *       the following disclaimer in the documentation and/or
- *       other materials provided with the distribution.
- *     * The names of contributors to this software may not be
- *       used to endorse or promote products derived from this
- *       software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
- * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- *
- * Author: Stef Walter <stefw@collabora.co.uk>
- */
-
-#include "config.h"
-
-#include "library.h"
-#define CRYPTOKI_EXPORTS
-#include "pkcs11.h"
-
-#include "mock-module.h"
-
-#include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-/* -------------------------------------------------------------------
- * GLOBALS / DEFINES
- */
-
-/* Various mutexes */
-static p11_mutex_t init_mutex;
-
-/* Whether we've been initialized, and on what process id it happened */
-static bool pkcs11_initialized = false;
-static pid_t pkcs11_initialized_pid = 0;
-
-/* -----------------------------------------------------------------------------
- * LOGGING and DEBUGGING
- */
-
-#define DEBUG_OUTPUT 0
-
-#if DEBUG_OUTPUT
-#define debug(x) mock_log x
-#else
-#define debug(x)
-#endif
-
-#define warning(x) mock_log x
-
-#define return_val_if_fail(x, v) \
-	if (!(x)) { mock_log ("'%s' not true at %s", #x, __func__); return v; }
-
-static void
-mock_log (const char *format, ...)
-{
-	va_list va;
-	va_start (va, format);
-	fprintf (stderr, "mock-module: ");
-	vfprintf (stderr, format, va);
-	fprintf (stderr, "\n");
-	va_end (va);
-}
-
-/* -------------------------------------------------------------------
- * INITIALIZATION and 'GLOBAL' CALLS
- */
-
-CK_RV
-mock_C_Initialize (CK_VOID_PTR init_args)
-{
-	CK_C_INITIALIZE_ARGS_PTR args = NULL;
-	CK_RV ret = CKR_OK;
-	pid_t pid;
-
-	debug (("C_Initialize: enter"));
-
-	p11_mutex_lock (&init_mutex);
-
-		if (init_args != NULL) {
-			int supplied_ok;
-
-			/* pReserved must be NULL */
-			args = init_args;
-
-			/* ALL supplied function pointers need to have the value either NULL or non-NULL. */
-			supplied_ok = (args->CreateMutex == NULL && args->DestroyMutex == NULL &&
-			               args->LockMutex == NULL && args->UnlockMutex == NULL) ||
-			              (args->CreateMutex != NULL && args->DestroyMutex != NULL &&
-			               args->LockMutex != NULL && args->UnlockMutex != NULL);
-			if (!supplied_ok) {
-				warning (("invalid set of mutex calls supplied"));
-				ret = CKR_ARGUMENTS_BAD;
-				goto done;
-			}
-
-			/*
-			 * When the CKF_OS_LOCKING_OK flag isn't set return an error.
-			 * We must be able to use our pthread functionality.
-			 */
-			if (!(args->flags & CKF_OS_LOCKING_OK)) {
-				warning (("can't do without os locking"));
-				ret = CKR_CANT_LOCK;
-				goto done;
-			}
-		}
-
-		pid = getpid ();
-		if (pkcs11_initialized) {
-
-			/* This process has called C_Initialize already */
-			if (pid == pkcs11_initialized_pid) {
-				warning (("C_Initialize called twice for same process"));
-				ret = CKR_CRYPTOKI_ALREADY_INITIALIZED;
-				goto done;
-			}
-		}
-
-done:
-		/* Mark us as officially initialized */
-		if (ret == CKR_OK) {
-			pkcs11_initialized = true;
-			pkcs11_initialized_pid = pid;
-		} else if (ret != CKR_CRYPTOKI_ALREADY_INITIALIZED) {
-			pkcs11_initialized = false;
-			pkcs11_initialized_pid = 0;
-		}
-
-	p11_mutex_unlock (&init_mutex);
-
-	debug (("C_Initialize: %d", ret));
-	return ret;
-}
-
-CK_RV
-mock_C_Finalize (CK_VOID_PTR reserved)
-{
-	debug (("C_Finalize: enter"));
-	return_val_if_fail (pkcs11_initialized, CKR_CRYPTOKI_NOT_INITIALIZED);
-	return_val_if_fail (reserved == NULL, CKR_ARGUMENTS_BAD);
-
-	p11_mutex_lock (&init_mutex);
-
-		/* This should stop all other calls in */
-		pkcs11_initialized = false;
-		pkcs11_initialized_pid = 0;
-
-	p11_mutex_unlock (&init_mutex);
-
-	debug (("C_Finalize: %d", CKR_OK));
-	return CKR_OK;
-}
-
-static const CK_INFO MOCK_INFO = {
-	{ CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },
-	"MOCK MANUFACTURER              ",
-	0,
-	"MOCK LIBRARY                   ",
-	{ 45, 145 }
-};
-
-
-CK_RV
-mock_C_GetInfo (CK_INFO_PTR info)
-{
-	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
-	memcpy (info, &MOCK_INFO, sizeof (*info));
-	return CKR_OK;
-}
-
-CK_RV
-mock_C_GetFunctionList (CK_FUNCTION_LIST_PTR_PTR list)
-{
-	/* This would be a strange call to receive */
-	return C_GetFunctionList (list);
-}
-
-CK_RV
-mock_C_GetSlotList__no_tokens (CK_BBOOL token_present,
-                               CK_SLOT_ID_PTR slot_list,
-                               CK_ULONG_PTR count)
-{
-	return_val_if_fail (count, CKR_ARGUMENTS_BAD);
-
-	/* No tokens */
-	*count = 0;
-	return CKR_OK;
-}
-
-CK_RV
-mock_C_GetSlotInfo__invalid_slotid (CK_SLOT_ID id,
-                                    CK_SLOT_INFO_PTR info)
-{
-	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
-	return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_C_GetTokenInfo__invalid_slotid (CK_SLOT_ID id,
-                                     CK_TOKEN_INFO_PTR info)
-{
-	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
-	return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_C_GetMechanismList__invalid_slotid (CK_SLOT_ID id,
-                                         CK_MECHANISM_TYPE_PTR mechanism_list,
-                                         CK_ULONG_PTR count)
-{
-	return_val_if_fail (count, CKR_ARGUMENTS_BAD);
-
-	return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_C_GetMechanismInfo__invalid_slotid (CK_SLOT_ID id,
-                                         CK_MECHANISM_TYPE type,
-                                         CK_MECHANISM_INFO_PTR info)
-{
-	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
-	return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_C_InitToken__invalid_slotid (CK_SLOT_ID id,
-                                  CK_UTF8CHAR_PTR pin,
-                                  CK_ULONG pin_len,
-                                  CK_UTF8CHAR_PTR label)
-{
-	return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_C_WaitForSlotEvent__no_event (CK_FLAGS flags,
-                                   CK_SLOT_ID_PTR slot,
-                                   CK_VOID_PTR reserved)
-{
-	return_val_if_fail (slot, CKR_ARGUMENTS_BAD);
-
-	return CKR_NO_EVENT;
-}
-
-CK_RV
-mock_C_OpenSession__invalid_slotid (CK_SLOT_ID id,
-                                    CK_FLAGS flags,
-                                    CK_VOID_PTR user_data,
-                                    CK_NOTIFY callback,
-                                    CK_SESSION_HANDLE_PTR session)
-{
-	return_val_if_fail (session, CKR_ARGUMENTS_BAD);
-
-	return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_C_CloseSession__invalid_handle (CK_SESSION_HANDLE session)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_CloseAllSessions__invalid_slotid (CK_SLOT_ID id)
-{
-	return CKR_SLOT_ID_INVALID;
-}
-
-CK_RV
-mock_C_GetFunctionStatus__not_parallel (CK_SESSION_HANDLE session)
-{
-	return CKR_FUNCTION_NOT_PARALLEL;
-}
-
-CK_RV
-mock_C_CancelFunction__not_parallel (CK_SESSION_HANDLE session)
-{
-	return CKR_FUNCTION_NOT_PARALLEL;
-}
-
-CK_RV
-mock_C_GetSessionInfo__invalid_handle (CK_SESSION_HANDLE session,
-                                       CK_SESSION_INFO_PTR info)
-{
-	return_val_if_fail (info, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_InitPIN__invalid_handle (CK_SESSION_HANDLE session,
-                                CK_UTF8CHAR_PTR pin,
-                                CK_ULONG pin_len)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SetPIN__invalid_handle (CK_SESSION_HANDLE session,
-                               CK_UTF8CHAR_PTR old_pin,
-                               CK_ULONG old_pin_len,
-                               CK_UTF8CHAR_PTR new_pin,
-                               CK_ULONG new_pin_len)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GetOperationState__invalid_handle (CK_SESSION_HANDLE session,
-                                         CK_BYTE_PTR operation_state,
-                                         CK_ULONG_PTR operation_state_len)
-{
-	return_val_if_fail (operation_state_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SetOperationState__invalid_handle (CK_SESSION_HANDLE session,
-                                          CK_BYTE_PTR operation_state,
-                                          CK_ULONG operation_state_len,
-                                          CK_OBJECT_HANDLE encryption_key,
-                                          CK_OBJECT_HANDLE authentication_key)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Login__invalid_handle (CK_SESSION_HANDLE session,
-                              CK_USER_TYPE user_type,
-                              CK_UTF8CHAR_PTR pin,
-                              CK_ULONG pin_len)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-
-}
-
-CK_RV
-mock_C_Logout__invalid_handle (CK_SESSION_HANDLE session)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-
-}
-
-CK_RV
-mock_C_CreateObject__invalid_handle (CK_SESSION_HANDLE session,
-                                     CK_ATTRIBUTE_PTR template,
-                                     CK_ULONG count,
-                                     CK_OBJECT_HANDLE_PTR new_object)
-{
-	return_val_if_fail (new_object, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_CopyObject__invalid_handle (CK_SESSION_HANDLE session,
-                                   CK_OBJECT_HANDLE object,
-                                   CK_ATTRIBUTE_PTR template,
-                                   CK_ULONG count,
-                                   CK_OBJECT_HANDLE_PTR new_object)
-{
-	return_val_if_fail (new_object, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-
-CK_RV
-mock_C_DestroyObject__invalid_handle (CK_SESSION_HANDLE session,
-                                      CK_OBJECT_HANDLE object)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GetObjectSize__invalid_handle (CK_SESSION_HANDLE session,
-                                      CK_OBJECT_HANDLE object,
-                                      CK_ULONG_PTR size)
-{
-	return_val_if_fail (size, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GetAttributeValue__invalid_handle (CK_SESSION_HANDLE session,
-                                          CK_OBJECT_HANDLE object,
-                                          CK_ATTRIBUTE_PTR template,
-                                          CK_ULONG count)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SetAttributeValue__invalid_handle (CK_SESSION_HANDLE session,
-                                          CK_OBJECT_HANDLE object,
-                                          CK_ATTRIBUTE_PTR template,
-                                          CK_ULONG count)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_FindObjectsInit__invalid_handle (CK_SESSION_HANDLE session,
-                                        CK_ATTRIBUTE_PTR template,
-                                        CK_ULONG count)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_FindObjects__invalid_handle (CK_SESSION_HANDLE session,
-                                    CK_OBJECT_HANDLE_PTR objects,
-                                    CK_ULONG max_count,
-                                    CK_ULONG_PTR count)
-{
-	return_val_if_fail (count, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_FindObjectsFinal__invalid_handle (CK_SESSION_HANDLE session)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_EncryptInit__invalid_handle (CK_SESSION_HANDLE session,
-                                    CK_MECHANISM_PTR mechanism,
-                                    CK_OBJECT_HANDLE key)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Encrypt__invalid_handle (CK_SESSION_HANDLE session,
-                                CK_BYTE_PTR data, CK_ULONG data_len,
-                                CK_BYTE_PTR encrypted_data,
-                                CK_ULONG_PTR encrypted_data_len)
-{
-	return_val_if_fail (encrypted_data_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_EncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
-                                      CK_BYTE_PTR part,
-                                      CK_ULONG part_len,
-                                      CK_BYTE_PTR encrypted_part,
-                                      CK_ULONG_PTR encrypted_part_len)
-{
-	return_val_if_fail (encrypted_part_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_EncryptFinal__invalid_handle (CK_SESSION_HANDLE session,
-                                     CK_BYTE_PTR last_part,
-                                     CK_ULONG_PTR last_part_len)
-{
-	return_val_if_fail (last_part_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DecryptInit__invalid_handle (CK_SESSION_HANDLE session,
-                                    CK_MECHANISM_PTR mechanism,
-                                    CK_OBJECT_HANDLE key)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Decrypt__invalid_handle (CK_SESSION_HANDLE session,
-                                CK_BYTE_PTR enc_data,
-                                CK_ULONG enc_data_len,
-                                CK_BYTE_PTR data,
-                                CK_ULONG_PTR data_len)
-{
-	return_val_if_fail (data_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DecryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
-                                      CK_BYTE_PTR enc_part,
-                                      CK_ULONG enc_part_len,
-                                      CK_BYTE_PTR part,
-                                      CK_ULONG_PTR part_len)
-{
-	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DecryptFinal__invalid_handle (CK_SESSION_HANDLE session,
-                                     CK_BYTE_PTR last_part,
-                                     CK_ULONG_PTR last_part_len)
-{
-	return_val_if_fail (last_part_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DigestInit__invalid_handle (CK_SESSION_HANDLE session,
-                                   CK_MECHANISM_PTR mechanism)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Digest__invalid_handle (CK_SESSION_HANDLE session,
-                               CK_BYTE_PTR data,
-                               CK_ULONG data_len,
-                               CK_BYTE_PTR digest,
-                               CK_ULONG_PTR digest_len)
-{
-	return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DigestUpdate__invalid_handle (CK_SESSION_HANDLE session,
-                                     CK_BYTE_PTR part,
-                                     CK_ULONG part_len)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DigestKey__invalid_handle (CK_SESSION_HANDLE session,
-                                  CK_OBJECT_HANDLE key)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DigestFinal__invalid_handle (CK_SESSION_HANDLE session,
-                                    CK_BYTE_PTR digest,
-                                    CK_ULONG_PTR digest_len)
-{
-	return_val_if_fail (digest_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SignInit__invalid_handle (CK_SESSION_HANDLE session,
-                                 CK_MECHANISM_PTR mechanism,
-                                 CK_OBJECT_HANDLE key)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Sign__invalid_handle (CK_SESSION_HANDLE session,
-                             CK_BYTE_PTR data,
-                             CK_ULONG data_len,
-                             CK_BYTE_PTR signature,
-                             CK_ULONG_PTR signature_len)
-{
-	return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SignUpdate__invalid_handle (CK_SESSION_HANDLE session,
-                                   CK_BYTE_PTR part,
-                                   CK_ULONG part_len)
-{
-	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SignFinal__invalid_handle (CK_SESSION_HANDLE session,
-                                  CK_BYTE_PTR signature,
-                                  CK_ULONG_PTR signature_len)
-{
-	return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SignRecoverInit__invalid_handle (CK_SESSION_HANDLE session,
-                                        CK_MECHANISM_PTR mechanism,
-                                        CK_OBJECT_HANDLE key)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SignRecover__invalid_handle (CK_SESSION_HANDLE session,
-                                    CK_BYTE_PTR data,
-                                    CK_ULONG data_len,
-                                    CK_BYTE_PTR signature,
-                                    CK_ULONG_PTR signature_len)
-{
-	return_val_if_fail (signature_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_VerifyInit__invalid_handle (CK_SESSION_HANDLE session,
-                                   CK_MECHANISM_PTR mechanism,
-                                   CK_OBJECT_HANDLE key)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_Verify__invalid_handle (CK_SESSION_HANDLE session,
-                               CK_BYTE_PTR data,
-                               CK_ULONG data_len,
-                               CK_BYTE_PTR signature,
-                               CK_ULONG signature_len)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_VerifyUpdate__invalid_handle (CK_SESSION_HANDLE session,
-                                     CK_BYTE_PTR part,
-                                     CK_ULONG part_len)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_VerifyFinal__invalid_handle (CK_SESSION_HANDLE session,
-                                    CK_BYTE_PTR signature,
-                                    CK_ULONG signature_len)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_VerifyRecoverInit__invalid_handle (CK_SESSION_HANDLE session,
-                                          CK_MECHANISM_PTR mechanism,
-                                          CK_OBJECT_HANDLE key)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_VerifyRecover__invalid_handle (CK_SESSION_HANDLE session,
-                                      CK_BYTE_PTR signature,
-                                      CK_ULONG signature_len,
-                                      CK_BYTE_PTR data,
-                                      CK_ULONG_PTR data_len)
-{
-	return_val_if_fail (data_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DigestEncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
-                                            CK_BYTE_PTR part,
-                           CK_ULONG part_len, CK_BYTE_PTR enc_part,
-                           CK_ULONG_PTR enc_part_len)
-{
-	return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DecryptDigestUpdate__invalid_handle (CK_SESSION_HANDLE session,
-                                            CK_BYTE_PTR enc_part,
-                                            CK_ULONG enc_part_len,
-                                            CK_BYTE_PTR part,
-                                            CK_ULONG_PTR part_len)
-{
-	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SignEncryptUpdate__invalid_handle (CK_SESSION_HANDLE session,
-                                          CK_BYTE_PTR part,
-                                          CK_ULONG part_len,
-                                          CK_BYTE_PTR enc_part,
-                                          CK_ULONG_PTR enc_part_len)
-{
-	return_val_if_fail (enc_part_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DecryptVerifyUpdate__invalid_handle (CK_SESSION_HANDLE session,
-                                            CK_BYTE_PTR enc_part,
-                                            CK_ULONG enc_part_len,
-                                            CK_BYTE_PTR part,
-                                            CK_ULONG_PTR part_len)
-{
-	return_val_if_fail (part_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GenerateKey__invalid_handle (CK_SESSION_HANDLE session,
-                                    CK_MECHANISM_PTR mechanism,
-                                    CK_ATTRIBUTE_PTR template,
-                                    CK_ULONG count,
-                                    CK_OBJECT_HANDLE_PTR key)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GenerateKeyPair__invalid_handle (CK_SESSION_HANDLE session,
-                                        CK_MECHANISM_PTR mechanism,
-                                        CK_ATTRIBUTE_PTR pub_template,
-                                        CK_ULONG pub_count,
-                                        CK_ATTRIBUTE_PTR priv_template,
-                                        CK_ULONG priv_count,
-                                        CK_OBJECT_HANDLE_PTR pub_key,
-                                        CK_OBJECT_HANDLE_PTR priv_key)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_WrapKey__invalid_handle (CK_SESSION_HANDLE session,
-                                CK_MECHANISM_PTR mechanism,
-                                CK_OBJECT_HANDLE wrapping_key,
-                                CK_OBJECT_HANDLE key,
-                                CK_BYTE_PTR wrapped_key,
-                                CK_ULONG_PTR wrapped_key_len)
-{
-	return_val_if_fail (wrapped_key_len, CKR_ARGUMENTS_BAD);
-
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_UnwrapKey__invalid_handle (CK_SESSION_HANDLE session,
-                                  CK_MECHANISM_PTR mechanism,
-                                  CK_OBJECT_HANDLE unwrapping_key,
-                                  CK_BYTE_PTR wrapped_key,
-                                  CK_ULONG wrapped_key_len,
-                                  CK_ATTRIBUTE_PTR template,
-                                  CK_ULONG count,
-                                  CK_OBJECT_HANDLE_PTR key)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_DeriveKey__invalid_handle (CK_SESSION_HANDLE session,
-                                  CK_MECHANISM_PTR mechanism,
-                                  CK_OBJECT_HANDLE base_key,
-                                  CK_ATTRIBUTE_PTR template,
-                                  CK_ULONG count,
-                                  CK_OBJECT_HANDLE_PTR key)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_SeedRandom__invalid_handle (CK_SESSION_HANDLE session,
-                                   CK_BYTE_PTR seed,
-                                   CK_ULONG seed_len)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_RV
-mock_C_GenerateRandom__invalid_handle (CK_SESSION_HANDLE session,
-                                       CK_BYTE_PTR random_data,
-                                       CK_ULONG random_len)
-{
-	return CKR_SESSION_HANDLE_INVALID;
-}
-
-CK_FUNCTION_LIST mock_module_no_slots = {
-	{ CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR },  /* version */
-	mock_C_Initialize,
-	mock_C_Finalize,
-	mock_C_GetInfo,
-	mock_C_GetFunctionList,
-	mock_C_GetSlotList__no_tokens,
-	mock_C_GetSlotInfo__invalid_slotid,
-	mock_C_GetTokenInfo__invalid_slotid,
-	mock_C_GetMechanismList__invalid_slotid,
-	mock_C_GetMechanismInfo__invalid_slotid,
-	mock_C_InitToken__invalid_slotid,
-	mock_C_InitPIN__invalid_handle,
-	mock_C_SetPIN__invalid_handle,
-	mock_C_OpenSession__invalid_slotid,
-	mock_C_CloseSession__invalid_handle,
-	mock_C_CloseAllSessions__invalid_slotid,
-	mock_C_GetSessionInfo__invalid_handle,
-	mock_C_GetOperationState__invalid_handle,
-	mock_C_SetOperationState__invalid_handle,
-	mock_C_Login__invalid_handle,
-	mock_C_Logout__invalid_handle,
-	mock_C_CreateObject__invalid_handle,
-	mock_C_CopyObject__invalid_handle,
-	mock_C_DestroyObject__invalid_handle,
-	mock_C_GetObjectSize__invalid_handle,
-	mock_C_GetAttributeValue__invalid_handle,
-	mock_C_SetAttributeValue__invalid_handle,
-	mock_C_FindObjectsInit__invalid_handle,
-	mock_C_FindObjects__invalid_handle,
-	mock_C_FindObjectsFinal__invalid_handle,
-	mock_C_EncryptInit__invalid_handle,
-	mock_C_Encrypt__invalid_handle,
-	mock_C_EncryptUpdate__invalid_handle,
-	mock_C_EncryptFinal__invalid_handle,
-	mock_C_DecryptInit__invalid_handle,
-	mock_C_Decrypt__invalid_handle,
-	mock_C_DecryptUpdate__invalid_handle,
-	mock_C_DecryptFinal__invalid_handle,
-	mock_C_DigestInit__invalid_handle,
-	mock_C_Digest__invalid_handle,
-	mock_C_DigestUpdate__invalid_handle,
-	mock_C_DigestKey__invalid_handle,
-	mock_C_DigestFinal__invalid_handle,
-	mock_C_SignInit__invalid_handle,
-	mock_C_Sign__invalid_handle,
-	mock_C_SignUpdate__invalid_handle,
-	mock_C_SignFinal__invalid_handle,
-	mock_C_SignRecoverInit__invalid_handle,
-	mock_C_SignRecover__invalid_handle,
-	mock_C_VerifyInit__invalid_handle,
-	mock_C_Verify__invalid_handle,
-	mock_C_VerifyUpdate__invalid_handle,
-	mock_C_VerifyFinal__invalid_handle,
-	mock_C_VerifyRecoverInit__invalid_handle,
-	mock_C_VerifyRecover__invalid_handle,
-	mock_C_DigestEncryptUpdate__invalid_handle,
-	mock_C_DecryptDigestUpdate__invalid_handle,
-	mock_C_SignEncryptUpdate__invalid_handle,
-	mock_C_DecryptVerifyUpdate__invalid_handle,
-	mock_C_GenerateKey__invalid_handle,
-	mock_C_GenerateKeyPair__invalid_handle,
-	mock_C_WrapKey__invalid_handle,
-	mock_C_UnwrapKey__invalid_handle,
-	mock_C_DeriveKey__invalid_handle,
-	mock_C_SeedRandom__invalid_handle,
-	mock_C_GenerateRandom__invalid_handle,
-	mock_C_GetFunctionStatus__not_parallel,
-	mock_C_CancelFunction__not_parallel,
-	mock_C_WaitForSlotEvent__no_event,
-};
-
-void
-mock_module_init (void)
-{
-	static bool initialized = false;
-	if (!initialized) {
-		p11_mutex_init (&init_mutex);
-		initialized = true;
-	}
-}
diff --git a/p11-kit/tests/mock-module.h b/p11-kit/tests/mock-module.h
deleted file mode 100644
index 9557f70..0000000
--- a/p11-kit/tests/mock-module.h
+++ /dev/null
@@ -1,337 +0,0 @@
-/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
-/* mock-module.c - a mock PKCS#11 module
-
-   Copyright (C) 2011 Collabora Ltd.
-
-   The Gnome Keyring Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
-
-   The Gnome Keyring Library 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
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with the Gnome Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.
-
-   Author: Stef Walter <stefw@collabora.co.uk>
-*/
-
-#ifndef __MOCK_MODULE_H__
-#define __MOCK_MODULE_H__
-
-#include "pkcs11.h"
-
-extern CK_FUNCTION_LIST    mock_module_no_slots;
-
-void        mock_module_init                              (void);
-
-CK_RV       mock_C_Initialize                             (CK_VOID_PTR init_args);
-
-CK_RV       mock_C_Finalize                               (CK_VOID_PTR reserved);
-
-CK_RV       mock_C_GetInfo                                (CK_INFO_PTR info);
-
-CK_RV       mock_C_GetFunctionList                        (CK_FUNCTION_LIST_PTR_PTR list);
-
-CK_RV       mock_C_GetSlotList__no_tokens                 (CK_BBOOL token_present,
-                                                           CK_SLOT_ID_PTR slot_list,
-                                                           CK_ULONG_PTR count);
-
-CK_RV       mock_C_GetSlotInfo__invalid_slotid            (CK_SLOT_ID id,
-                                                           CK_SLOT_INFO_PTR info);
-
-CK_RV       mock_C_GetTokenInfo__invalid_slotid           (CK_SLOT_ID id,
-                                                           CK_TOKEN_INFO_PTR info);
-
-CK_RV       mock_C_GetMechanismList__invalid_slotid       (CK_SLOT_ID id,
-                                                           CK_MECHANISM_TYPE_PTR mechanism_list,
-                                                           CK_ULONG_PTR count);
-
-CK_RV       mock_C_GetMechanismInfo__invalid_slotid       (CK_SLOT_ID id,
-                                                           CK_MECHANISM_TYPE type,
-                                                           CK_MECHANISM_INFO_PTR info);
-
-CK_RV       mock_C_InitToken__invalid_slotid              (CK_SLOT_ID id,
-                                                           CK_UTF8CHAR_PTR pin,
-                                                           CK_ULONG pin_len,
-                                                           CK_UTF8CHAR_PTR label);
-
-CK_RV       mock_C_WaitForSlotEvent__no_event             (CK_FLAGS flags,
-                                                           CK_SLOT_ID_PTR slot,
-                                                           CK_VOID_PTR reserved);
-
-CK_RV       mock_C_OpenSession__invalid_slotid            (CK_SLOT_ID id,
-                                                           CK_FLAGS flags,
-                                                           CK_VOID_PTR user_data,
-                                                           CK_NOTIFY callback,
-                                                           CK_SESSION_HANDLE_PTR session);
-
-CK_RV       mock_C_CloseSession__invalid_handle           (CK_SESSION_HANDLE session);
-
-CK_RV       mock_C_CloseAllSessions__invalid_slotid       (CK_SLOT_ID id);
-
-CK_RV       mock_C_GetFunctionStatus__not_parallel        (CK_SESSION_HANDLE session);
-
-CK_RV       mock_C_CancelFunction__not_parallel           (CK_SESSION_HANDLE session);
-
-CK_RV       mock_C_GetSessionInfo__invalid_handle         (CK_SESSION_HANDLE session,
-                                                           CK_SESSION_INFO_PTR info);
-
-CK_RV       mock_C_InitPIN__invalid_handle                (CK_SESSION_HANDLE session,
-                                                           CK_UTF8CHAR_PTR pin,
-                                                           CK_ULONG pin_len);
-
-CK_RV       mock_C_SetPIN__invalid_handle                 (CK_SESSION_HANDLE session,
-                                                           CK_UTF8CHAR_PTR old_pin,
-                                                           CK_ULONG old_pin_len,
-                                                           CK_UTF8CHAR_PTR new_pin,
-                                                           CK_ULONG new_pin_len);
-
-CK_RV       mock_C_GetOperationState__invalid_handle      (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR operation_state,
-                                                           CK_ULONG_PTR operation_state_len);
-
-CK_RV       mock_C_SetOperationState__invalid_handle      (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR operation_state,
-                                                           CK_ULONG operation_state_len,
-                                                           CK_OBJECT_HANDLE encryption_key,
-                                                           CK_OBJECT_HANDLE authentication_key);
-
-CK_RV       mock_C_Login__invalid_handle                  (CK_SESSION_HANDLE session,
-                                                           CK_USER_TYPE user_type,
-                                                           CK_UTF8CHAR_PTR pin,
-                                                           CK_ULONG pin_len);
-
-CK_RV       mock_C_Logout__invalid_handle                 (CK_SESSION_HANDLE session);
-
-CK_RV       mock_C_CreateObject__invalid_handle           (CK_SESSION_HANDLE session,
-                                                           CK_ATTRIBUTE_PTR template,
-                                                           CK_ULONG count,
-                                                           CK_OBJECT_HANDLE_PTR new_object);
-
-CK_RV       mock_C_CopyObject__invalid_handle             (CK_SESSION_HANDLE session,
-                                                           CK_OBJECT_HANDLE object,
-                                                           CK_ATTRIBUTE_PTR template,
-                                                           CK_ULONG count,
-                                                           CK_OBJECT_HANDLE_PTR new_object);
-
-CK_RV       mock_C_DestroyObject__invalid_handle          (CK_SESSION_HANDLE session,
-                                                           CK_OBJECT_HANDLE object);
-
-CK_RV       mock_C_GetObjectSize__invalid_handle          (CK_SESSION_HANDLE session,
-                                                           CK_OBJECT_HANDLE object,
-                                                           CK_ULONG_PTR size);
-
-CK_RV       mock_C_GetAttributeValue__invalid_handle      (CK_SESSION_HANDLE session,
-                                                           CK_OBJECT_HANDLE object,
-                                                           CK_ATTRIBUTE_PTR template,
-                                                           CK_ULONG count);
-
-CK_RV       mock_C_SetAttributeValue__invalid_handle      (CK_SESSION_HANDLE session,
-                                                           CK_OBJECT_HANDLE object,
-                                                           CK_ATTRIBUTE_PTR template,
-                                                           CK_ULONG count);
-
-CK_RV       mock_C_FindObjectsInit__invalid_handle        (CK_SESSION_HANDLE session,
-                                                           CK_ATTRIBUTE_PTR template,
-                                                           CK_ULONG count);
-
-CK_RV       mock_C_FindObjects__invalid_handle            (CK_SESSION_HANDLE session,
-                                                           CK_OBJECT_HANDLE_PTR objects,
-                                                           CK_ULONG max_count,
-                                                           CK_ULONG_PTR count);
-
-CK_RV       mock_C_FindObjectsFinal__invalid_handle       (CK_SESSION_HANDLE session);
-
-CK_RV       mock_C_EncryptInit__invalid_handle            (CK_SESSION_HANDLE session,
-                                                           CK_MECHANISM_PTR mechanism,
-                                                           CK_OBJECT_HANDLE key);
-
-CK_RV       mock_C_Encrypt__invalid_handle                (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR data,
-                                                           CK_ULONG data_len,
-                                                           CK_BYTE_PTR encrypted_data,
-                                                           CK_ULONG_PTR encrypted_data_len);
-
-CK_RV       mock_C_EncryptUpdate__invalid_handle          (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR part,
-                                                           CK_ULONG part_len,
-                                                           CK_BYTE_PTR encrypted_part,
-                                                           CK_ULONG_PTR encrypted_part_len);
-
-CK_RV       mock_C_EncryptFinal__invalid_handle           (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR last_part,
-                                                           CK_ULONG_PTR last_part_len);
-
-CK_RV       mock_C_DecryptInit__invalid_handle            (CK_SESSION_HANDLE session,
-                                                           CK_MECHANISM_PTR mechanism,
-                                                           CK_OBJECT_HANDLE key);
-
-CK_RV       mock_C_Decrypt__invalid_handle                (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR enc_data,
-                                                           CK_ULONG enc_data_len,
-                                                           CK_BYTE_PTR data,
-                                                           CK_ULONG_PTR data_len);
-
-CK_RV       mock_C_DecryptUpdate__invalid_handle          (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR enc_part,
-                                                           CK_ULONG enc_part_len,
-                                                           CK_BYTE_PTR part,
-                                                           CK_ULONG_PTR part_len);
-
-CK_RV       mock_C_DecryptFinal__invalid_handle           (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR last_part,
-                                                           CK_ULONG_PTR last_part_len);
-
-CK_RV       mock_C_DigestInit__invalid_handle             (CK_SESSION_HANDLE session,
-                                                           CK_MECHANISM_PTR mechanism);
-
-CK_RV       mock_C_Digest__invalid_handle                 (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR data,
-                                                           CK_ULONG data_len,
-                                                           CK_BYTE_PTR digest,
-                                                           CK_ULONG_PTR digest_len);
-
-CK_RV       mock_C_DigestUpdate__invalid_handle           (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR part,
-                                                           CK_ULONG part_len);
-
-CK_RV       mock_C_DigestKey__invalid_handle              (CK_SESSION_HANDLE session,
-                                                           CK_OBJECT_HANDLE key);
-
-CK_RV       mock_C_DigestFinal__invalid_handle            (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR digest,
-                                                           CK_ULONG_PTR digest_len);
-
-CK_RV       mock_C_SignInit__invalid_handle               (CK_SESSION_HANDLE session,
-                                                           CK_MECHANISM_PTR mechanism,
-                                                           CK_OBJECT_HANDLE key);
-
-CK_RV       mock_C_Sign__invalid_handle                   (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR data,
-                                                           CK_ULONG data_len,
-                                                           CK_BYTE_PTR signature,
-                                                           CK_ULONG_PTR signature_len);
-
-CK_RV       mock_C_SignUpdate__invalid_handle             (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR part,
-                                                           CK_ULONG part_len);
-
-CK_RV       mock_C_SignFinal__invalid_handle              (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR signature,
-                                                           CK_ULONG_PTR signature_len);
-
-CK_RV       mock_C_SignRecoverInit__invalid_handle        (CK_SESSION_HANDLE session,
-                                                           CK_MECHANISM_PTR mechanism,
-                                                           CK_OBJECT_HANDLE key);
-
-CK_RV       mock_C_SignRecover__invalid_handle            (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR data,
-                                                           CK_ULONG data_len,
-                                                           CK_BYTE_PTR signature,
-                                                           CK_ULONG_PTR signature_len);
-
-CK_RV       mock_C_VerifyInit__invalid_handle             (CK_SESSION_HANDLE session,
-                                                           CK_MECHANISM_PTR mechanism,
-                                                           CK_OBJECT_HANDLE key);
-
-CK_RV       mock_C_Verify__invalid_handle                 (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR data,
-                                                           CK_ULONG data_len,
-                                                           CK_BYTE_PTR signature,
-                                                           CK_ULONG signature_len);
-
-CK_RV       mock_C_VerifyUpdate__invalid_handle           (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR part,
-                                                           CK_ULONG part_len);
-
-CK_RV       mock_C_VerifyFinal__invalid_handle            (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR signature,
-                                                           CK_ULONG signature_len);
-
-CK_RV       mock_C_VerifyRecoverInit__invalid_handle      (CK_SESSION_HANDLE session,
-                                                           CK_MECHANISM_PTR mechanism,
-                                                           CK_OBJECT_HANDLE key);
-
-CK_RV       mock_C_VerifyRecover__invalid_handle          (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR signature,
-                                                           CK_ULONG signature_len,
-                                                           CK_BYTE_PTR data,
-                                                           CK_ULONG_PTR data_len);
-
-CK_RV       mock_C_DigestEncryptUpdate__invalid_handle    (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR part,
-                                                           CK_ULONG part_len,
-                                                           CK_BYTE_PTR enc_part,
-                                                           CK_ULONG_PTR enc_part_len);
-
-CK_RV       mock_C_DecryptDigestUpdate__invalid_handle    (CK_SESSION_HANDLE session,
-                                                           CK_BYTE_PTR enc_part,
-                                                           CK_ULONG enc_part_len,
-                                                           CK_BYTE_PTR part,
-                                                           CK_ULONG_PTR part_len);
-
-CK_RV       mock_C_SignEncryptUpdate__invalid_handle       (CK_SESSION_HANDLE session,
-                                                            CK_BYTE_PTR part,
-                                                            CK_ULONG part_len,
-                                                            CK_BYTE_PTR enc_part,
-                                                            CK_ULONG_PTR enc_part_len);
-
-CK_RV       mock_C_DecryptVerifyUpdate__invalid_handle     (CK_SESSION_HANDLE session,
-                                                            CK_BYTE_PTR enc_part,
-                                                            CK_ULONG enc_part_len,
-                                                            CK_BYTE_PTR part,
-                                                            CK_ULONG_PTR part_len);
-
-CK_RV       mock_C_GenerateKey__invalid_handle             (CK_SESSION_HANDLE session,
-                                                            CK_MECHANISM_PTR mechanism,
-                                                            CK_ATTRIBUTE_PTR template,
-                                                            CK_ULONG count,
-                                                            CK_OBJECT_HANDLE_PTR key);
-
-CK_RV       mock_C_GenerateKeyPair__invalid_handle         (CK_SESSION_HANDLE session,
-                                                            CK_MECHANISM_PTR mechanism,
-                                                            CK_ATTRIBUTE_PTR pub_template,
-                                                            CK_ULONG pub_count,
-                                                            CK_ATTRIBUTE_PTR priv_template,
-                                                            CK_ULONG priv_count,
-                                                            CK_OBJECT_HANDLE_PTR pub_key,
-                                                            CK_OBJECT_HANDLE_PTR priv_key);
-
-CK_RV       mock_C_WrapKey__invalid_handle                 (CK_SESSION_HANDLE session,
-                                                            CK_MECHANISM_PTR mechanism,
-                                                            CK_OBJECT_HANDLE wrapping_key,
-                                                            CK_OBJECT_HANDLE key,
-                                                            CK_BYTE_PTR wrapped_key,
-                                                            CK_ULONG_PTR wrapped_key_len);
-
-CK_RV       mock_C_UnwrapKey__invalid_handle               (CK_SESSION_HANDLE session,
-                                                            CK_MECHANISM_PTR mechanism,
-                                                            CK_OBJECT_HANDLE unwrapping_key,
-                                                            CK_BYTE_PTR wrapped_key,
-                                                            CK_ULONG wrapped_key_len,
-                                                            CK_ATTRIBUTE_PTR template,
-                                                            CK_ULONG count,
-                                                            CK_OBJECT_HANDLE_PTR key);
-
-CK_RV       mock_C_DeriveKey__invalid_handle               (CK_SESSION_HANDLE session,
-                                                            CK_MECHANISM_PTR mechanism,
-                                                            CK_OBJECT_HANDLE base_key,
-                                                            CK_ATTRIBUTE_PTR template,
-                                                            CK_ULONG count,
-                                                            CK_OBJECT_HANDLE_PTR key);
-
-CK_RV       mock_C_SeedRandom__invalid_handle              (CK_SESSION_HANDLE session,
-                                                            CK_BYTE_PTR seed,
-                                                            CK_ULONG seed_len);
-
-CK_RV       mock_C_GenerateRandom__invalid_handle          (CK_SESSION_HANDLE session,
-                                                            CK_BYTE_PTR random_data,
-                                                            CK_ULONG random_len);
-
-#endif /* __MOCK_MODULE_H__ */
diff --git a/p11-kit/tests/test-init.c b/p11-kit/tests/test-init.c
index 7664666..1c13b15 100644
--- a/p11-kit/tests/test-init.c
+++ b/p11-kit/tests/test-init.c
@@ -48,7 +48,7 @@
 
 #include "p11-kit/p11-kit.h"
 
-#include "mock-module.h"
+#include "mock.h"
 
 CK_FUNCTION_LIST module;
 
@@ -281,7 +281,7 @@ test_load_and_initialize (CuTest *tc)
 	rv = (module->C_GetInfo) (&info);
 	CuAssertTrue (tc, rv == CKR_OK);
 
-	ret = memcmp (info.manufacturerID, "MOCK MANUFACTURER              ", 32);
+	ret = memcmp (info.manufacturerID, "MOCK MANUFACTURER               ", 32);
 	CuAssertTrue (tc, ret == 0);
 
 	rv = p11_kit_finalize_module (module);