Modernize the remainder of the tests.

 * Bring up to date with gtester running and individual binaries.
 * Make the tests run in make distcheck

25 files changed, 2148 insertions, 1816 deletions

diff --git a/pkcs11/secret-store/gkm-secret-binary.c b/pkcs11/secret-store/gkm-secret-binary.c
index 942ffe7b..29cd9cdc 100644
--- a/pkcs11/secret-store/gkm-secret-binary.c
+++ b/pkcs11/secret-store/gkm-secret-binary.c
@@ -561,7 +561,7 @@ generate_hashed_items (GkmSecretCollection *collection, EggBuffer *buffer)
 
 GkmDataResult
 gkm_secret_binary_write (GkmSecretCollection *collection, GkmSecretData *sdata,
-                         guchar **data, gsize *n_data)
+                         gpointer *data, gsize *n_data)
 {
 	GkmSecretObject *obj;
 	EggBuffer to_encrypt;
@@ -843,7 +843,7 @@ free_item_info (ItemInfo *info)
 
 gint
 gkm_secret_binary_read (GkmSecretCollection *collection, GkmSecretData *sdata,
-                        const guchar *data, gsize n_data)
+                        gconstpointer data, gsize n_data)
 {
 	gsize offset;
 	guchar major, minor, crypto, hash;
diff --git a/pkcs11/secret-store/gkm-secret-binary.h b/pkcs11/secret-store/gkm-secret-binary.h
index 05cc0643..a150f1be 100644
--- a/pkcs11/secret-store/gkm-secret-binary.h
+++ b/pkcs11/secret-store/gkm-secret-binary.h
@@ -29,12 +29,12 @@
 
 GkmDataResult          gkm_secret_binary_read        (GkmSecretCollection *collection,
                                                       GkmSecretData *sdata,
-                                                      const guchar *data,
+                                                      gconstpointer data,
                                                       gsize n_data);
 
 GkmDataResult          gkm_secret_binary_write       (GkmSecretCollection *collection,
                                                       GkmSecretData *sdata,
-                                                      guchar **data,
+                                                      gpointer *data,
                                                       gsize *n_data);
 
 #endif /* __GKM_SECRET_BINARY_H__ */
diff --git a/pkcs11/secret-store/gkm-secret-collection.c b/pkcs11/secret-store/gkm-secret-collection.c
index 1157255d..0aedc5c9 100644
--- a/pkcs11/secret-store/gkm-secret-collection.c
+++ b/pkcs11/secret-store/gkm-secret-collection.c
@@ -888,7 +888,7 @@ gkm_secret_collection_save (GkmSecretCollection *self, GkmTransaction *transacti
 {
 	GkmSecret *master;
 	GkmDataResult res;
-	guchar *data;
+	gpointer data;
 	gsize n_data;
 
 	g_return_if_fail (GKM_IS_SECRET_COLLECTION (self));
diff --git a/pkcs11/secret-store/gkm-secret-textual.c b/pkcs11/secret-store/gkm-secret-textual.c
index 8d671173..af7bc372 100644
--- a/pkcs11/secret-store/gkm-secret-textual.c
+++ b/pkcs11/secret-store/gkm-secret-textual.c
@@ -380,7 +380,7 @@ parse_item (GKeyFile *file, GkmSecretItem *item, GkmSecretData *sdata,
 
 GkmDataResult
 gkm_secret_textual_write (GkmSecretCollection *collection, GkmSecretData *sdata,
-                          guchar **data, gsize *n_data)
+                          gpointer *data, gsize *n_data)
 {
 	GkmSecretObject *obj;
 	GList *items, *l;
@@ -445,7 +445,7 @@ remove_unavailable_item (gpointer key, gpointer dummy, gpointer user_data)
 
 GkmDataResult
 gkm_secret_textual_read (GkmSecretCollection *collection, GkmSecretData *sdata,
-                         const guchar *data, gsize n_data)
+                         gconstpointer data, gsize n_data)
 {
 	GkmSecretObject *obj;
 	GkmSecretItem *item;
diff --git a/pkcs11/secret-store/gkm-secret-textual.h b/pkcs11/secret-store/gkm-secret-textual.h
index bb96e8ce..ca568e38 100644
--- a/pkcs11/secret-store/gkm-secret-textual.h
+++ b/pkcs11/secret-store/gkm-secret-textual.h
@@ -28,12 +28,12 @@
 
 GkmDataResult          gkm_secret_textual_read       (GkmSecretCollection *collection,
                                                       GkmSecretData *sdata,
-                                                      const guchar *data,
+                                                      gconstpointer data,
                                                       gsize n_data);
 
 GkmDataResult          gkm_secret_textual_write      (GkmSecretCollection *collection,
                                                       GkmSecretData *sdata,
-                                                      guchar **data,
+                                                      gpointer *data,
                                                       gsize *n_data);
 
 #endif /* __GKM_SECRET_TEXTUAL_H__ */
diff --git a/pkcs11/secret-store/tests/Makefile.am b/pkcs11/secret-store/tests/Makefile.am
index ff14313b..814bcc5c 100644
--- a/pkcs11/secret-store/tests/Makefile.am
+++ b/pkcs11/secret-store/tests/Makefile.am
@@ -1,25 +1,44 @@
-TESTING_SOURCES = \
-	test-secret-module.c test-secret-module.h
-
-TESTING_FILES = \
-	unit-test-secret-compat.c \
-	unit-test-secret-fields.c \
-	unit-test-secret-data.c \
-	unit-test-secret-object.c \
-	unit-test-secret-collection.c \
-	unit-test-secret-item.c \
-	unit-test-secret-search.c \
-	unit-test-secret-textual.c \
-	unit-test-secret-binary.c
-
-UNIT_PROMPT =
-
-TESTING_LIBS =  \
+
+INCLUDES = \
+	-I$(top_builddir) \
+	-I$(top_srcdir) \
+	-I$(top_srcdir)/pkcs11 \
+	-DSRCDIR="\"$(srcdir)\"" \
+	$(GLIB_CFLAGS) \
+	$(LIBGCRYPT_CFLAGS)
+
+LDADD = \
+	libgkm-mock-secret-module.a \
 	$(top_builddir)/pkcs11/secret-store/libgkm-secret-store.la \
 	$(top_builddir)/pkcs11/gkm/libgkm.la \
-	$(top_builddir)/egg/libegg.la
+	$(top_builddir)/egg/libegg.la \
+	$(GLIB_LIBS) \
+	$(LIBGCRYPT_LIBS)
+
+noinst_LIBRARIES = libgkm-mock-secret-module.a
+
+libgkm_mock_secret_module_a_SOURCES = \
+	mock-secret-module.c mock-secret-module.h
+
+TEST_PROGS = \
+	test-secret-compat \
+	test-secret-fields \
+	test-secret-data \
+	test-secret-object \
+	test-secret-collection \
+	test-secret-item \
+	test-secret-search \
+	test-secret-textual \
+	test-secret-binary
+
+check_PROGRAMS = $(TEST_PROGS)
+
+test: $(TEST_PROGS)
+	gtester -k --verbose -m $(TEST_MODE) --g-fatal-warnings $(TEST_PROGS)
+
+check-local: test
 
-include $(top_srcdir)/testing/testing.make
+all-local: $(check_PROGRAMS)
 
-EXTRA_DIST += \
-	test-data
+EXTRA_DIST = \
+	files
diff --git a/pkcs11/secret-store/tests/test-data/encrypted.keyring b/pkcs11/secret-store/tests/files/encrypted.keyring
index 742aecc3..742aecc3 100644
--- a/pkcs11/secret-store/tests/test-data/encrypted.keyring
+++ b/pkcs11/secret-store/tests/files/encrypted.keyring
diff --git a/pkcs11/secret-store/tests/test-data/plain-bad-number.keyring b/pkcs11/secret-store/tests/files/plain-bad-number.keyring
index e5ff5ac9..e5ff5ac9 100644
--- a/pkcs11/secret-store/tests/test-data/plain-bad-number.keyring
+++ b/pkcs11/secret-store/tests/files/plain-bad-number.keyring
diff --git a/pkcs11/secret-store/tests/test-data/plain.keyring b/pkcs11/secret-store/tests/files/plain.keyring
index c048aa10..c048aa10 100644
--- a/pkcs11/secret-store/tests/test-data/plain.keyring
+++ b/pkcs11/secret-store/tests/files/plain.keyring
diff --git a/pkcs11/secret-store/tests/test-secret-module.c b/pkcs11/secret-store/tests/mock-secret-module.c
index 3215c81b..6cb698c0 100644
--- a/pkcs11/secret-store/tests/test-secret-module.c
+++ b/pkcs11/secret-store/tests/mock-secret-module.c
@@ -22,26 +22,54 @@
 */
 
 #include "config.h"
-#include "test-secret-module.h"
-#include "test-suite.h"
+
+#include "mock-secret-module.h"
 
 #include "gkm/gkm-secret.h"
 #include "gkm/gkm-module.h"
 
-#include "gkm-secret-collection.h"
-#include "gkm-secret-data.h"
-#include "gkm-secret-fields.h"
-#include "gkm-secret-item.h"
-#include "gkm-secret-object.h"
-#include "gkm-secret-store.h"
+#include "secret-store/gkm-secret-collection.h"
+#include "secret-store/gkm-secret-data.h"
+#include "secret-store/gkm-secret-fields.h"
+#include "secret-store/gkm-secret-item.h"
+#include "secret-store/gkm-secret-object.h"
+#include "secret-store/gkm-secret-store.h"
+
+#include "egg/egg-mkdtemp.h"
+#include "egg/egg-secure-memory.h"
+
+#include <glib.h>
 
 #include <string.h>
 
+EGG_SECURE_GLIB_DEFINITIONS ();
+
 static GMutex *mutex = NULL;
+static gchar *directory = NULL;
 
 GkmModule*  _gkm_secret_store_get_module_for_testing (void);
 GMutex* _gkm_module_get_scary_mutex_that_you_should_not_touch (GkmModule *module);
 
+static void
+copy_file_to_directory (const gchar *from, const gchar *directory)
+{
+	gchar *filename;
+	gchar *basename;
+	gchar *data;
+	gsize n_data;
+
+	if (!g_file_get_contents (from, &data, &n_data, NULL))
+		g_error ("couldn't read: %s", from);
+
+	basename = g_path_get_basename (from);
+	filename = g_build_filename (directory, basename, NULL);
+	if (!g_file_set_contents (filename, data, n_data, NULL))
+		g_error ("couldn't write: %s", filename);
+	g_free (filename);
+	g_free (basename);
+	g_free (data);
+}
+
 GkmModule*
 test_secret_module_initialize_and_enter (void)
 {
@@ -51,15 +79,17 @@ test_secret_module_initialize_and_enter (void)
 	gchar *string;
 	CK_RV rv;
 
+	directory = egg_mkdtemp (g_strdup ("/tmp/mock-secret-XXXXXX"));
+
 	/* Setup test directory to work in */
 	memset (&args, 0, sizeof (args));
-	string = g_strdup_printf ("directory='%s'", testing_scratch_directory ());
+	string = g_strdup_printf ("directory='%s'", directory);
 	args.pReserved = string;
 	args.flags = CKF_OS_LOCKING_OK;
 
 	/* Copy files from test-data to scratch */
-	testing_data_to_scratch ("encrypted.keyring", NULL);
-	testing_data_to_scratch ("plain.keyring", NULL);
+	copy_file_to_directory (SRCDIR "/files/encrypted.keyring", directory);
+	copy_file_to_directory (SRCDIR "/files/plain.keyring", directory);
 
 	funcs = gkm_secret_store_get_functions ();
 	rv = (funcs->C_Initialize) (&args);
@@ -87,6 +117,9 @@ test_secret_module_leave_and_finalize (void)
 	funcs = gkm_secret_store_get_functions ();
 	rv = (funcs->C_Finalize) (NULL);
 	g_return_if_fail (rv == CKR_OK);
+
+	g_free (directory);
+	directory = NULL;
 }
 
 void
diff --git a/pkcs11/secret-store/tests/test-secret-module.h b/pkcs11/secret-store/tests/mock-secret-module.h
index 46413e3d..72afc154 100644
--- a/pkcs11/secret-store/tests/test-secret-module.h
+++ b/pkcs11/secret-store/tests/mock-secret-module.h
@@ -27,7 +27,8 @@
 #include <glib.h>
 
 #include "gkm/gkm-types.h"
-#include "gkm-secret-types.h"
+
+#include "secret-store/gkm-secret-types.h"
 
 #include "pkcs11.h"
 
diff --git a/pkcs11/secret-store/tests/test-secret-binary.c b/pkcs11/secret-store/tests/test-secret-binary.c
new file mode 100644
index 00000000..6f2e71d4
--- /dev/null
+++ b/pkcs11/secret-store/tests/test-secret-binary.c
@@ -0,0 +1,222 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* test-secret-binary.c: Test binary keyring read and write
+
+   Copyright (C) 2009 Stefan Walter
+
+   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 <stef@memberwebs.com>
+*/
+
+#include "config.h"
+
+#include "mock-secret-module.h"
+
+#include "secret-store/gkm-secret-binary.h"
+#include "secret-store/gkm-secret-collection.h"
+#include "secret-store/gkm-secret-data.h"
+#include "secret-store/gkm-secret-fields.h"
+#include "secret-store/gkm-secret-item.h"
+
+#include "gkm/gkm-secret.h"
+
+#include "pkcs11/pkcs11i.h"
+
+#include <glib.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct {
+	GkmModule *module;
+	GkmSession *session;
+	GkmSecretCollection *collection;
+	GkmSecretData *sdata;
+} Test;
+
+static void
+setup (Test *test, gconstpointer unused)
+{
+	GkmSecret *master;
+
+	test->module = test_secret_module_initialize_and_enter ();
+	test->session = test_secret_module_open_session (TRUE);
+
+	test->collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
+	                           "module", test->module,
+	                           "identifier", "test",
+	                           "label", "brigadooooooooooooon",
+	                           NULL);
+
+	test->sdata = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
+	master = gkm_secret_new_from_password ("my-keyring-password");
+	gkm_secret_data_set_master (test->sdata, master);
+	g_object_unref (master);
+
+	g_assert (GKM_IS_SECRET_COLLECTION (test->collection));
+
+}
+
+static void
+teardown (Test *test, gconstpointer unused)
+{
+	g_object_unref (test->collection);
+	g_object_unref (test->sdata);
+	test_secret_module_leave_and_finalize ();
+}
+
+static void
+test_read (Test *test, gconstpointer unused)
+{
+	GkmDataResult res;
+	gchar *data;
+	gsize n_data;
+
+	if (!g_file_get_contents (SRCDIR "/files/encrypted.keyring", &data, &n_data, NULL))
+		g_assert_not_reached ();
+	res = gkm_secret_binary_read (test->collection, test->sdata, data, n_data);
+	g_free (data);
+
+	test_secret_collection_validate (test->collection, test->sdata);
+
+	g_assert (res == GKM_DATA_SUCCESS);
+}
+
+static void
+test_read_wrong_format (Test *test, gconstpointer unused)
+{
+	GkmDataResult res;
+	gchar *data;
+	gsize n_data;
+
+	if (!g_file_get_contents (SRCDIR "/files/plain.keyring", &data, &n_data, NULL))
+		g_assert_not_reached ();
+	res = gkm_secret_binary_read (test->collection, test->sdata, data, n_data);
+	g_free (data);
+
+	g_assert (res == GKM_DATA_UNRECOGNIZED);
+}
+
+static void
+test_read_wrong_master (Test *test, gconstpointer unused)
+{
+	GkmDataResult res;
+	GkmSecret *master;
+	gchar *data;
+	gsize n_data;
+
+	master = gkm_secret_new_from_password ("wrong");
+	gkm_secret_data_set_master (test->sdata, master);
+	g_object_unref (master);
+
+	if (!g_file_get_contents (SRCDIR "/files/encrypted.keyring", &data, &n_data, NULL))
+		g_assert_not_reached ();
+	res = gkm_secret_binary_read (test->collection, test->sdata, data, n_data);
+	g_free (data);
+
+	g_assert (res == GKM_DATA_LOCKED);
+}
+
+static void
+test_read_sdata_but_no_master (Test *test, gconstpointer unused)
+{
+	GkmDataResult res;
+	gchar *data;
+	gsize n_data;
+
+	gkm_secret_data_set_master (test->sdata, NULL);
+
+	if (!g_file_get_contents (SRCDIR "/files/encrypted.keyring", &data, &n_data, NULL))
+		g_assert_not_reached ();
+	res = gkm_secret_binary_read (test->collection, test->sdata, data, n_data);
+	g_free (data);
+
+	g_assert (res == GKM_DATA_LOCKED);
+}
+
+static void
+test_write (Test *test, gconstpointer unused)
+{
+	GkmDataResult res;
+	gpointer data;
+	gsize n_data;
+
+	test_secret_collection_populate (test->collection, test->sdata);
+
+	res = gkm_secret_binary_write (test->collection, test->sdata, &data, &n_data);
+	g_assert (res == GKM_DATA_SUCCESS);
+	g_assert (data);
+	g_assert (n_data);
+
+	/* Try parsing it again */
+	res = gkm_secret_binary_read (test->collection, test->sdata, data, n_data);
+	g_assert (res == GKM_DATA_SUCCESS);
+}
+
+static void
+test_remove_unavailable (Test *test, gconstpointer unused)
+{
+	GkmDataResult res;
+	GList *items;
+	gchar *data;
+	gsize n_data;
+
+	if (!g_file_get_contents (SRCDIR "/files/encrypted.keyring", &data, &n_data, NULL))
+		g_assert_not_reached ();
+	res = gkm_secret_binary_read (test->collection, test->sdata, data, n_data);
+	g_assert (res == GKM_DATA_SUCCESS);
+
+	/* Two items from the file */
+	items = gkm_secret_collection_get_items (test->collection);
+	g_assert_cmpint (g_list_length (items), ==, 2);
+	g_list_free (items);
+
+	/* Fill in some more data */
+	test_secret_collection_populate (test->collection, test->sdata);
+
+	/* Should have added three more */
+	items = gkm_secret_collection_get_items (test->collection);
+	g_assert_cmpint (g_list_length (items), ==, 5);
+	g_list_free (items);
+
+	/* Re-read the keyring */
+	res = gkm_secret_binary_read (test->collection, test->sdata, data, n_data);
+	g_assert (res == GKM_DATA_SUCCESS);
+
+	/* And we're back to two */
+	items = gkm_secret_collection_get_items (test->collection);
+	g_assert_cmpint (g_list_length (items), ==, 2);
+	g_list_free (items);
+
+	g_free (data);
+}
+
+int
+main (int argc, char **argv)
+{
+	g_type_init ();
+	g_test_init (&argc, &argv, NULL);
+
+	g_test_add ("/secret-store/binary/read", Test, NULL, setup, test_read, teardown);
+	g_test_add ("/secret-store/binary/read_wrong_format", Test, NULL, setup, test_read_wrong_format, teardown);
+	g_test_add ("/secret-store/binary/read_wrong_master", Test, NULL, setup, test_read_wrong_master, teardown);
+	g_test_add ("/secret-store/binary/read_sdata_but_no_master", Test, NULL, setup, test_read_sdata_but_no_master, teardown);
+	g_test_add ("/secret-store/binary/write", Test, NULL, setup, test_write, teardown);
+	g_test_add ("/secret-store/binary/remove_unavailable", Test, NULL, setup, test_remove_unavailable, teardown);
+
+	return g_test_run ();
+}
diff --git a/pkcs11/secret-store/tests/test-secret-collection.c b/pkcs11/secret-store/tests/test-secret-collection.c
new file mode 100644
index 00000000..203d8abe
--- /dev/null
+++ b/pkcs11/secret-store/tests/test-secret-collection.c
@@ -0,0 +1,598 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* test-secret-test->collection.c: Test the test->collection keyring
+
+   Copyright (C) 2009 Stefan Walter
+
+   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 <stef@memberwebs.com>
+*/
+
+#include "config.h"
+
+#include "mock-secret-module.h"
+
+#include "secret-store/gkm-secret-data.h"
+#include "secret-store/gkm-secret-collection.h"
+#include "secret-store/gkm-secret-item.h"
+
+#include "gkm/gkm-credential.h"
+#include "gkm/gkm-session.h"
+#include "gkm/gkm-transaction.h"
+
+#include "pkcs11/pkcs11i.h"
+
+#include <glib.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct {
+	GkmModule *module;
+	GkmSession *session;
+	CK_OBJECT_HANDLE credential;
+	CK_OBJECT_HANDLE credential2;
+	GkmSecretCollection *collection;
+} Test;
+
+static void
+setup (Test *test, gconstpointer unused)
+{
+	CK_OBJECT_CLASS klass = CKO_G_CREDENTIAL;
+	GkmObject *cred;
+
+	CK_ATTRIBUTE attrs[] = {
+		{ CKA_CLASS, &klass, sizeof (klass) },
+		{ CKA_VALUE, NULL, 0 }
+	};
+
+	test->module = test_secret_module_initialize_and_enter ();
+	test->session = test_secret_module_open_session (TRUE);
+
+	test->collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
+	                           "module", test->module,
+	                           "identifier", "test",
+	                           NULL);
+	g_assert (GKM_IS_SECRET_COLLECTION (test->collection));
+
+	/* Make two credentials */
+	cred = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_CREDENTIAL, NULL,
+	                                            attrs, G_N_ELEMENTS (attrs));
+	g_assert (cred != NULL);
+	test->credential = gkm_object_get_handle (GKM_OBJECT (cred));
+	g_object_unref (cred);
+
+	cred = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_CREDENTIAL, NULL,
+	                                            attrs, G_N_ELEMENTS (attrs));
+	g_assert (cred != NULL);
+	test->credential2 = gkm_object_get_handle (GKM_OBJECT (cred));
+	g_object_unref (cred);
+}
+
+static void
+teardown (Test *test, gconstpointer unused)
+{
+	if (test->collection)
+		g_object_unref (test->collection);
+	test->collection = NULL;
+
+	test_secret_module_leave_and_finalize ();
+	test->module = NULL;
+	test->session = NULL;
+	test->credential = 0;
+}
+
+static void
+test_is_locked (Test *test, gconstpointer unused)
+{
+	gboolean locked;
+
+	/* By default is locked */
+	locked = gkm_secret_object_is_locked (GKM_SECRET_OBJECT (test->collection), test->session);
+	g_assert (locked == TRUE);
+}
+
+static void
+test_unlocked_data (Test *test, gconstpointer unused)
+{
+	GkmCredential *cred;
+	GkmSecretData *sdata;
+	CK_RV rv;
+
+	/* Create test->credential, which unlocks test->collection */
+	rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection), NULL, 0, &cred);
+	g_assert (rv == CKR_OK);
+	gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
+	g_object_unref (cred);
+
+	/* Collection should now be unlocked */
+	sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
+	g_assert (GKM_IS_SECRET_DATA (sdata));
+	g_assert (!gkm_secret_object_is_locked (GKM_SECRET_OBJECT (test->collection), test->session));
+	g_object_unref (sdata);
+}
+
+static void
+test_get_filename (Test *test, gconstpointer unused)
+{
+	GkmSecretCollection *other;
+	const gchar *filename;
+
+	other = g_object_new (GKM_TYPE_SECRET_COLLECTION,
+	                      "module", test->module,
+	                      "identifier", "test",
+	                      "filename", "/tmp/filename.keyring",
+	                      NULL);
+
+	filename = gkm_secret_collection_get_filename (other);
+	g_assert_cmpstr (filename, ==, "/tmp/filename.keyring");
+
+	g_object_unref (other);
+}
+
+static void
+test_set_filename (Test *test, gconstpointer unused)
+{
+	const gchar *filename;
+
+	gkm_secret_collection_set_filename (test->collection, "/tmp/filename.keyring");
+
+	filename = gkm_secret_collection_get_filename (test->collection);
+	g_assert_cmpstr (filename, ==, "/tmp/filename.keyring");
+}
+
+static void
+test_has_item (Test *test, gconstpointer unused)
+{
+	GkmSecretItem *item;
+
+	item = gkm_secret_collection_new_item (test->collection, "testo");
+	g_assert (gkm_secret_collection_has_item (test->collection, item));
+}
+
+static void
+test_load_unlock_plain (Test *test, gconstpointer unused)
+{
+	GkmCredential *cred;
+	GkmSecretData *sdata;
+	GkmDataResult res;
+	CK_RV rv;
+
+	gkm_secret_collection_set_filename (test->collection, SRCDIR "/files/plain.keyring");
+
+	/* Load the data in the file */
+	res = gkm_secret_collection_load (test->collection);
+	g_assert (res == GKM_DATA_SUCCESS);
+
+	/* Unlock the keyring, which should load again */
+	rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection), NULL, 0, &cred);
+	g_assert (rv == CKR_OK);
+	gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
+	g_object_unref (cred);
+
+	sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
+	g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
+	test_secret_collection_validate (test->collection, sdata);
+	g_object_unref (sdata);
+}
+
+static void
+test_load_unlock_encrypted (Test *test, gconstpointer unused)
+{
+	GkmCredential *cred;
+	GkmSecretData *sdata;
+	GkmDataResult res;
+	CK_RV rv;
+
+	gkm_secret_collection_set_filename (test->collection, SRCDIR "/files/encrypted.keyring");
+
+	/* Load the data in the file */
+	res = gkm_secret_collection_load (test->collection);
+	g_assert (res == GKM_DATA_SUCCESS);
+
+	/* Unlock the keyring, which should load again */
+	rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
+	                            (guchar*)"my-keyring-password", 19, &cred);
+	g_assert (rv == CKR_OK);
+	gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
+	g_object_unref (cred);
+
+	sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
+	g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
+	test_secret_collection_validate (test->collection, sdata);
+	g_object_unref (sdata);
+}
+
+static void
+test_load_unlock_bad_password (Test *test, gconstpointer unused)
+{
+	GkmCredential *cred;
+	GkmDataResult res;
+	CK_RV rv;
+
+	gkm_secret_collection_set_filename (test->collection, SRCDIR "/files/encrypted.keyring");
+
+	/* Load the data in the file */
+	res = gkm_secret_collection_load (test->collection);
+	g_assert (res == GKM_DATA_SUCCESS);
+
+	/* Unlock the keyring, which should load again */
+	rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
+	                            (guchar*)"wrong", 5, &cred);
+	g_assert (rv == CKR_PIN_INCORRECT);
+}
+
+static void
+test_unlock_without_load (Test *test, gconstpointer unused)
+{
+	GkmCredential *cred;
+	GkmSecretData *sdata;
+	CK_RV rv;
+
+	gkm_secret_collection_set_filename (test->collection, SRCDIR "/files/encrypted.keyring");
+
+	/* Unlock the keyring, which should load it */
+	rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
+	                            (guchar*)"my-keyring-password", 19, &cred);
+	g_assert (rv == CKR_OK);
+	gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
+	g_object_unref (cred);
+
+	sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
+	g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
+	test_secret_collection_validate (test->collection, sdata);
+	g_object_unref (sdata);
+}
+
+static void
+test_twice_unlock (Test *test, gconstpointer unused)
+{
+	GkmCredential *cred;
+	GkmSecretData *sdata;
+	CK_RV rv;
+
+	gkm_secret_collection_set_filename (test->collection, SRCDIR "/files/encrypted.keyring");
+
+	/* Unlock the keyring, which should load */
+	rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
+	                            (guchar*)"my-keyring-password", 19, &cred);
+	g_assert (rv == CKR_OK);
+	gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
+	g_object_unref (cred);
+
+	/* Unlock the keyring again, which should not reload */
+	rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
+	                            (guchar*)"my-keyring-password", 19, &cred);
+	g_assert (rv == CKR_OK);
+	gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
+	g_object_unref (cred);
+
+	sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
+	g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
+	test_secret_collection_validate (test->collection, sdata);
+	g_object_unref (sdata);
+}
+
+static void
+test_twice_unlock_bad_password (Test *test, gconstpointer unused)
+{
+	GkmCredential *cred;
+	GkmSecretData *sdata;
+	CK_RV rv;
+
+	gkm_secret_collection_set_filename (test->collection, SRCDIR "/files/encrypted.keyring");
+
+	/* Unlock the keyring, which should load */
+	rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
+	                               (guchar*)"my-keyring-password", 19, &cred);
+	g_assert (rv == CKR_OK);
+	gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
+	g_object_unref (cred);
+
+	/* Unlock the keyring again, wrong password */
+	rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
+	                            (guchar*)"wrong", 5, &cred);
+	g_assert (rv == CKR_PIN_INCORRECT);
+
+	sdata = gkm_secret_collection_unlocked_use (test->collection, test->session);
+	g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
+	test_secret_collection_validate (test->collection, sdata);
+	g_object_unref (sdata);
+}
+
+static void
+test_memory_unlock (Test *test, gconstpointer unused)
+{
+	GkmCredential *cred;
+	GkmDataResult res;
+	CK_RV rv;
+
+	/* Load the data in the file */
+	res = gkm_secret_collection_load (test->collection);
+	g_assert (res == GKM_DATA_SUCCESS);
+
+	/* Unlock the keyring, which should load again */
+	rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
+	                            NULL, 0, &cred);
+	g_assert (rv == CKR_OK);
+	gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
+	g_object_unref (cred);
+}
+
+static void
+test_memory_unlock_bad_password (Test *test, gconstpointer unused)
+{
+	GkmCredential *cred;
+	GkmDataResult res;
+	CK_RV rv;
+
+	/* Load the data in the file */
+	res = gkm_secret_collection_load (test->collection);
+	g_assert (res == GKM_DATA_SUCCESS);
+
+	/* Unlock the keyring, which should load again */
+	rv = gkm_credential_create (test->module, gkm_session_get_manager (test->session), GKM_OBJECT (test->collection),
+	                            (guchar*)"wrong", 5, &cred);
+	g_assert (rv == CKR_PIN_INCORRECT);
+}
+
+static void
+test_factory (Test *test, gconstpointer unused)
+{
+	CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
+	GkmObject *object;
+
+	CK_ATTRIBUTE attrs[] = {
+		{ CKA_CLASS, &klass, sizeof (klass) },
+		{ CKA_LABEL, "blah", 4 },
+		{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
+	};
+
+	object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
+	                                                attrs, G_N_ELEMENTS (attrs));
+	g_assert (object != NULL);
+	g_assert (GKM_IS_SECRET_COLLECTION (object));
+
+	g_assert_cmpstr (gkm_secret_object_get_label (GKM_SECRET_OBJECT (object)), ==, "blah");
+	g_object_unref (object);
+}
+
+static void
+test_factory_unnamed (Test *test, gconstpointer unused)
+{
+	CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
+	const gchar *identifier;
+	GkmObject *object;
+
+	CK_ATTRIBUTE attrs[] = {
+		{ CKA_CLASS, &klass, sizeof (klass) },
+		{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
+	};
+
+	object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
+	                                                attrs, G_N_ELEMENTS (attrs));
+	g_assert (object != NULL);
+	g_assert (GKM_IS_SECRET_COLLECTION (object));
+
+	identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
+	g_assert_cmpstr (identifier, !=, "");
+	g_object_unref (object);
+}
+
+static void
+test_factory_token (Test *test, gconstpointer unused)
+{
+	CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
+	const gchar *identifier;
+	GkmObject *object;
+	CK_BBOOL token = CK_TRUE;
+
+	CK_ATTRIBUTE attrs[] = {
+		{ CKA_CLASS, &klass, sizeof (klass) },
+		{ CKA_TOKEN, &token, sizeof (token) },
+		{ CKA_LABEL, "blah", 4 },
+		{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
+	};
+
+	object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
+	                                                attrs, G_N_ELEMENTS (attrs));
+	g_assert (object != NULL);
+	g_assert (GKM_IS_SECRET_COLLECTION (object));
+
+	identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
+	g_assert (strstr (identifier, "blah"));
+	g_object_unref (object);
+}
+
+static void
+test_factory_duplicate (Test *test, gconstpointer unused)
+{
+	CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
+	const gchar *identifier1, *identifier2;
+	GkmObject *object;
+
+	CK_ATTRIBUTE attrs[] = {
+		{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
+		{ CKA_CLASS, &klass, sizeof (klass) },
+		{ CKA_LABEL, "blah", 4 },
+	};
+
+	object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
+	                                                attrs, G_N_ELEMENTS (attrs));
+	g_assert (object != NULL);
+	g_assert (GKM_IS_SECRET_COLLECTION (object));
+
+	identifier1 = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
+	g_assert (strstr (identifier1, "blah"));
+	g_object_unref (object);
+
+	/* Use second test->credential for second object */
+	attrs[0].pValue = &test->credential2;
+	object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
+	                                                attrs, G_N_ELEMENTS (attrs));
+	g_assert (object != NULL);
+	g_assert (GKM_IS_SECRET_COLLECTION (object));
+
+	identifier2 = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
+	g_assert (strstr (identifier2, "blah"));
+	g_object_unref (object);
+
+	g_assert_cmpstr (identifier1, !=, identifier2);
+}
+
+static void
+test_factory_item (Test *test, gconstpointer unused)
+{
+	CK_OBJECT_CLASS c_klass = CKO_G_COLLECTION;
+	CK_OBJECT_CLASS i_klass = CKO_SECRET_KEY;
+	const gchar *identifier;
+	GkmObject *object;
+	CK_BBOOL token = CK_TRUE;
+
+	CK_ATTRIBUTE c_attrs[] = {
+		{ CKA_CLASS, &c_klass, sizeof (c_klass) },
+		{ CKA_TOKEN, &token, sizeof (token) },
+		{ CKA_LABEL, "three", 5 },
+		{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
+	};
+
+	CK_ATTRIBUTE i_attrs[] = {
+		{ CKA_G_COLLECTION, NULL, 0 }, /* Filled below */
+		{ CKA_CLASS, &i_klass, sizeof (i_klass) },
+		{ CKA_TOKEN, &token, sizeof (token) },
+		{ CKA_LABEL, "Item", 4 },
+	};
+
+	object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
+	                                                c_attrs, G_N_ELEMENTS (c_attrs));
+	g_assert (object != NULL);
+	g_assert (GKM_IS_SECRET_COLLECTION (object));
+	identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
+	g_object_unref (object);
+
+	i_attrs[0].pValue = (gpointer)identifier;
+	i_attrs[0].ulValueLen = strlen (identifier);
+	object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_ITEM, NULL,
+	                                                i_attrs, G_N_ELEMENTS (i_attrs));
+	g_assert (object != NULL);
+	g_assert (GKM_IS_SECRET_ITEM (object));
+	g_object_unref (object);
+}
+
+static void
+test_token_remove (Test *test, gconstpointer unused)
+{
+	CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
+	GkmTransaction *transaction;
+	GkmObject *object;
+	CK_BBOOL token = CK_TRUE;
+
+	CK_ATTRIBUTE attrs[] = {
+		{ CKA_CLASS, &klass, sizeof (klass) },
+		{ CKA_TOKEN, &token, sizeof (token) },
+		{ CKA_LABEL, "blah", 4 },
+		{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
+	};
+
+	object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
+	                                                attrs, G_N_ELEMENTS (attrs));
+	g_assert (object != NULL);
+	g_assert (GKM_IS_SECRET_COLLECTION (object));
+
+	transaction = gkm_transaction_new ();
+	gkm_module_remove_token_object (test->module, transaction, object);
+	g_assert (!gkm_transaction_get_failed (transaction));
+	gkm_transaction_complete (transaction);
+	g_object_unref (transaction);
+	g_object_unref (object);
+}
+
+static void
+test_token_item_remove (Test *test, gconstpointer unused)
+{
+	CK_OBJECT_CLASS c_klass = CKO_G_COLLECTION;
+	CK_OBJECT_CLASS i_klass = CKO_SECRET_KEY;
+	GkmTransaction *transaction;
+	const gchar *identifier;
+	GkmObject *object;
+	CK_BBOOL token = CK_TRUE;
+
+	CK_ATTRIBUTE c_attrs[] = {
+		{ CKA_CLASS, &c_klass, sizeof (c_klass) },
+		{ CKA_TOKEN, &token, sizeof (token) },
+		{ CKA_LABEL, "three", 5 },
+		{ CKA_G_CREDENTIAL, &test->credential, sizeof (test->credential) },
+	};
+
+	CK_ATTRIBUTE i_attrs[] = {
+		{ CKA_G_COLLECTION, NULL, 0 }, /* Filled below */
+		{ CKA_CLASS, &i_klass, sizeof (i_klass) },
+		{ CKA_TOKEN, &token, sizeof (token) },
+		{ CKA_LABEL, "Item", 4 },
+	};
+
+	object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_COLLECTION, NULL,
+	                                                c_attrs, G_N_ELEMENTS (c_attrs));
+	g_assert (object != NULL);
+	g_assert (GKM_IS_SECRET_COLLECTION (object));
+	identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
+	g_object_unref (object);
+
+	i_attrs[0].pValue = (gpointer)identifier;
+	i_attrs[0].ulValueLen = strlen (identifier);
+	object = gkm_session_create_object_for_factory (test->session, GKM_FACTORY_SECRET_ITEM, NULL,
+	                                                i_attrs, G_N_ELEMENTS (i_attrs));
+	g_assert (object != NULL);
+	g_assert (GKM_IS_SECRET_ITEM (object));
+
+	transaction = gkm_transaction_new ();
+	gkm_module_remove_token_object (test->module, transaction, object);
+	g_assert (!gkm_transaction_get_failed (transaction));
+	gkm_transaction_complete (transaction);
+	g_object_unref (transaction);
+	g_object_unref (object);
+}
+
+int
+main (int argc, char **argv)
+{
+	g_type_init ();
+	g_test_init (&argc, &argv, NULL);
+
+	g_test_add ("/secret-store/collection/is_locked", Test, NULL, setup, test_is_locked, teardown);
+	g_test_add ("/secret-store/collection/unlocked_data", Test, NULL, setup, test_unlocked_data, teardown);
+	g_test_add ("/secret-store/collection/get_filename", Test, NULL, setup, test_get_filename, teardown);
+	g_test_add ("/secret-store/collection/set_filename", Test, NULL, setup, test_set_filename, teardown);
+	g_test_add ("/secret-store/collection/has_item", Test, NULL, setup, test_has_item, teardown);
+	g_test_add ("/secret-store/collection/load_unlock_plain", Test, NULL, setup, test_load_unlock_plain, teardown);
+	g_test_add ("/secret-store/collection/load_unlock_encrypted", Test, NULL, setup, test_load_unlock_encrypted, teardown);
+	g_test_add ("/secret-store/collection/load_unlock_bad_password", Test, NULL, setup, test_load_unlock_bad_password, teardown);
+	g_test_add ("/secret-store/collection/unlock_without_load", Test, NULL, setup, test_unlock_without_load, teardown);
+	g_test_add ("/secret-store/collection/twice_unlock", Test, NULL, setup, test_twice_unlock, teardown);
+	g_test_add ("/secret-store/collection/twice_unlock_bad_password", Test, NULL, setup, test_twice_unlock_bad_password, teardown);
+	g_test_add ("/secret-store/collection/memory_unlock", Test, NULL, setup, test_memory_unlock, teardown);
+	g_test_add ("/secret-store/collection/memory_unlock_bad_password", Test, NULL, setup, test_memory_unlock_bad_password, teardown);
+	g_test_add ("/secret-store/collection/factory", Test, NULL, setup, test_factory, teardown);
+	g_test_add ("/secret-store/collection/factory_unnamed", Test, NULL, setup, test_factory_unnamed, teardown);
+	g_test_add ("/secret-store/collection/factory_token", Test, NULL, setup, test_factory_token, teardown);
+	g_test_add ("/secret-store/collection/factory_duplicate", Test, NULL, setup, test_factory_duplicate, teardown);
+	g_test_add ("/secret-store/collection/factory_item", Test, NULL, setup, test_factory_item, teardown);
+	g_test_add ("/secret-store/collection/token_remove", Test, NULL, setup, test_token_remove, teardown);
+	g_test_add ("/secret-store/collection/token_item_remove", Test, NULL, setup, test_token_item_remove, teardown);
+
+	return g_test_run ();
+}
diff --git a/pkcs11/secret-store/tests/unit-test-secret-compat.c b/pkcs11/secret-store/tests/test-secret-compat.c
index 925c729c..f11b0e2e 100644
--- a/pkcs11/secret-store/tests/unit-test-secret-compat.c
+++ b/pkcs11/secret-store/tests/test-secret-compat.c
@@ -1,5 +1,5 @@
 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
-/* unit-test-secret-compat.c: Test secret compat files
+/* test-secret-compat.c: Test secret compat files
 
    Copyright (C) 2008 Stefan Walter
 
@@ -23,9 +23,7 @@
 
 #include "config.h"
 
-#include "test-suite.h"
-
-#include "gkm-secret-compat.h"
+#include "secret-store/gkm-secret-compat.h"
 
 #include <glib.h>
 
@@ -33,7 +31,8 @@
 #include <stdio.h>
 #include <string.h>
 
-TESTING_TEST(access_free)
+static void
+test_access_free (void)
 {
 	GkmSecretAccess *ac;
 
@@ -45,7 +44,8 @@ TESTING_TEST(access_free)
 	gkm_secret_compat_access_free (ac);
 }
 
-TESTING_TEST(acl_free)
+static void
+test_acl_free (void)
 {
 	GkmSecretAccess *ac;
 	GList *acl = NULL;
@@ -62,7 +62,8 @@ TESTING_TEST(acl_free)
 	gkm_secret_compat_acl_free (acl);
 }
 
-TESTING_TEST(parse_item_type)
+static void
+test_parse_item_type (void)
 {
 	guint type;
 
@@ -88,7 +89,8 @@ TESTING_TEST(parse_item_type)
 	g_assert_cmpuint (type, ==, 0);
 }
 
-TESTING_TEST(format_item_type)
+static void
+test_format_item_type (void)
 {
 	const gchar *type;
 
@@ -113,3 +115,16 @@ TESTING_TEST(format_item_type)
 	type = gkm_secret_compat_format_item_type (32);
 	g_assert (type == NULL);
 }
+
+int
+main (int argc, char **argv)
+{
+	g_test_init (&argc, &argv, NULL);
+
+	g_test_add_func ("/secret-store/compat/access_free", test_access_free);
+	g_test_add_func ("/secret-store/compat/acl_free", test_acl_free);
+	g_test_add_func ("/secret-store/compat/parse_item_type", test_parse_item_type);
+	g_test_add_func ("/secret-store/compat/format_item_type", test_format_item_type);
+
+	return g_test_run ();
+}
diff --git a/pkcs11/secret-store/tests/unit-test-secret-data.c b/pkcs11/secret-store/tests/test-secret-data.c
index efa6b259..a71e3019 100644
--- a/pkcs11/secret-store/tests/unit-test-secret-data.c
+++ b/pkcs11/secret-store/tests/test-secret-data.c
@@ -1,5 +1,5 @@
 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
-/* unit-test-secret-compat.c: Test secret compat files
+/* test-secret-compat.c: Test secret compat files
 
    Copyright (C) 2008 Stefan Walter
 
@@ -23,27 +23,31 @@
 
 #include "config.h"
 
-#include "test-suite.h"
-
-#include "gkm-secret-data.h"
+#include "secret-store/gkm-secret-data.h"
 
 #include "gkm/gkm-secret.h"
 #include "gkm/gkm-transaction.h"
 
+#include "egg/egg-secure-memory.h"
+
 #include <glib.h>
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 
-TESTING_TEST(secret_data_new)
+EGG_SECURE_GLIB_DEFINITIONS ();
+
+static void
+test_new (void)
 {
 	GkmSecretData *data = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
 	g_assert (GKM_IS_SECRET_DATA (data));
 	g_object_unref (data);
 }
 
-TESTING_TEST(secret_data_get_set)
+static void
+test_get_set (void)
 {
 	GkmSecretData *data = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
 	GkmSecret *secret = gkm_secret_new_from_password ("barn");
@@ -60,7 +64,8 @@ TESTING_TEST(secret_data_get_set)
 	g_object_unref (data);
 }
 
-TESTING_TEST(secret_data_get_raw)
+static void
+test_get_raw (void)
 {
 	GkmSecretData *data = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
 	GkmSecret *secret = gkm_secret_new_from_password ("barn");
@@ -81,7 +86,8 @@ TESTING_TEST(secret_data_get_raw)
 	g_object_unref (data);
 }
 
-TESTING_TEST(secret_data_remove)
+static void
+test_remove (void)
 {
 	GkmSecretData *data = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
 	GkmSecret *secret = gkm_secret_new_from_password ("barn");
@@ -99,7 +105,8 @@ TESTING_TEST(secret_data_remove)
 	g_object_unref (data);
 }
 
-TESTING_TEST(secret_data_set_transacted)
+static void
+test_set_transacted (void)
 {
 	GkmTransaction *transaction = gkm_transaction_new ();
 	GkmSecretData *data = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
@@ -120,7 +127,8 @@ TESTING_TEST(secret_data_set_transacted)
 	g_object_unref (transaction);
 }
 
-TESTING_TEST(secret_data_set_transacted_replace)
+static void
+test_set_transacted_replace (void)
 {
 	GkmTransaction *transaction = gkm_transaction_new ();
 	GkmSecretData *data = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
@@ -147,7 +155,8 @@ TESTING_TEST(secret_data_set_transacted_replace)
 	g_object_unref (transaction);
 }
 
-TESTING_TEST(secret_data_set_transacted_fail)
+static void
+test_set_transacted_fail (void)
 {
 	GkmTransaction *transaction = gkm_transaction_new ();
 	GkmSecretData *data = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
@@ -169,7 +178,8 @@ TESTING_TEST(secret_data_set_transacted_fail)
 	g_object_unref (transaction);
 }
 
-TESTING_TEST(secret_data_set_transacted_fail_revert)
+static void
+test_set_transacted_fail_revert (void)
 {
 	GkmTransaction *transaction = gkm_transaction_new ();
 	GkmSecretData *data = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
@@ -197,7 +207,8 @@ TESTING_TEST(secret_data_set_transacted_fail_revert)
 	g_object_unref (transaction);
 }
 
-TESTING_TEST(secret_data_get_set_master)
+static void
+test_get_set_master (void)
 {
 	GkmSecretData *data = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
 	GkmSecret *master = gkm_secret_new_from_password ("master");
@@ -213,3 +224,22 @@ TESTING_TEST(secret_data_get_set_master)
 
 	g_object_unref (data);
 }
+
+int
+main (int argc, char **argv)
+{
+	g_type_init ();
+	g_test_init (&argc, &argv, NULL);
+
+	g_test_add_func ("/secret-store/data/new", test_new);
+	g_test_add_func ("/secret-store/data/get_set", test_get_set);
+	g_test_add_func ("/secret-store/data/get_raw", test_get_raw);
+	g_test_add_func ("/secret-store/data/remove", test_remove);
+	g_test_add_func ("/secret-store/data/set_transacted", test_set_transacted);
+	g_test_add_func ("/secret-store/data/set_transacted_replace", test_set_transacted_replace);
+	g_test_add_func ("/secret-store/data/set_transacted_fail", test_set_transacted_fail);
+	g_test_add_func ("/secret-store/data/set_transacted_fail_revert", test_set_transacted_fail_revert);
+	g_test_add_func ("/secret-store/data/get_set_master", test_get_set_master);
+
+	return g_test_run ();
+}
diff --git a/pkcs11/secret-store/tests/unit-test-secret-fields.c b/pkcs11/secret-store/tests/test-secret-fields.c
index d69939d3..96bb6071 100644
--- a/pkcs11/secret-store/tests/unit-test-secret-fields.c
+++ b/pkcs11/secret-store/tests/test-secret-fields.c
@@ -1,5 +1,5 @@
 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
-/* unit-test-secret-fields.c: Test secret fields
+/* test-secret-fields.c: Test secret fields
 
    Copyright (C) 2009 Stefan Walter
 
@@ -23,9 +23,7 @@
 
 #include "config.h"
 
-#include "test-suite.h"
-
-#include "gkm-secret-fields.h"
+#include "secret-store/gkm-secret-fields.h"
 
 #include "pkcs11/pkcs11i.h"
 
@@ -35,20 +33,23 @@
 #include <stdio.h>
 #include <string.h>
 
-TESTING_TEST(fields_new)
+static void
+test_new (void)
 {
 	GHashTable *fields = gkm_secret_fields_new ();
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_boxed)
+static void
+test_boxed (void)
 {
 	GType boxed = gkm_secret_fields_boxed_type ();
 	GType check = gkm_secret_fields_boxed_type ();
 	g_assert (boxed == check);
 }
 
-TESTING_TEST(fields_add_get_values)
+static void
+test_add_get_values (void)
 {
 	GHashTable *fields = gkm_secret_fields_new ();
 	const gchar *value;
@@ -69,7 +70,8 @@ TESTING_TEST(fields_add_get_values)
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_parse)
+static void
+test_parse (void)
 {
 	CK_ATTRIBUTE attr = { CKA_G_FIELDS, "one\0value1\0two\0value2\0three\0value3\0", 35 };
 	GHashTable *fields;
@@ -90,7 +92,8 @@ TESTING_TEST(fields_parse)
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_parse_empty)
+static void
+test_parse_empty (void)
 {
 	CK_ATTRIBUTE attr = { CKA_G_FIELDS, "", 0 };
 	GHashTable *fields;
@@ -104,7 +107,8 @@ TESTING_TEST(fields_parse_empty)
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_parse_null_invalid)
+static void
+test_parse_null_invalid (void)
 {
 	CK_ATTRIBUTE attr = { CKA_G_FIELDS, NULL, 5 };
 	GHashTable *fields;
@@ -114,7 +118,8 @@ TESTING_TEST(fields_parse_null_invalid)
 	g_assert (rv == CKR_ATTRIBUTE_VALUE_INVALID);
 }
 
-TESTING_TEST(fields_parse_missing_value)
+static void
+test_parse_missing_value (void)
 {
 	CK_ATTRIBUTE attr = { CKA_G_FIELDS, "one", 3 };
 	GHashTable *fields;
@@ -124,7 +129,8 @@ TESTING_TEST(fields_parse_missing_value)
 	g_assert (rv == CKR_ATTRIBUTE_VALUE_INVALID);
 }
 
-TESTING_TEST(fields_parse_missing_terminator)
+static void
+test_parse_missing_terminator (void)
 {
 	CK_ATTRIBUTE attr = { CKA_G_FIELDS, "one\0value", 9 };
 	GHashTable *fields;
@@ -134,7 +140,8 @@ TESTING_TEST(fields_parse_missing_terminator)
 	g_assert (rv == CKR_ATTRIBUTE_VALUE_INVALID);
 }
 
-TESTING_TEST(fields_parse_not_utf8)
+static void
+test_parse_not_utf8 (void)
 {
 	CK_ATTRIBUTE attr = { CKA_G_FIELDS, "one\0not\234utf8\0", 13 };
 	GHashTable *fields;
@@ -144,7 +151,8 @@ TESTING_TEST(fields_parse_not_utf8)
 	g_assert (rv == CKR_ATTRIBUTE_VALUE_INVALID);
 }
 
-TESTING_TEST(fields_serialize)
+static void
+test_serialize (void)
 {
 	gchar buffer[32];
 	CK_ATTRIBUTE attr = { CKA_G_FIELDS, buffer, 32 };
@@ -162,7 +170,8 @@ TESTING_TEST(fields_serialize)
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_serialize_length)
+static void
+test_serialize_length (void)
 {
 	CK_ATTRIBUTE attr = { CKA_G_FIELDS, NULL, 0 };
 	GHashTable *fields;
@@ -178,7 +187,8 @@ TESTING_TEST(fields_serialize_length)
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_add_get_compat_uint32)
+static void
+test_add_get_compat_uint32 (void)
 {
 	GHashTable *fields;
 	gboolean ret;
@@ -194,7 +204,8 @@ TESTING_TEST(fields_add_get_compat_uint32)
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_get_compat_uint32_fail)
+static void
+test_get_compat_uint32_fail (void)
 {
 	GHashTable *fields;
 	gboolean ret;
@@ -209,7 +220,8 @@ TESTING_TEST(fields_get_compat_uint32_fail)
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_get_compat_hashed_string)
+static void
+test_get_compat_hashed_string (void)
 {
 	GHashTable *fields;
 	gboolean ret;
@@ -226,7 +238,8 @@ TESTING_TEST(fields_get_compat_hashed_string)
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_get_compat_hashed_already)
+static void
+test_get_compat_hashed_already (void)
 {
 	GHashTable *fields;
 	gboolean ret;
@@ -243,7 +256,8 @@ TESTING_TEST(fields_get_compat_hashed_already)
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_get_compat_hashed_uint32)
+static void
+test_get_compat_hashed_uint32 (void)
 {
 	GHashTable *fields;
 	gboolean ret;
@@ -260,7 +274,8 @@ TESTING_TEST(fields_get_compat_hashed_uint32)
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_get_compat_hashed_uint32_already)
+static void
+test_get_compat_hashed_uint32_already (void)
 {
 	GHashTable *fields;
 	gboolean ret;
@@ -277,7 +292,8 @@ TESTING_TEST(fields_get_compat_hashed_uint32_already)
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_get_names)
+static void
+test_get_names (void)
 {
 	GHashTable *fields;
 	GList *names, *l;
@@ -303,7 +319,8 @@ TESTING_TEST(fields_get_names)
 	g_hash_table_unref (fields);
 }
 
-TESTING_TEST(fields_match)
+static void
+test_match (void)
 {
 	GHashTable *haystack;
 	GHashTable *needle;
@@ -329,7 +346,8 @@ TESTING_TEST(fields_match)
 	g_hash_table_unref (needle);
 }
 
-TESTING_TEST(fields_match_mismatch_value)
+static void
+test_match_mismatch_value (void)
 {
 	GHashTable *haystack;
 	GHashTable *needle;
@@ -348,7 +366,8 @@ TESTING_TEST(fields_match_mismatch_value)
 	g_hash_table_unref (needle);
 }
 
-TESTING_TEST(fields_match_mismatch_field)
+static void
+test_match_mismatch_field (void)
 {
 	GHashTable *haystack;
 	GHashTable *needle;
@@ -367,7 +386,8 @@ TESTING_TEST(fields_match_mismatch_field)
 	g_hash_table_unref (needle);
 }
 
-TESTING_TEST(fields_match_wrong_hashed)
+static void
+test_match_wrong_hashed (void)
 {
 	GHashTable *haystack;
 	GHashTable *needle;
@@ -385,3 +405,35 @@ TESTING_TEST(fields_match_wrong_hashed)
 	g_hash_table_unref (haystack);
 	g_hash_table_unref (needle);
 }
+
+int
+main (int argc, char **argv)
+{
+	g_type_init ();
+	g_test_init (&argc, &argv, NULL);
+
+	g_test_add_func ("/secret-store/fields/new", test_new);
+	g_test_add_func ("/secret-store/fields/boxed", test_boxed);
+	g_test_add_func ("/secret-store/fields/add_get_values", test_add_get_values);
+	g_test_add_func ("/secret-store/fields/parse", test_parse);
+	g_test_add_func ("/secret-store/fields/parse_empty", test_parse_empty);
+	g_test_add_func ("/secret-store/fields/parse_null_invalid", test_parse_null_invalid);
+	g_test_add_func ("/secret-store/fields/parse_missing_value", test_parse_missing_value);
+	g_test_add_func ("/secret-store/fields/parse_missing_terminator", test_parse_missing_terminator);
+	g_test_add_func ("/secret-store/fields/parse_not_utf8", test_parse_not_utf8);
+	g_test_add_func ("/secret-store/fields/serialize", test_serialize);
+	g_test_add_func ("/secret-store/fields/serialize_length", test_serialize_length);
+	g_test_add_func ("/secret-store/fields/add_get_compat_uint32", test_add_get_compat_uint32);
+	g_test_add_func ("/secret-store/fields/get_compat_uint32_fail", test_get_compat_uint32_fail);
+	g_test_add_func ("/secret-store/fields/get_compat_hashed_string", test_get_compat_hashed_string);
+	g_test_add_func ("/secret-store/fields/get_compat_hashed_already", test_get_compat_hashed_already);
+	g_test_add_func ("/secret-store/fields/get_compat_hashed_uint32", test_get_compat_hashed_uint32);
+	g_test_add_func ("/secret-store/fields/get_compat_hashed_uint32_already", test_get_compat_hashed_uint32_already);
+	g_test_add_func ("/secret-store/fields/get_names", test_get_names);
+	g_test_add_func ("/secret-store/fields/match", test_match);
+	g_test_add_func ("/secret-store/fields/match_mismatch_value", test_match_mismatch_value);
+	g_test_add_func ("/secret-store/fields/match_mismatch_field", test_match_mismatch_field);
+	g_test_add_func ("/secret-store/fields/match_wrong_hashed", test_match_wrong_hashed);
+
+	return g_test_run ();
+}
diff --git a/pkcs11/secret-store/tests/test-secret-item.c b/pkcs11/secret-store/tests/test-secret-item.c
new file mode 100644
index 00000000..2198cf2e
--- /dev/null
+++ b/pkcs11/secret-store/tests/test-secret-item.c
@@ -0,0 +1,482 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* unit-test-secret-item.c: Test secret item
+
+   Copyright (C) 2009 Stefan Walter
+
+   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 <stef@memberwebs.com>
+*/
+
+#include "config.h"
+
+#include "mock-secret-module.h"
+
+#include "secret-store/gkm-secret-collection.h"
+#include "secret-store/gkm-secret-fields.h"
+#include "secret-store/gkm-secret-item.h"
+
+#include "gkm/gkm-credential.h"
+#include "gkm/gkm-session.h"
+#include "gkm/gkm-transaction.h"
+
+#include "pkcs11/pkcs11i.h"
+
+#include <glib.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct {
+	GkmModule *module;
+	GkmSession *session;
+	GkmSecretCollection *collection;
+} Test;
+
+static void
+setup (Test *test, gconstpointer unused)
+{
+	test->module = test_secret_module_initialize_and_enter ();
+	test->session = test_secret_module_open_session (TRUE);
+
+	test->collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
+	                           "module", test->module,
+	                           "identifier", "test",
+	                           NULL);
+}
+
+static void
+teardown (Test *test, gconstpointer unused)
+{
+	if (test->collection)
+		g_object_unref (test->collection);
+	test_secret_module_leave_and_finalize ();
+}
+
+static void
+unlock_collection (Test *test)
+{
+	GkmCredential *cred;
+	GkmObject *object;
+	CK_RV rv;
+
+	/* Create credential, which unlocks test->collection */
+	object = GKM_OBJECT (test->collection);
+	rv = gkm_credential_create (gkm_object_get_module (object),
+	                            gkm_session_get_manager (test->session),
+	                            object, NULL, 0, &cred);
+	g_assert (rv == CKR_OK);
+
+	gkm_session_add_session_object (test->session, NULL, GKM_OBJECT (cred));
+	g_object_unref (cred);
+}
+
+static void
+test_new (Test *test, gconstpointer unused)
+{
+	GkmSecretItem *item;
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	g_assert (GKM_IS_SECRET_ITEM (item));
+	g_assert_cmpstr (gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (item)), ==, "the-identifier");
+}
+
+static void
+test_create (Test *test, gconstpointer unused)
+{
+	GkmTransaction *transaction;
+	GkmSecretItem *item;
+
+	transaction = gkm_transaction_new ();
+	item = gkm_secret_collection_create_item (test->collection, transaction);
+	g_assert (GKM_IS_SECRET_ITEM (item));
+	g_object_ref (item);
+	g_assert (gkm_secret_collection_has_item (test->collection, item));
+
+	gkm_transaction_complete (transaction);
+	g_object_unref (transaction);
+
+	/* Should still be there */
+	g_assert (gkm_secret_collection_has_item (test->collection, item));
+	g_object_unref (item);
+}
+
+static void
+test_create_failed (Test *test, gconstpointer unused)
+{
+	GkmTransaction *transaction;
+	GkmSecretItem *item;
+
+	transaction = gkm_transaction_new ();
+	item = gkm_secret_collection_create_item (test->collection, transaction);
+	g_assert (GKM_IS_SECRET_ITEM (item));
+	g_object_ref (item);
+	g_assert (gkm_secret_collection_has_item (test->collection, item));
+
+	gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
+	gkm_transaction_complete (transaction);
+	g_object_unref (transaction);
+
+	/* Should no longer be there */
+	g_assert (!gkm_secret_collection_has_item (test->collection, item));
+	g_object_unref (item);
+}
+
+static void
+test_destroy (Test *test, gconstpointer unused)
+{
+	GkmTransaction *transaction;
+	GkmSecretItem *item;
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	g_assert (gkm_secret_collection_has_item (test->collection, item));
+	g_object_ref (item);
+
+	transaction = gkm_transaction_new ();
+	gkm_secret_collection_destroy_item (test->collection, transaction, item);
+	g_assert (!gkm_secret_collection_has_item (test->collection, item));
+
+	gkm_transaction_complete (transaction);
+	g_object_unref (transaction);
+
+	/* Should not be there */
+	g_assert (!gkm_secret_collection_has_item (test->collection, item));
+	g_object_unref (item);
+}
+
+static void
+test_destroy_failed (Test *test, gconstpointer unused)
+{
+	GkmTransaction *transaction;
+	GkmSecretItem *item;
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	g_assert (gkm_secret_collection_has_item (test->collection, item));
+	g_object_ref (item);
+
+	transaction = gkm_transaction_new ();
+	gkm_secret_collection_destroy_item (test->collection, transaction, item);
+	g_assert (!gkm_secret_collection_has_item (test->collection, item));
+
+	gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
+	gkm_transaction_complete (transaction);
+	g_object_unref (transaction);
+
+	/* Should be there */
+	g_assert (gkm_secret_collection_has_item (test->collection, item));
+	g_object_unref (item);
+}
+
+static void
+test_collection_get (Test *test, gconstpointer unused)
+{
+	GkmSecretItem *item, *check;
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	g_assert (GKM_IS_SECRET_ITEM (item));
+
+	check = gkm_secret_collection_get_item (test->collection, "the-identifier");
+	g_assert (item == check);
+}
+
+static void
+test_collection_items (Test *test, gconstpointer unused)
+{
+	GList *l, *items;
+	const gchar *identifier;
+
+	gkm_secret_collection_new_item (test->collection, "one-identifier");
+	gkm_secret_collection_new_item (test->collection, "two-identifier");
+	gkm_secret_collection_new_item (test->collection, "three-identifier");
+
+	items = gkm_secret_collection_get_items (test->collection);
+	g_assert_cmpuint (g_list_length (items), ==, 3);
+	for (l = items; l; l = g_list_next (l)) {
+		identifier = gkm_secret_object_get_identifier (l->data);
+		if (!g_str_equal (identifier, "one-identifier") &&
+		    !g_str_equal (identifier, "two-identifier") &&
+		    !g_str_equal (identifier, "three-identifier"))
+			g_assert_not_reached ();
+	}
+
+	g_list_free (items);
+}
+
+static void
+test_collection_remove (Test *test, gconstpointer unused)
+{
+	GkmSecretItem *item;
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	g_assert (gkm_secret_collection_get_item (test->collection, "the-identifier") == item);
+
+	gkm_secret_collection_remove_item (test->collection, item);
+	g_assert (gkm_secret_collection_get_item (test->collection, "the-identifier") == NULL);
+}
+
+static void
+test_is_locked (Test *test, gconstpointer unused)
+{
+	GkmSecretItem *item;
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	g_assert (gkm_secret_object_is_locked (GKM_SECRET_OBJECT (item), test->session) ==
+	          gkm_secret_object_is_locked (GKM_SECRET_OBJECT (test->collection), test->session));
+
+	unlock_collection (test);
+
+	g_assert (gkm_secret_object_is_locked (GKM_SECRET_OBJECT (item), test->session) == FALSE);
+}
+
+static void
+test_get_collection (Test *test, gconstpointer unused)
+{
+	GkmSecretItem *item;
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	g_assert (gkm_secret_item_get_collection (item) == test->collection);
+}
+
+static void
+test_tracks_collection (Test *test, gconstpointer unused)
+{
+	GkmSecretItem *item;
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	g_object_ref (item);
+
+	unlock_collection (test);
+
+	/* At this point the item should be 'unlocked' */
+	g_assert (gkm_secret_object_is_locked (GKM_SECRET_OBJECT (item), test->session) == FALSE);
+
+	g_object_unref (test->collection);
+	test->collection = NULL;
+
+	/* Collection went away */
+	g_assert (gkm_secret_item_get_collection (item) == NULL);
+	g_assert (gkm_secret_object_is_locked (GKM_SECRET_OBJECT (item), test->session) == TRUE);
+
+	g_object_unref (item);
+}
+
+static void
+test_get_set_fields (Test *test, gconstpointer unused)
+{
+	GHashTable *fields = gkm_secret_fields_new ();
+	GHashTable *check;
+	GkmSecretItem *item;
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	gkm_secret_item_set_fields (item, fields);
+	gkm_secret_item_set_fields (item, fields);
+
+	check = gkm_secret_item_get_fields (item);
+	g_assert (check == fields);
+
+	g_hash_table_unref (fields);
+}
+
+static void
+test_collection_attr (Test *test, gconstpointer unused)
+{
+	gchar buffer[32];
+	CK_ATTRIBUTE check = { CKA_G_COLLECTION, buffer, 32 };
+	GkmSecretItem *item;
+	CK_RV rv;
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	rv = gkm_object_get_attribute (GKM_OBJECT (item), test->session, &check);
+	g_assert (rv == CKR_OK);
+	g_assert (check.ulValueLen == 4);
+	g_assert (memcmp (buffer, "test", 4) == 0);
+}
+
+static void
+test_secret_attr (Test *test, gconstpointer unused)
+{
+	GkmTransaction *transaction = gkm_transaction_new ();
+	CK_ATTRIBUTE attr = { CKA_VALUE, "hello", 5 };
+	gchar buffer[32];
+	CK_ATTRIBUTE check = { CKA_VALUE, buffer, 32 };
+	GkmSecretItem *item;
+	CK_RV rv;
+
+	unlock_collection (test);
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	gkm_object_set_attribute (GKM_OBJECT (item), test->session, transaction, &attr);
+	g_assert (gkm_transaction_get_failed (transaction) == FALSE);
+	gkm_transaction_complete (transaction);
+	g_assert (gkm_transaction_get_result (transaction) == CKR_OK);
+
+	g_object_unref (transaction);
+
+	rv = gkm_object_get_attribute (GKM_OBJECT (item), test->session, &check);
+	g_assert (rv == CKR_OK);
+	g_assert (check.ulValueLen == 5);
+	g_assert (memcmp (buffer, "hello", 5) == 0);
+}
+
+static void
+test_secret_attr_locked (Test *test, gconstpointer unused)
+{
+	GkmTransaction *transaction = gkm_transaction_new ();
+	CK_ATTRIBUTE attr = { CKA_VALUE, "hello", 5 };
+	gchar buffer[32];
+	CK_ATTRIBUTE check = { CKA_VALUE, buffer, 32 };
+	GkmSecretItem *item;
+	CK_RV rv;
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	gkm_object_set_attribute (GKM_OBJECT (item), test->session, transaction, &attr);
+	g_assert (gkm_transaction_get_failed (transaction) == TRUE);
+	gkm_transaction_complete (transaction);
+	g_assert (gkm_transaction_get_result (transaction) == CKR_USER_NOT_LOGGED_IN);
+
+	g_object_unref (transaction);
+
+	rv = gkm_object_get_attribute (GKM_OBJECT (item), test->session, &check);
+	g_assert (rv == CKR_USER_NOT_LOGGED_IN);
+}
+
+static void
+test_fields_attr (Test *test, gconstpointer unused)
+{
+	GkmTransaction *transaction = gkm_transaction_new ();
+	CK_ATTRIBUTE attr = { CKA_G_FIELDS, "name1\0value1\0name2\0value2", 26 };
+	gchar buffer[32];
+	CK_ATTRIBUTE check = { CKA_G_FIELDS, buffer, 32 };
+	GkmSecretItem *item;
+	GHashTable *fields;
+	const gchar *value;
+	CK_RV rv;
+
+	unlock_collection (test);
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	gkm_object_set_attribute (GKM_OBJECT (item), test->session, transaction, &attr);
+	g_assert (gkm_transaction_get_failed (transaction) == FALSE);
+	gkm_transaction_complete (transaction);
+	g_assert (gkm_transaction_get_result (transaction) == CKR_OK);
+
+	g_object_unref (transaction);
+
+	rv = gkm_object_get_attribute (GKM_OBJECT (item), test->session, &check);
+	g_assert (rv == CKR_OK);
+	g_assert (check.ulValueLen == 26);
+	g_assert (memcmp (buffer, "name1\0value1\0name2\0value2", 26) == 0);
+
+	fields = gkm_secret_item_get_fields (item);
+	g_assert (fields);
+	value = gkm_secret_fields_get (fields, "name1");
+	g_assert_cmpstr (value, ==, "value1");
+	value = gkm_secret_fields_get (fields, "name2");
+	g_assert_cmpstr (value, ==, "value2");
+}
+
+static void
+test_fields_attr_locked (Test *test, gconstpointer unused)
+{
+	GkmTransaction *transaction = gkm_transaction_new ();
+	CK_ATTRIBUTE attr = { CKA_G_FIELDS, "name1\0value1\0name2\0value2", 26 };
+	GkmSecretItem *item;
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+	gkm_object_set_attribute (GKM_OBJECT (item), test->session, transaction, &attr);
+	g_assert (gkm_transaction_get_failed (transaction) == TRUE);
+	gkm_transaction_complete (transaction);
+	g_assert (gkm_transaction_get_result (transaction) == CKR_USER_NOT_LOGGED_IN);
+
+	g_object_unref (transaction);
+}
+
+static void
+test_fields_attr_reverts (Test *test, gconstpointer unused)
+{
+	GkmTransaction *transaction = gkm_transaction_new ();
+	CK_ATTRIBUTE attr = { CKA_G_FIELDS, "new\0value\0", 10 };
+	gchar buffer[32];
+	CK_ATTRIBUTE check = { CKA_G_FIELDS, buffer, 32 };
+	GkmSecretItem *item;
+	GHashTable *fields;
+	CK_RV rv;
+
+	unlock_collection (test);
+
+	item = gkm_secret_collection_new_item (test->collection, "the-identifier");
+
+	/* Set the old value like so */
+	fields = gkm_secret_fields_new ();
+	gkm_secret_fields_add (fields, "old", "value");
+	gkm_secret_item_set_fields (item, fields);
+	g_hash_table_unref (fields);
+
+	/* Should show old value */
+	rv = gkm_object_get_attribute (GKM_OBJECT (item), test->session, &check);
+	g_assert (rv == CKR_OK);
+	g_assert (check.ulValueLen == 10);
+	g_assert (memcmp (buffer, "old\0value\0", 10) == 0);
+
+	/* Set the new values */
+	gkm_object_set_attribute (GKM_OBJECT (item), test->session, transaction, &attr);
+	g_assert (gkm_transaction_get_failed (transaction) == FALSE);
+
+	/* Should have the new value */
+	rv = gkm_object_get_attribute (GKM_OBJECT (item), test->session, &check);
+	g_assert (rv == CKR_OK);
+	g_assert (check.ulValueLen == 10);
+	g_assert (memcmp (buffer, "new\0value\0", 10) == 0);
+
+	/* Fail the transaction */
+	gkm_transaction_fail (transaction, CKR_CANCEL);
+	gkm_transaction_complete (transaction);
+
+	/* Should show the old value */
+	rv = gkm_object_get_attribute (GKM_OBJECT (item), test->session, &check);
+	g_assert (rv == CKR_OK);
+	g_assert (check.ulValueLen == 10);
+	g_assert (memcmp (buffer, "old\0value\0", 10) == 0);
+
+	g_object_unref (transaction);
+}
+
+int
+main (int argc, char **argv)
+{
+	g_type_init ();
+	g_test_init (&argc, &argv, NULL);
+
+	g_test_add ("/secret-store/item/new", Test, NULL, setup, test_new, teardown);
+	g_test_add ("/secret-store/item/create", Test, NULL, setup, test_create, teardown);
+	g_test_add ("/secret-store/item/create_failed", Test, NULL, setup, test_create_failed, teardown);
+	g_test_add ("/secret-store/item/destroy", Test, NULL, setup, test_destroy, teardown);
+	g_test_add ("/secret-store/item/destroy_failed", Test, NULL, setup, test_destroy_failed, teardown);
+	g_test_add ("/secret-store/item/collection_get", Test, NULL, setup, test_collection_get, teardown);
+	g_test_add ("/secret-store/item/collection_items", Test, NULL, setup, test_collection_items, teardown);
+	g_test_add ("/secret-store/item/collection_remove", Test, NULL, setup, test_collection_remove, teardown);
+	g_test_add ("/secret-store/item/is_locked", Test, NULL, setup, test_is_locked, teardown);
+	g_test_add ("/secret-store/item/get_collection", Test, NULL, setup, test_get_collection, teardown);
+	g_test_add ("/secret-store/item/tracks_collection", Test, NULL, setup, test_tracks_collection, teardown);
+	g_test_add ("/secret-store/item/get_set_fields", Test, NULL, setup, test_get_set_fields, teardown);
+	g_test_add ("/secret-store/item/collection_attr", Test, NULL, setup, test_collection_attr, teardown);
+	g_test_add ("/secret-store/item/secret_attr", Test, NULL, setup, test_secret_attr, teardown);
+	g_test_add ("/secret-store/item/secret_attr_locked", Test, NULL, setup, test_secret_attr_locked, teardown);
+	g_test_add ("/secret-store/item/fields_attr", Test, NULL, setup, test_fields_attr, teardown);
+	g_test_add ("/secret-store/item/fields_attr_locked", Test, NULL, setup, test_fields_attr_locked, teardown);
+	g_test_add ("/secret-store/item/fields_attr_reverts", Test, NULL, setup, test_fields_attr_reverts, teardown);
+
+	return g_test_run ();
+}
diff --git a/pkcs11/secret-store/tests/test-secret-object.c b/pkcs11/secret-store/tests/test-secret-object.c
new file mode 100644
index 00000000..db235cb2
--- /dev/null
+++ b/pkcs11/secret-store/tests/test-secret-object.c
@@ -0,0 +1,302 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/*
+   Copyright (C) 2009 Stefan Walter
+
+   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 <stef@memberwebs.com>
+*/
+
+#include "config.h"
+
+#include "mock-secret-module.h"
+
+#include "secret-store/gkm-secret-object.h"
+
+#include "gkm/gkm-transaction.h"
+
+#include "pkcs11/pkcs11i.h"
+
+#include <glib.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct {
+	GkmModule *module;
+	GkmSession *session;
+	GkmSecretObject *object;
+} Test;
+
+static void
+setup (Test *test, gconstpointer unused)
+{
+	test->module = test_secret_module_initialize_and_enter ();
+	test->session = test_secret_module_open_session (TRUE);
+
+	test->object = g_object_new (GKM_TYPE_SECRET_OBJECT,
+	                       "module", test->module,
+	                       "identifier", "my-identifier",
+	                       NULL);
+
+	g_assert (GKM_IS_SECRET_OBJECT (test->object));
+}
+
+static void
+teardown (Test *test, gconstpointer unused)
+{
+	g_object_unref (test->object);
+	test_secret_module_leave_and_finalize ();
+}
+
+static void
+test_is_locked (Test *test, gconstpointer unused)
+{
+	/* Plain GkmSecretObject is never locked */
+	g_assert (!gkm_secret_object_is_locked (test->object, test->session));
+}
+
+static void
+test_identifier_prop (Test *test, gconstpointer unused)
+{
+	const gchar *identifier;
+	identifier = gkm_secret_object_get_identifier (test->object);
+	g_assert_cmpstr (identifier, ==, "my-identifier");
+}
+
+static void
+was_notified (GObject *obj, GParamSpec *pspec, gpointer user_data)
+{
+	gboolean* notified = user_data;
+	g_assert (user_data);
+	*notified = TRUE;
+}
+
+static void
+test_created_prop (Test *test, gconstpointer unused)
+{
+	glong created;
+
+	/* Monitor for changes */
+	gboolean notified = FALSE;
+	g_signal_connect (test->object, "notify::created", G_CALLBACK (was_notified), &notified);
+
+	/* Default value */
+	created = gkm_secret_object_get_created (test->object);
+	g_assert (created == 0);
+
+	/* Set a new value */
+	gkm_secret_object_set_created (test->object, 1247930171);
+	g_assert (notified);
+	created = gkm_secret_object_get_created (test->object);
+	g_assert (created == 1247930171);
+}
+
+static void
+test_modified_prop (Test *test, gconstpointer unused)
+{
+	glong modified;
+
+	/* Monitor for changes */
+	gboolean notified = FALSE;
+	g_signal_connect (test->object, "notify::modified", G_CALLBACK (was_notified), &notified);
+
+	/* Default value */
+	modified = gkm_secret_object_get_modified (test->object);
+	g_assert (modified == 0);
+
+	/* Set a new value */
+	gkm_secret_object_set_modified (test->object, 1247930171);
+	g_assert (notified);
+	modified = gkm_secret_object_get_modified (test->object);
+	g_assert (modified == 1247930171);
+}
+
+static void
+test_was_modified (Test *test, gconstpointer unused)
+{
+	GTimeVal tv;
+	g_get_current_time (&tv);
+	gkm_secret_object_was_modified (test->object);
+	g_assert (tv.tv_sec == gkm_secret_object_get_modified (test->object));
+}
+
+static void
+test_label_prop (Test *test, gconstpointer unused)
+{
+	const gchar *label;
+
+	/* Monitor for changes */
+	gboolean notified = FALSE;
+	g_signal_connect (test->object, "notify::label", G_CALLBACK (was_notified), &notified);
+
+	/* Default value */
+	label = gkm_secret_object_get_label (test->object);
+	g_assert_cmpstr (label, ==, "");
+
+	/* Set a new value */
+	gkm_secret_object_set_label (test->object, "hello");
+	g_assert (notified);
+	label = gkm_secret_object_get_label (test->object);
+	g_assert_cmpstr (label, ==, "hello");
+}
+
+static void
+test_identifier_get_attr (Test *test, gconstpointer unused)
+{
+	gchar buffer[32];
+	CK_ATTRIBUTE attr = { CKA_ID, buffer, 32 };
+	CK_RV rv;
+
+	rv = gkm_object_get_attribute (GKM_OBJECT (test->object), test->session, &attr);
+	g_assert (rv == CKR_OK);
+	g_assert (attr.ulValueLen == 13);
+	g_assert (memcmp (buffer, "my-identifier", 13) == 0);
+}
+
+static void
+test_label_get_attr (Test *test, gconstpointer unused)
+{
+	gchar buffer[32];
+	CK_ATTRIBUTE attr = { CKA_LABEL, buffer, 32 };
+	CK_RV rv;
+
+	gkm_secret_object_set_label (test->object, "hello");
+	rv = gkm_object_get_attribute (GKM_OBJECT (test->object), test->session, &attr);
+	g_assert (rv == CKR_OK);
+	g_assert (attr.ulValueLen == 5);
+	g_assert (memcmp (buffer, "hello", 5) == 0);
+}
+
+static void
+test_label_set_attr (Test *test, gconstpointer unused)
+{
+	CK_ATTRIBUTE attr = { CKA_LABEL, "hello", 5 };
+	GkmTransaction *transaction = gkm_transaction_new ();
+
+	/* Monitor for changes */
+	gboolean notified = FALSE;
+	g_signal_connect (test->object, "notify::label", G_CALLBACK (was_notified), &notified);
+
+	gkm_object_set_attribute (GKM_OBJECT (test->object), test->session, transaction, &attr);
+	g_assert (!gkm_transaction_get_failed (transaction));
+	g_assert (!notified); /* Not notified yet */
+
+	g_assert_cmpstr (gkm_secret_object_get_label (test->object), ==, "hello");
+
+	gkm_transaction_complete (transaction);
+	g_assert_cmpstr (gkm_secret_object_get_label (test->object), ==, "hello");
+	g_assert (notified); /* Notified after transaction complete */
+
+	g_object_unref (transaction);
+}
+
+static void
+test_label_set_attr_fail (Test *test, gconstpointer unused)
+{
+	CK_ATTRIBUTE attr = { CKA_LABEL, "hello", 5 };
+	GkmTransaction *transaction = gkm_transaction_new ();
+	gboolean notified = FALSE;
+
+	/* Set an old value */
+	gkm_secret_object_set_label (test->object, "old");
+
+	/* Monitor for changes */
+	g_signal_connect (test->object, "notify::label", G_CALLBACK (was_notified), &notified);
+
+	/* Set a new value */
+	gkm_object_set_attribute (GKM_OBJECT (test->object), test->session, transaction, &attr);
+	g_assert (!gkm_transaction_get_failed (transaction));
+	g_assert (!notified); /* Not notified yet */
+
+	/* Temporarily has new value */
+	g_assert_cmpstr (gkm_secret_object_get_label (test->object), ==, "hello");
+
+	/* Fail and complete transaction */
+	gkm_transaction_fail (transaction, CKR_CANCEL);
+	gkm_transaction_complete (transaction);
+
+	/* Back to old value */
+	g_assert_cmpstr (gkm_secret_object_get_label (test->object), ==, "old");
+	g_assert (!notified); /* Should never have notified */
+
+	g_object_unref (transaction);
+}
+
+static void
+test_modified_get_attr (Test *test, gconstpointer unused)
+{
+	gchar buffer[32];
+	CK_ATTRIBUTE attr = { CKA_G_MODIFIED, buffer, 32 };
+	CK_RV rv;
+
+	gkm_secret_object_set_modified (test->object, 1247930171);
+	rv = gkm_object_get_attribute (GKM_OBJECT (test->object), test->session, &attr);
+	g_assert (rv == CKR_OK);
+	g_assert (attr.ulValueLen == 16);
+	g_assert (memcmp (buffer, "2009071815161100", 16) == 0);
+}
+
+static void
+test_created_get_attr (Test *test, gconstpointer unused)
+{
+	gchar buffer[32];
+	CK_ATTRIBUTE attr = { CKA_G_CREATED, buffer, 32 };
+	CK_RV rv;
+
+	gkm_secret_object_set_created (test->object, 1247930171);
+	rv = gkm_object_get_attribute (GKM_OBJECT (test->object), test->session, &attr);
+	g_assert (rv == CKR_OK);
+	g_assert (attr.ulValueLen == 16);
+	g_assert (memcmp (buffer, "2009071815161100", 16) == 0);
+}
+
+static void
+test_locked_get_attr (Test *test, gconstpointer unused)
+{
+	gchar buffer[32];
+	CK_ATTRIBUTE attr = { CKA_G_LOCKED, buffer, 32 };
+	CK_RV rv;
+
+	rv = gkm_object_get_attribute (GKM_OBJECT (test->object), test->session, &attr);
+	g_assert (rv == CKR_OK);
+	g_assert (attr.ulValueLen == 1);
+	g_assert (memcmp (buffer, "\0", 1) == 0);
+}
+
+int
+main (int argc, char **argv)
+{
+	g_type_init ();
+	g_test_init (&argc, &argv, NULL);
+
+	g_test_add ("/secret-store/object/is_locked", Test, NULL, setup, test_is_locked, teardown);
+	g_test_add ("/secret-store/object/identifier_prop", Test, NULL, setup, test_identifier_prop, teardown);
+	g_test_add ("/secret-store/object/created_prop", Test, NULL, setup, test_created_prop, teardown);
+	g_test_add ("/secret-store/object/modified_prop", Test, NULL, setup, test_modified_prop, teardown);
+	g_test_add ("/secret-store/object/was_modified", Test, NULL, setup, test_was_modified, teardown);
+	g_test_add ("/secret-store/object/label_prop", Test, NULL, setup, test_label_prop, teardown);
+	g_test_add ("/secret-store/object/identifier_get_attr", Test, NULL, setup, test_identifier_get_attr, teardown);
+	g_test_add ("/secret-store/object/label_get_attr", Test, NULL, setup, test_label_get_attr, teardown);
+	g_test_add ("/secret-store/object/label_set_attr", Test, NULL, setup, test_label_set_attr, teardown);
+	g_test_add ("/secret-store/object/label_set_attr_fail", Test, NULL, setup, test_label_set_attr_fail, teardown);
+	g_test_add ("/secret-store/object/modified_get_attr", Test, NULL, setup, test_modified_get_attr, teardown);
+	g_test_add ("/secret-store/object/created_get_attr", Test, NULL, setup, test_created_get_attr, teardown);
+	g_test_add ("/secret-store/object/locked_get_attr", Test, NULL, setup, test_locked_get_attr, teardown);
+
+	return g_test_run ();
+}
diff --git a/pkcs11/secret-store/tests/unit-test-secret-search.c b/pkcs11/secret-store/tests/test-secret-search.c
index ead2aa25..303a3144 100644
--- a/pkcs11/secret-store/tests/unit-test-secret-search.c
+++ b/pkcs11/secret-store/tests/test-secret-search.c
@@ -1,6 +1,5 @@
 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
-/* unit-test-secret-collection.c: Test the collection keyring
-
+/*
    Copyright (C) 2009 Stefan Walter
 
    The Gnome Keyring Library is free software; you can redistribute it and/or
@@ -23,13 +22,12 @@
 
 #include "config.h"
 
-#include "test-suite.h"
-#include "test-secret-module.h"
+#include "mock-secret-module.h"
 
-#include "gkm-secret-collection.h"
-#include "gkm-secret-fields.h"
-#include "gkm-secret-item.h"
-#include "gkm-secret-search.h"
+#include "secret-store/gkm-secret-collection.h"
+#include "secret-store/gkm-secret-fields.h"
+#include "secret-store/gkm-secret-item.h"
+#include "secret-store/gkm-secret-search.h"
 
 #include "gkm/gkm-session.h"
 #include "gkm/gkm-transaction.h"
@@ -42,59 +40,62 @@
 #include <stdio.h>
 #include <string.h>
 
-static GkmModule *module = NULL;
-static GkmSession *session = NULL;
-static GkmFactory *factory = NULL;
-static GkmSecretCollection *collection = NULL;
-static GkmSecretItem *item = NULL;
+typedef struct {
+	GkmModule *module;
+	GkmSession *session;
+	GkmFactory *factory;
+	GkmSecretCollection *collection;
+	GkmSecretItem *item;
+} Test;
 
-TESTING_SETUP(secret_search)
+static void
+setup (Test *test, gconstpointer unused)
 {
 	GHashTable *fields;
 
-	module = test_secret_module_initialize_and_enter ();
-	session = test_secret_module_open_session (TRUE);
-	factory = GKM_FACTORY_SECRET_SEARCH;
-	g_assert (factory);
+	test->module = test_secret_module_initialize_and_enter ();
+	test->session = test_secret_module_open_session (TRUE);
+	test->factory = GKM_FACTORY_SECRET_SEARCH;
+	g_assert (test->factory);
 
-	collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
-	                           "module", module,
-	                           "manager", gkm_session_get_manager (session),
+	test->collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
+	                           "module", test->module,
+	                           "manager", gkm_session_get_manager (test->session),
 	                           "identifier", "test-collection",
 	                           NULL);
 
-	/* Create an item */
-	item = gkm_secret_collection_new_item (collection, "test-item");
+	/* Create an test->item */
+	test->item = gkm_secret_collection_new_item (test->collection, "test-item");
 	fields = gkm_secret_fields_new ();
 	gkm_secret_fields_add (fields, "name1", "value1");
 	gkm_secret_fields_add (fields, "name2", "value2");
-	gkm_secret_item_set_fields (item, fields);
+	gkm_secret_item_set_fields (test->item, fields);
 	g_hash_table_unref (fields);
 
-	gkm_object_expose (GKM_OBJECT (collection), TRUE);
+	gkm_object_expose (GKM_OBJECT (test->collection), TRUE);
 }
 
-TESTING_TEARDOWN(secret_search)
+static void
+teardown (Test *test, gconstpointer unused)
 {
-	g_object_unref (collection);
-
+	g_object_unref (test->collection);
 	test_secret_module_leave_and_finalize ();
-	module = NULL;
-	session = NULL;
 }
 
-TESTING_TEST(create_search_incomplete)
+static void
+test_incomplete (Test *test, gconstpointer unused)
 {
 	CK_ATTRIBUTE attrs[1];
 	GkmObject *object = NULL;
 	GkmTransaction *transaction = gkm_transaction_new ();
 
-	object = gkm_session_create_object_for_factory (session, factory, transaction, attrs, 0);
+	object = gkm_session_create_object_for_factory (test->session, test->factory, transaction, attrs, 0);
 	g_assert (gkm_transaction_complete_and_unref (transaction) == CKR_TEMPLATE_INCOMPLETE);
 	g_assert (object == NULL);
 }
 
-TESTING_TEST(create_search_bad_fields)
+static void
+test_bad_fields (Test *test, gconstpointer unused)
 {
 	CK_ATTRIBUTE attrs[] = {
 	        { CKA_G_FIELDS, "bad-value", 9 },
@@ -103,12 +104,13 @@ TESTING_TEST(create_search_bad_fields)
 	GkmObject *object = NULL;
 	GkmTransaction *transaction = gkm_transaction_new ();
 
-	object = gkm_session_create_object_for_factory (session, factory, transaction, attrs, 1);
+	object = gkm_session_create_object_for_factory (test->session, test->factory, transaction, attrs, 1);
 	g_assert (gkm_transaction_complete_and_unref (transaction) == CKR_ATTRIBUTE_VALUE_INVALID);
 	g_assert (object == NULL);
 }
 
-TESTING_TEST(create_search)
+static void
+test_new (Test *test, gconstpointer unused)
 {
 	CK_ATTRIBUTE attrs[] = {
 	        { CKA_G_FIELDS, "test\0value\0two\0value2", 22 },
@@ -122,30 +124,30 @@ TESTING_TEST(create_search)
 	gboolean vbool;
 	gsize vsize;
 
-	object = gkm_session_create_object_for_factory (session, factory, NULL, attrs, 1);
+	object = gkm_session_create_object_for_factory (test->session, test->factory, NULL, attrs, 1);
 	g_assert (object != NULL);
 	g_assert (GKM_IS_SECRET_SEARCH (object));
 
-	if (!gkm_object_get_attribute_ulong (object, session, CKA_CLASS, &vulong))
+	if (!gkm_object_get_attribute_ulong (object, test->session, CKA_CLASS, &vulong))
 		g_assert_not_reached ();
 	g_assert (vulong == CKO_G_SEARCH);
 
-	if (!gkm_object_get_attribute_boolean (object, session, CKA_MODIFIABLE, &vbool))
+	if (!gkm_object_get_attribute_boolean (object, test->session, CKA_MODIFIABLE, &vbool))
 		g_assert_not_reached ();
 	g_assert (vbool == CK_TRUE);
 
-	vdata = gkm_object_get_attribute_data (object, session, CKA_G_FIELDS, &vsize);
+	vdata = gkm_object_get_attribute_data (object, test->session, CKA_G_FIELDS, &vsize);
 	g_assert (vdata);
 	g_assert (vsize == attrs[0].ulValueLen);
 	g_free (vdata);
 
-	vdata = gkm_object_get_attribute_data (object, session, CKA_G_COLLECTION, &vsize);
+	vdata = gkm_object_get_attribute_data (object, test->session, CKA_G_COLLECTION, &vsize);
 	g_assert (vdata);
 	g_assert (vsize == 0);
 	g_free (vdata);
 
 	/* No objects matched */
-	vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
+	vdata = gkm_object_get_attribute_data (object, test->session, CKA_G_MATCHED, &vsize);
 	g_assert (vdata);
 	g_assert (vsize == 0);
 	g_free (vdata);
@@ -155,14 +157,15 @@ TESTING_TEST(create_search)
 	g_assert (fields);
 	g_assert_cmpstr (gkm_secret_fields_get (fields, "test"), ==, "value");
 
-	/* No collection */
+	/* No test->collection */
 	identifier = gkm_secret_search_get_collection_id (GKM_SECRET_SEARCH (object));
 	g_assert (identifier == NULL);
 
 	g_object_unref (object);
 }
 
-TESTING_TEST(create_search_and_match)
+static void
+test_and_match (Test *test, gconstpointer unused)
 {
 	CK_ATTRIBUTE attrs[] = {
 	        { CKA_G_FIELDS, "name1\0value1\0name2\0value2", 26 },
@@ -172,21 +175,22 @@ TESTING_TEST(create_search_and_match)
 	gpointer vdata;
 	gsize vsize;
 
-	object = gkm_session_create_object_for_factory (session, factory, NULL, attrs, 1);
+	object = gkm_session_create_object_for_factory (test->session, test->factory, NULL, attrs, 1);
 	g_assert (object != NULL);
 	g_assert (GKM_IS_SECRET_SEARCH (object));
 
 	/* One object matched */
-	vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
+	vdata = gkm_object_get_attribute_data (object, test->session, CKA_G_MATCHED, &vsize);
 	g_assert (vdata);
 	g_assert (vsize == sizeof (CK_OBJECT_HANDLE));
-	g_assert (*((CK_OBJECT_HANDLE_PTR)vdata) == gkm_object_get_handle (GKM_OBJECT (item)));
+	g_assert (*((CK_OBJECT_HANDLE_PTR)vdata) == gkm_object_get_handle (GKM_OBJECT (test->item)));
 	g_free (vdata);
 
 	g_object_unref (object);
 }
 
-TESTING_TEST(create_search_and_change_to_match)
+static void
+test_and_change_to_match (Test *test, gconstpointer unused)
 {
 	CK_ATTRIBUTE attrs[] = {
 	        { CKA_G_FIELDS, "name1\0value1", 13 },
@@ -199,15 +203,15 @@ TESTING_TEST(create_search_and_change_to_match)
 
 	/* Make it not match */
 	fields = gkm_secret_fields_new ();
-	gkm_secret_item_set_fields (item, fields);
+	gkm_secret_item_set_fields (test->item, fields);
 	g_hash_table_unref (fields);
 
-	object = gkm_session_create_object_for_factory (session, factory, NULL, attrs, 1);
+	object = gkm_session_create_object_for_factory (test->session, test->factory, NULL, attrs, 1);
 	g_assert (object != NULL);
 	g_assert (GKM_IS_SECRET_SEARCH (object));
 
 	/* Nothing matched */
-	vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
+	vdata = gkm_object_get_attribute_data (object, test->session, CKA_G_MATCHED, &vsize);
 	g_assert (vsize == 0);
 	g_free (vdata);
 
@@ -215,20 +219,21 @@ TESTING_TEST(create_search_and_change_to_match)
 	fields = gkm_secret_fields_new ();
 	gkm_secret_fields_add (fields, "name1", "value1");
 	gkm_secret_fields_add (fields, "name2", "value2");
-	gkm_secret_item_set_fields (item, fields);
+	gkm_secret_item_set_fields (test->item, fields);
 	g_hash_table_unref (fields);
 
 	/* One object matched */
-	vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
+	vdata = gkm_object_get_attribute_data (object, test->session, CKA_G_MATCHED, &vsize);
 	g_assert (vdata);
 	g_assert (vsize == sizeof (CK_OBJECT_HANDLE));
-	g_assert (*((CK_OBJECT_HANDLE_PTR)vdata) == gkm_object_get_handle (GKM_OBJECT (item)));
+	g_assert (*((CK_OBJECT_HANDLE_PTR)vdata) == gkm_object_get_handle (GKM_OBJECT (test->item)));
 	g_free (vdata);
 
 	g_object_unref (object);
 }
 
-TESTING_TEST(create_search_and_change_to_not_match)
+static void
+test_and_change_to_not_match (Test *test, gconstpointer unused)
 {
 	CK_ATTRIBUTE attrs[] = {
 	        { CKA_G_FIELDS, "name1\0value1", 13 },
@@ -239,47 +244,49 @@ TESTING_TEST(create_search_and_change_to_not_match)
 	gpointer vdata;
 	gsize vsize;
 
-	object = gkm_session_create_object_for_factory (session, factory, NULL, attrs, 1);
+	object = gkm_session_create_object_for_factory (test->session, test->factory, NULL, attrs, 1);
 	g_assert (object != NULL);
 	g_assert (GKM_IS_SECRET_SEARCH (object));
 
 	/* One object matched */
-	vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
+	vdata = gkm_object_get_attribute_data (object, test->session, CKA_G_MATCHED, &vsize);
 	g_assert (vdata);
 	g_assert (vsize == sizeof (CK_OBJECT_HANDLE));
-	g_assert (*((CK_OBJECT_HANDLE_PTR)vdata) == gkm_object_get_handle (GKM_OBJECT (item)));
+	g_assert (*((CK_OBJECT_HANDLE_PTR)vdata) == gkm_object_get_handle (GKM_OBJECT (test->item)));
 	g_free (vdata);
 
 	/* Make it not match */
 	fields = gkm_secret_fields_new ();
-	gkm_secret_item_set_fields (item, fields);
+	gkm_secret_item_set_fields (test->item, fields);
 	g_hash_table_unref (fields);
 
 	/* Nothing matched */
-	vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
+	vdata = gkm_object_get_attribute_data (object, test->session, CKA_G_MATCHED, &vsize);
 	g_assert (vsize == 0);
 	g_free (vdata);
 
 	g_object_unref (object);
 }
 
-TESTING_TEST(create_search_for_bad_collection)
+static void
+test_for_bad_collection (Test *test, gconstpointer unused)
 {
 	CK_ATTRIBUTE attrs[] = {
 	        { CKA_G_FIELDS, "name1\0value1", 13 },
-	        { CKA_G_COLLECTION, "bad-collection", 14 },
+	        { CKA_G_COLLECTION, "bad-test->collection", 14 },
 	};
 
 	GkmObject *object = NULL;
 	GkmTransaction *transaction = gkm_transaction_new ();
 
-	object = gkm_session_create_object_for_factory (session, factory, transaction, attrs, 2);
+	object = gkm_session_create_object_for_factory (test->session, test->factory, transaction, attrs, 2);
 	g_assert (gkm_transaction_complete_and_unref (transaction) == CKR_OK);
 
 	g_object_unref (object);
 }
 
-TESTING_TEST(create_search_for_collection)
+static void
+test_for_collection (Test *test, gconstpointer unused)
 {
 	CK_ATTRIBUTE attrs[] = {
 	        { CKA_G_FIELDS, "name1\0value1", 13 },
@@ -290,28 +297,29 @@ TESTING_TEST(create_search_for_collection)
 	gpointer vdata;
 	gsize vsize;
 
-	object = gkm_session_create_object_for_factory (session, factory, NULL, attrs, 2);
+	object = gkm_session_create_object_for_factory (test->session, test->factory, NULL, attrs, 2);
 	g_assert (object != NULL);
 	g_assert (GKM_IS_SECRET_SEARCH (object));
 
-	/* Should have the collection set properly */
-	vdata = gkm_object_get_attribute_data (object, session, CKA_G_COLLECTION , &vsize);
+	/* Should have the test->collection set properly */
+	vdata = gkm_object_get_attribute_data (object, test->session, CKA_G_COLLECTION , &vsize);
 	g_assert (vdata);
 	g_assert (vsize == 15);
 	g_assert (memcmp (vdata, "test-collection", 15) == 0);
 	g_free (vdata);
 
 	/* One object matched */
-	vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
+	vdata = gkm_object_get_attribute_data (object, test->session, CKA_G_MATCHED, &vsize);
 	g_assert (vdata);
 	g_assert (vsize == sizeof (CK_OBJECT_HANDLE));
-	g_assert (*((CK_OBJECT_HANDLE_PTR)vdata) == gkm_object_get_handle (GKM_OBJECT (item)));
+	g_assert (*((CK_OBJECT_HANDLE_PTR)vdata) == gkm_object_get_handle (GKM_OBJECT (test->item)));
 	g_free (vdata);
 
 	g_object_unref (object);
 }
 
-TESTING_TEST(create_search_for_collection_no_match)
+static void
+test_for_collection_no_match (Test *test, gconstpointer unused)
 {
 	CK_ATTRIBUTE attrs[] = {
 	        { CKA_G_FIELDS, "test\0value", 11 },
@@ -326,8 +334,8 @@ TESTING_TEST(create_search_for_collection_no_match)
 	gsize vsize;
 
 	ocoll = g_object_new (GKM_TYPE_SECRET_COLLECTION,
-	                      "module", module,
-	                      "manager", gkm_session_get_manager (session),
+	                      "module", test->module,
+	                      "manager", gkm_session_get_manager (test->session),
 	                      "identifier", "other-collection",
 	                      NULL);
 	oitem = gkm_secret_collection_new_item (ocoll, "other-item");
@@ -339,15 +347,34 @@ TESTING_TEST(create_search_for_collection_no_match)
 	gkm_secret_item_set_fields (oitem, fields);
 	g_hash_table_unref (fields);
 
-	object = gkm_session_create_object_for_factory (session, factory, NULL, attrs, 2);
+	object = gkm_session_create_object_for_factory (test->session, test->factory, NULL, attrs, 2);
 	g_assert (object != NULL);
 	g_assert (GKM_IS_SECRET_SEARCH (object));
 
 	/* No objects matched */
-	vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
+	vdata = gkm_object_get_attribute_data (object, test->session, CKA_G_MATCHED, &vsize);
 	g_assert (vsize == 0);
 	g_free (vdata);
 
 	g_object_unref (object);
 	g_object_unref (ocoll);
 }
+
+int
+main (int argc, char **argv)
+{
+	g_type_init ();
+	g_test_init (&argc, &argv, NULL);
+
+	g_test_add ("/secret-store/search/new", Test, NULL, setup, test_new, teardown);
+	g_test_add ("/secret-store/search/incomplete", Test, NULL, setup, test_incomplete, teardown);
+	g_test_add ("/secret-store/search/bad_fields", Test, NULL, setup, test_bad_fields, teardown);
+	g_test_add ("/secret-store/search/and_match", Test, NULL, setup, test_and_match, teardown);
+	g_test_add ("/secret-store/search/and_change_to_match", Test, NULL, setup, test_and_change_to_match, teardown);
+	g_test_add ("/secret-store/search/and_change_to_not_match", Test, NULL, setup, test_and_change_to_not_match, teardown);
+	g_test_add ("/secret-store/search/for_bad_collection", Test, NULL, setup, test_for_bad_collection, teardown);
+	g_test_add ("/secret-store/search/for_collection", Test, NULL, setup, test_for_collection, teardown);
+	g_test_add ("/secret-store/search/for_collection_no_match", Test, NULL, setup, test_for_collection_no_match, teardown);
+
+	return g_test_run ();
+}
diff --git a/pkcs11/secret-store/tests/test-secret-textual.c b/pkcs11/secret-store/tests/test-secret-textual.c
new file mode 100644
index 00000000..4c8a5aed
--- /dev/null
+++ b/pkcs11/secret-store/tests/test-secret-textual.c
@@ -0,0 +1,205 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/*
+   Copyright (C) 2009 Stefan Walter
+
+   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 <stef@memberwebs.com>
+*/
+
+#include "config.h"
+
+#include "mock-secret-module.h"
+
+#include "secret-store/gkm-secret-collection.h"
+#include "secret-store/gkm-secret-data.h"
+#include "secret-store/gkm-secret-fields.h"
+#include "secret-store/gkm-secret-item.h"
+#include "secret-store/gkm-secret-textual.h"
+
+#include "gkm/gkm-secret.h"
+
+#include "pkcs11/pkcs11i.h"
+
+#include <glib.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct {
+	GkmModule *module;
+	GkmSession *session;
+	GkmSecretCollection *collection;
+	GkmSecretData *sdata;
+} Test;
+
+static void
+setup (Test *test, gconstpointer unused)
+{
+	test->module = test_secret_module_initialize_and_enter ();
+	test->session = test_secret_module_open_session (TRUE);
+
+	test->collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
+	                           "module", test->module,
+	                           "identifier", "test",
+	                           "label", "brigadooooooooooooon",
+	                           NULL);
+
+	test->sdata = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
+
+	g_assert (GKM_IS_SECRET_COLLECTION (test->collection));
+
+}
+
+static void
+teardown (Test *test, gconstpointer unused)
+{
+	if (test->collection)
+		g_object_unref (test->collection);
+	if (test->sdata)
+		g_object_unref (test->sdata);
+	test_secret_module_leave_and_finalize ();
+}
+
+static void
+test_read (Test *test, gconstpointer unused)
+{
+	GkmDataResult res;
+	gchar *data;
+	gsize n_data;
+
+	if (!g_file_get_contents (SRCDIR "/files/plain.keyring", &data, &n_data, NULL))
+		g_assert_not_reached ();
+	res = gkm_secret_textual_read (test->collection, test->sdata, data, n_data);
+	g_free (data);
+
+	test_secret_collection_validate (test->collection, test->sdata);
+
+	g_assert (res == GKM_DATA_SUCCESS);
+}
+
+static void
+test_read_wrong_format (Test *test, gconstpointer unused)
+{
+	GkmDataResult res;
+	gchar *data;
+	gsize n_data;
+
+	if (!g_file_get_contents (SRCDIR "/files/encrypted.keyring", &data, &n_data, NULL))
+		g_assert_not_reached ();
+
+	res = gkm_secret_textual_read (test->collection, test->sdata, data, n_data);
+	g_free (data);
+
+	g_assert (res == GKM_DATA_UNRECOGNIZED);
+}
+
+static void
+test_read_bad_number (Test *test, gconstpointer unused)
+{
+	GkmSecretItem *item;
+	GkmDataResult res;
+	const gchar *value;
+	gchar *data;
+	gsize n_data;
+
+	if (!g_file_get_contents (SRCDIR "/files/plain-bad-number.keyring", &data, &n_data, NULL))
+		g_assert_not_reached ();
+	res = gkm_secret_textual_read (test->collection, test->sdata, data, n_data);
+	g_free (data);
+
+	g_assert (res == GKM_DATA_SUCCESS);
+
+	item = gkm_secret_collection_get_item (test->collection, "1");
+	g_assert (GKM_IS_SECRET_ITEM (item));
+	value = gkm_secret_fields_get (gkm_secret_item_get_fields (item), "bad-number");
+	g_assert (value == NULL);
+	value = gkm_secret_fields_get (gkm_secret_item_get_fields (item), "missing-number");
+	g_assert (value == NULL);
+}
+
+static void
+test_write (Test *test, gconstpointer unused)
+{
+	GkmDataResult res;
+	gpointer data;
+	gsize n_data;
+
+	test_secret_collection_populate (test->collection, test->sdata);
+
+	res = gkm_secret_textual_write (test->collection, test->sdata, &data, &n_data);
+	g_assert (res == GKM_DATA_SUCCESS);
+	g_assert (data);
+	g_assert (n_data);
+
+	/* Try parsing it again */
+	res = gkm_secret_textual_read (test->collection, test->sdata, data, n_data);
+	g_assert (res == GKM_DATA_SUCCESS);
+}
+
+static void
+test_remove_unavailable (Test *test, gconstpointer unused)
+{
+	GkmDataResult res;
+	GList *items;
+	gchar *data;
+	gsize n_data;
+
+	if (!g_file_get_contents (SRCDIR "/files/plain.keyring", &data, &n_data, NULL))
+		g_assert_not_reached ();
+	res = gkm_secret_textual_read (test->collection, test->sdata, data, n_data);
+	g_assert (res == GKM_DATA_SUCCESS);
+
+	/* Two items from the file */
+	items = gkm_secret_collection_get_items (test->collection);
+	g_assert_cmpint (g_list_length (items), ==, 2);
+	g_list_free (items);
+
+	/* Fill in some more data */
+	test_secret_collection_populate (test->collection, test->sdata);
+
+	/* Should have added three more */
+	items = gkm_secret_collection_get_items (test->collection);
+	g_assert_cmpint (g_list_length (items), ==, 5);
+	g_list_free (items);
+
+	/* Re-read the keyring */
+	res = gkm_secret_textual_read (test->collection, test->sdata, data, n_data);
+	g_assert (res == GKM_DATA_SUCCESS);
+
+	/* And we're back to two */
+	items = gkm_secret_collection_get_items (test->collection);
+	g_assert_cmpint (g_list_length (items), ==, 2);
+	g_list_free (items);
+
+	g_free (data);
+}
+
+int
+main (int argc, char **argv)
+{
+	g_type_init ();
+	g_test_init (&argc, &argv, NULL);
+
+	g_test_add ("/secret-store/search/read", Test, NULL, setup, test_read, teardown);
+	g_test_add ("/secret-store/search/read_wrong_format", Test, NULL, setup, test_read_wrong_format, teardown);
+	g_test_add ("/secret-store/search/read_bad_number", Test, NULL, setup, test_read_bad_number, teardown);
+	g_test_add ("/secret-store/search/write", Test, NULL, setup, test_write, teardown);
+	g_test_add ("/secret-store/search/remove_unavailable", Test, NULL, setup, test_remove_unavailable, teardown);
+
+	return g_test_run ();
+}
diff --git a/pkcs11/secret-store/tests/unit-test-secret-binary.c b/pkcs11/secret-store/tests/unit-test-secret-binary.c
deleted file mode 100644
index 6efc9493..00000000
--- a/pkcs11/secret-store/tests/unit-test-secret-binary.c
+++ /dev/null
@@ -1,200 +0,0 @@
-/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
-/* unit-test-secret-binary.c: Test binary keyring read and write
-
-   Copyright (C) 2009 Stefan Walter
-
-   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 <stef@memberwebs.com>
-*/
-
-#include "config.h"
-
-#include "test-suite.h"
-#include "test-secret-module.h"
-
-#include "gkm-secret-binary.h"
-#include "gkm-secret-collection.h"
-#include "gkm-secret-data.h"
-#include "gkm-secret-fields.h"
-#include "gkm-secret-item.h"
-
-#include "gkm/gkm-secret.h"
-
-#include "pkcs11/pkcs11i.h"
-
-#include <glib.h>
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-static GkmModule *module = NULL;
-static GkmSession *session = NULL;
-static GkmSecretCollection *collection = NULL;
-static GkmSecretData *sdata = NULL;
-
-TESTING_SETUP(binary)
-{
-	GkmSecret *master;
-
-	module = test_secret_module_initialize_and_enter ();
-	session = test_secret_module_open_session (TRUE);
-
-	collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
-	                           "module", module,
-	                           "identifier", "test",
-	                           "label", "brigadooooooooooooon",
-	                           NULL);
-
-	sdata = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
-	master = gkm_secret_new_from_password ("my-keyring-password");
-	gkm_secret_data_set_master (sdata, master);
-	g_object_unref (master);
-
-	g_assert (GKM_IS_SECRET_COLLECTION (collection));
-
-}
-
-TESTING_TEARDOWN(binary)
-{
-	if (collection)
-		g_object_unref (collection);
-	collection = NULL;
-
-	if (sdata)
-		g_object_unref (sdata);
-	sdata = NULL;
-
-	test_secret_module_leave_and_finalize ();
-	module = NULL;
-	session = NULL;
-}
-
-TESTING_TEST(binary_read)
-{
-	GkmDataResult res;
-	guchar *data;
-	gsize n_data;
-
-	data = testing_data_read ("encrypted.keyring", &n_data);
-	res = gkm_secret_binary_read (collection, sdata, data, n_data);
-	g_free (data);
-
-	test_secret_collection_validate (collection, sdata);
-
-	g_assert (res == GKM_DATA_SUCCESS);
-}
-
-TESTING_TEST(binary_read_wrong_format)
-{
-	GkmDataResult res;
-	guchar *data;
-	gsize n_data;
-
-	data = testing_data_read ("plain.keyring", &n_data);
-	res = gkm_secret_binary_read (collection, sdata, data, n_data);
-	g_free (data);
-
-	g_assert (res == GKM_DATA_UNRECOGNIZED);
-}
-
-TESTING_TEST(binary_read_wrong_master)
-{
-	GkmDataResult res;
-	GkmSecret *master;
-	guchar *data;
-	gsize n_data;
-
-	master = gkm_secret_new_from_password ("wrong");
-	gkm_secret_data_set_master (sdata, master);
-	g_object_unref (master);
-
-	data = testing_data_read ("encrypted.keyring", &n_data);
-	res = gkm_secret_binary_read (collection, sdata, data, n_data);
-	g_free (data);
-
-	g_assert (res == GKM_DATA_LOCKED);
-}
-
-TESTING_TEST(binary_read_sdata_but_no_master)
-{
-	GkmDataResult res;
-	guchar *data;
-	gsize n_data;
-
-	gkm_secret_data_set_master (sdata, NULL);
-
-	data = testing_data_read ("encrypted.keyring", &n_data);
-	res = gkm_secret_binary_read (collection, sdata, data, n_data);
-	g_free (data);
-
-	g_assert (res == GKM_DATA_LOCKED);
-}
-
-TESTING_TEST(binary_write)
-{
-	GkmDataResult res;
-	guchar *data;
-	gsize n_data;
-
-	test_secret_collection_populate (collection, sdata);
-
-	res = gkm_secret_binary_write (collection, sdata, &data, &n_data);
-	g_assert (res == GKM_DATA_SUCCESS);
-	g_assert (data);
-	g_assert (n_data);
-
-	/* Try parsing it again */
-	res = gkm_secret_binary_read (collection, sdata, data, n_data);
-	g_assert (res == GKM_DATA_SUCCESS);
-}
-
-TESTING_TEST(binary_remove_unavailable)
-{
-	GkmDataResult res;
-	GList *items;
-	guchar *data;
-	gsize n_data;
-
-	data = testing_data_read ("encrypted.keyring", &n_data);
-	res = gkm_secret_binary_read (collection, sdata, data, n_data);
-	g_assert (res == GKM_DATA_SUCCESS);
-
-	/* Two items from the file */
-	items = gkm_secret_collection_get_items (collection);
-	g_assert_cmpint (g_list_length (items), ==, 2);
-	g_list_free (items);
-
-	/* Fill in some more data */
-	test_secret_collection_populate (collection, sdata);
-
-	/* Should have added three more */
-	items = gkm_secret_collection_get_items (collection);
-	g_assert_cmpint (g_list_length (items), ==, 5);
-	g_list_free (items);
-
-	/* Re-read the keyring */
-	res = gkm_secret_binary_read (collection, sdata, data, n_data);
-	g_assert (res == GKM_DATA_SUCCESS);
-
-	/* And we're back to two */
-	items = gkm_secret_collection_get_items (collection);
-	g_assert_cmpint (g_list_length (items), ==, 2);
-	g_list_free (items);
-
-	g_free (data);
-}
diff --git a/pkcs11/secret-store/tests/unit-test-secret-collection.c b/pkcs11/secret-store/tests/unit-test-secret-collection.c
deleted file mode 100644
index e2d2f131..00000000
--- a/pkcs11/secret-store/tests/unit-test-secret-collection.c
+++ /dev/null
@@ -1,563 +0,0 @@
-/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
-/* unit-test-secret-collection.c: Test the collection keyring
-
-   Copyright (C) 2009 Stefan Walter
-
-   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 <stef@memberwebs.com>
-*/
-
-#include "config.h"
-
-#include "test-suite.h"
-#include "test-secret-module.h"
-
-#include "gkm-secret-data.h"
-#include "gkm-secret-collection.h"
-#include "gkm-secret-item.h"
-
-#include "gkm/gkm-credential.h"
-#include "gkm/gkm-session.h"
-#include "gkm/gkm-transaction.h"
-
-#include "pkcs11/pkcs11i.h"
-
-#include <glib.h>
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-static GkmModule *module = NULL;
-static GkmSession *session = NULL;
-static CK_OBJECT_HANDLE credential = 0;
-static CK_OBJECT_HANDLE credential2 = 0;
-static GkmSecretCollection *collection = NULL;
-
-TESTING_SETUP(secret_collection)
-{
-	CK_OBJECT_CLASS klass = CKO_G_CREDENTIAL;
-	GkmObject *cred;
-
-	CK_ATTRIBUTE attrs[] = {
-		{ CKA_CLASS, &klass, sizeof (klass) },
-		{ CKA_VALUE, NULL, 0 }
-	};
-
-	module = test_secret_module_initialize_and_enter ();
-	session = test_secret_module_open_session (TRUE);
-
-	collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
-	                           "module", module,
-	                           "identifier", "test",
-	                           NULL);
-	g_assert (GKM_IS_SECRET_COLLECTION (collection));
-
-	/* Make two credentials */
-	cred = gkm_session_create_object_for_factory (session, GKM_FACTORY_CREDENTIAL, NULL,
-	                                            attrs, G_N_ELEMENTS (attrs));
-	g_assert (cred != NULL);
-	credential = gkm_object_get_handle (GKM_OBJECT (cred));
-	g_object_unref (cred);
-
-	cred = gkm_session_create_object_for_factory (session, GKM_FACTORY_CREDENTIAL, NULL,
-	                                            attrs, G_N_ELEMENTS (attrs));
-	g_assert (cred != NULL);
-	credential2 = gkm_object_get_handle (GKM_OBJECT (cred));
-	g_object_unref (cred);
-}
-
-TESTING_TEARDOWN(secret_collection)
-{
-	if (collection)
-		g_object_unref (collection);
-	collection = NULL;
-
-	test_secret_module_leave_and_finalize ();
-	module = NULL;
-	session = NULL;
-	credential = 0;
-}
-
-TESTING_TEST(secret_collection_is_locked)
-{
-	gboolean locked;
-
-	/* By default is locked */
-	locked = gkm_secret_object_is_locked (GKM_SECRET_OBJECT (collection), session);
-	g_assert (locked == TRUE);
-}
-
-TESTING_TEST(secret_collection_unlocked_data)
-{
-	GkmCredential *cred;
-	GkmSecretData *sdata;
-	CK_RV rv;
-
-	/* Create credential, which unlocks collection */
-	rv = gkm_credential_create (module, gkm_session_get_manager (session), GKM_OBJECT (collection), NULL, 0, &cred);
-	g_assert (rv == CKR_OK);
-	gkm_session_add_session_object (session, NULL, GKM_OBJECT (cred));
-	g_object_unref (cred);
-
-	/* Collection should now be unlocked */
-	sdata = gkm_secret_collection_unlocked_use (collection, session);
-	g_assert (GKM_IS_SECRET_DATA (sdata));
-	g_assert (!gkm_secret_object_is_locked (GKM_SECRET_OBJECT (collection), session));
-	g_object_unref (sdata);
-}
-
-TESTING_TEST(secret_collection_get_filename)
-{
-	GkmSecretCollection *other;
-	const gchar *filename;
-
-	other = g_object_new (GKM_TYPE_SECRET_COLLECTION,
-	                      "module", module,
-	                      "identifier", "test",
-	                      "filename", "/tmp/filename.keyring",
-	                      NULL);
-
-	filename = gkm_secret_collection_get_filename (other);
-	g_assert_cmpstr (filename, ==, "/tmp/filename.keyring");
-
-	g_object_unref (other);
-}
-
-TESTING_TEST(secret_collection_set_filename)
-{
-	const gchar *filename;
-
-	gkm_secret_collection_set_filename (collection, "/tmp/filename.keyring");
-
-	filename = gkm_secret_collection_get_filename (collection);
-	g_assert_cmpstr (filename, ==, "/tmp/filename.keyring");
-}
-
-TESTING_TEST(secret_collection_has_item)
-{
-	GkmSecretItem *item;
-
-	item = gkm_secret_collection_new_item (collection, "testo");
-	g_assert (gkm_secret_collection_has_item (collection, item));
-}
-
-TESTING_TEST(secret_collection_load_unlock_plain)
-{
-	GkmCredential *cred;
-	GkmSecretData *sdata;
-	GkmDataResult res;
-	gchar *filename;
-	CK_RV rv;
-
-	filename = testing_data_filename ("plain.keyring");
-	gkm_secret_collection_set_filename (collection, filename);
-	g_free (filename);
-
-	/* Load the data in the file */
-	res = gkm_secret_collection_load (collection);
-	g_assert (res == GKM_DATA_SUCCESS);
-
-	/* Unlock the keyring, which should load again */
-	rv = gkm_credential_create (module, gkm_session_get_manager (session), GKM_OBJECT (collection), NULL, 0, &cred);
-	g_assert (rv == CKR_OK);
-	gkm_session_add_session_object (session, NULL, GKM_OBJECT (cred));
-	g_object_unref (cred);
-
-	sdata = gkm_secret_collection_unlocked_use (collection, session);
-	g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
-	test_secret_collection_validate (collection, sdata);
-	g_object_unref (sdata);
-}
-
-TESTING_TEST(secret_collection_load_unlock_encrypted)
-{
-	GkmCredential *cred;
-	GkmSecretData *sdata;
-	GkmDataResult res;
-	gchar *filename;
-	CK_RV rv;
-
-	filename = testing_data_filename ("encrypted.keyring");
-	gkm_secret_collection_set_filename (collection, filename);
-	g_free (filename);
-
-	/* Load the data in the file */
-	res = gkm_secret_collection_load (collection);
-	g_assert (res == GKM_DATA_SUCCESS);
-
-	/* Unlock the keyring, which should load again */
-	rv = gkm_credential_create (module, gkm_session_get_manager (session), GKM_OBJECT (collection),
-	                            (guchar*)"my-keyring-password", 19, &cred);
-	g_assert (rv == CKR_OK);
-	gkm_session_add_session_object (session, NULL, GKM_OBJECT (cred));
-	g_object_unref (cred);
-
-	sdata = gkm_secret_collection_unlocked_use (collection, session);
-	g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
-	test_secret_collection_validate (collection, sdata);
-	g_object_unref (sdata);
-}
-
-TESTING_TEST(secret_collection_load_unlock_bad_password)
-{
-	GkmCredential *cred;
-	GkmDataResult res;
-	gchar *filename;
-	CK_RV rv;
-
-	filename = testing_data_filename ("encrypted.keyring");
-	gkm_secret_collection_set_filename (collection, filename);
-	g_free (filename);
-
-	/* Load the data in the file */
-	res = gkm_secret_collection_load (collection);
-	g_assert (res == GKM_DATA_SUCCESS);
-
-	/* Unlock the keyring, which should load again */
-	rv = gkm_credential_create (module, gkm_session_get_manager (session), GKM_OBJECT (collection),
-	                            (guchar*)"wrong", 5, &cred);
-	g_assert (rv == CKR_PIN_INCORRECT);
-}
-
-TESTING_TEST(secret_collection_unlock_without_load)
-{
-	GkmCredential *cred;
-	GkmSecretData *sdata;
-	gchar *filename;
-	CK_RV rv;
-
-	filename = testing_data_filename ("encrypted.keyring");
-	gkm_secret_collection_set_filename (collection, filename);
-	g_free (filename);
-
-	/* Unlock the keyring, which should load it */
-	rv = gkm_credential_create (module, gkm_session_get_manager (session), GKM_OBJECT (collection),
-	                            (guchar*)"my-keyring-password", 19, &cred);
-	g_assert (rv == CKR_OK);
-	gkm_session_add_session_object (session, NULL, GKM_OBJECT (cred));
-	g_object_unref (cred);
-
-	sdata = gkm_secret_collection_unlocked_use (collection, session);
-	g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
-	test_secret_collection_validate (collection, sdata);
-	g_object_unref (sdata);
-}
-
-TESTING_TEST(secret_collection_twice_unlock)
-{
-	GkmCredential *cred;
-	GkmSecretData *sdata;
-	gchar *filename;
-	CK_RV rv;
-
-	filename = testing_data_filename ("encrypted.keyring");
-	gkm_secret_collection_set_filename (collection, filename);
-	g_free (filename);
-
-	/* Unlock the keyring, which should load */
-	rv = gkm_credential_create (module, gkm_session_get_manager (session), GKM_OBJECT (collection),
-	                            (guchar*)"my-keyring-password", 19, &cred);
-	g_assert (rv == CKR_OK);
-	gkm_session_add_session_object (session, NULL, GKM_OBJECT (cred));
-	g_object_unref (cred);
-
-	/* Unlock the keyring again, which should not reload */
-	rv = gkm_credential_create (module, gkm_session_get_manager (session), GKM_OBJECT (collection),
-	                            (guchar*)"my-keyring-password", 19, &cred);
-	g_assert (rv == CKR_OK);
-	gkm_session_add_session_object (session, NULL, GKM_OBJECT (cred));
-	g_object_unref (cred);
-
-	sdata = gkm_secret_collection_unlocked_use (collection, session);
-	g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
-	test_secret_collection_validate (collection, sdata);
-	g_object_unref (sdata);
-}
-
-TESTING_TEST(secret_collection_twice_unlock_bad_password)
-{
-	GkmCredential *cred;
-	GkmSecretData *sdata;
-	gchar *filename;
-	CK_RV rv;
-
-	filename = testing_data_filename ("encrypted.keyring");
-	gkm_secret_collection_set_filename (collection, filename);
-	g_free (filename);
-
-	/* Unlock the keyring, which should load */
-	rv = gkm_credential_create (module, gkm_session_get_manager (session), GKM_OBJECT (collection),
-	                               (guchar*)"my-keyring-password", 19, &cred);
-	g_assert (rv == CKR_OK);
-	gkm_session_add_session_object (session, NULL, GKM_OBJECT (cred));
-	g_object_unref (cred);
-
-	/* Unlock the keyring again, wrong password */
-	rv = gkm_credential_create (module, gkm_session_get_manager (session), GKM_OBJECT (collection),
-	                            (guchar*)"wrong", 5, &cred);
-	g_assert (rv == CKR_PIN_INCORRECT);
-
-	sdata = gkm_secret_collection_unlocked_use (collection, session);
-	g_assert (sdata != NULL && GKM_IS_SECRET_DATA (sdata));
-	test_secret_collection_validate (collection, sdata);
-	g_object_unref (sdata);
-}
-
-TESTING_TEST(secret_collection_memory_unlock)
-{
-	GkmCredential *cred;
-	GkmDataResult res;
-	CK_RV rv;
-
-	/* Load the data in the file */
-	res = gkm_secret_collection_load (collection);
-	g_assert (res == GKM_DATA_SUCCESS);
-
-	/* Unlock the keyring, which should load again */
-	rv = gkm_credential_create (module, gkm_session_get_manager (session), GKM_OBJECT (collection),
-	                            NULL, 0, &cred);
-	g_assert (rv == CKR_OK);
-	gkm_session_add_session_object (session, NULL, GKM_OBJECT (cred));
-	g_object_unref (cred);
-}
-
-TESTING_TEST(secret_collection_memory_unlock_bad_password)
-{
-	GkmCredential *cred;
-	GkmDataResult res;
-	CK_RV rv;
-
-	/* Load the data in the file */
-	res = gkm_secret_collection_load (collection);
-	g_assert (res == GKM_DATA_SUCCESS);
-
-	/* Unlock the keyring, which should load again */
-	rv = gkm_credential_create (module, gkm_session_get_manager (session), GKM_OBJECT (collection),
-	                            (guchar*)"wrong", 5, &cred);
-	g_assert (rv == CKR_PIN_INCORRECT);
-}
-
-TESTING_TEST(secret_collection_factory)
-{
-	CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
-	GkmObject *object;
-
-	CK_ATTRIBUTE attrs[] = {
-		{ CKA_CLASS, &klass, sizeof (klass) },
-		{ CKA_LABEL, "blah", 4 },
-		{ CKA_G_CREDENTIAL, &credential, sizeof (credential) },
-	};
-
-	object = gkm_session_create_object_for_factory (session, GKM_FACTORY_SECRET_COLLECTION, NULL,
-	                                                attrs, G_N_ELEMENTS (attrs));
-	g_assert (object != NULL);
-	g_assert (GKM_IS_SECRET_COLLECTION (object));
-
-	g_assert_cmpstr (gkm_secret_object_get_label (GKM_SECRET_OBJECT (object)), ==, "blah");
-	g_object_unref (object);
-}
-
-TESTING_TEST(secret_collection_factory_unnamed)
-{
-	CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
-	const gchar *identifier;
-	GkmObject *object;
-
-	CK_ATTRIBUTE attrs[] = {
-		{ CKA_CLASS, &klass, sizeof (klass) },
-		{ CKA_G_CREDENTIAL, &credential, sizeof (credential) },
-	};
-
-	object = gkm_session_create_object_for_factory (session, GKM_FACTORY_SECRET_COLLECTION, NULL,
-	                                                attrs, G_N_ELEMENTS (attrs));
-	g_assert (object != NULL);
-	g_assert (GKM_IS_SECRET_COLLECTION (object));
-
-	identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
-	g_assert_cmpstr (identifier, !=, "");
-	g_object_unref (object);
-}
-
-TESTING_TEST(secret_collection_factory_token)
-{
-	CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
-	const gchar *identifier;
-	GkmObject *object;
-	CK_BBOOL token = CK_TRUE;
-
-	CK_ATTRIBUTE attrs[] = {
-		{ CKA_CLASS, &klass, sizeof (klass) },
-		{ CKA_TOKEN, &token, sizeof (token) },
-		{ CKA_LABEL, "blah", 4 },
-		{ CKA_G_CREDENTIAL, &credential, sizeof (credential) },
-	};
-
-	object = gkm_session_create_object_for_factory (session, GKM_FACTORY_SECRET_COLLECTION, NULL,
-	                                                attrs, G_N_ELEMENTS (attrs));
-	g_assert (object != NULL);
-	g_assert (GKM_IS_SECRET_COLLECTION (object));
-
-	identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
-	g_assert (strstr (identifier, "blah"));
-	g_object_unref (object);
-}
-
-TESTING_TEST(secret_collection_factory_duplicate)
-{
-	CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
-	const gchar *identifier1, *identifier2;
-	GkmObject *object;
-
-	CK_ATTRIBUTE attrs[] = {
-		{ CKA_G_CREDENTIAL, &credential, sizeof (credential) },
-		{ CKA_CLASS, &klass, sizeof (klass) },
-		{ CKA_LABEL, "blah", 4 },
-	};
-
-	object = gkm_session_create_object_for_factory (session, GKM_FACTORY_SECRET_COLLECTION, NULL,
-	                                                attrs, G_N_ELEMENTS (attrs));
-	g_assert (object != NULL);
-	g_assert (GKM_IS_SECRET_COLLECTION (object));
-
-	identifier1 = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
-	g_assert (strstr (identifier1, "blah"));
-	g_object_unref (object);
-
-	/* Use second credential for second object */
-	attrs[0].pValue = &credential2;
-	object = gkm_session_create_object_for_factory (session, GKM_FACTORY_SECRET_COLLECTION, NULL,
-	                                                attrs, G_N_ELEMENTS (attrs));
-	g_assert (object != NULL);
-	g_assert (GKM_IS_SECRET_COLLECTION (object));
-
-	identifier2 = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
-	g_assert (strstr (identifier2, "blah"));
-	g_object_unref (object);
-
-	g_assert_cmpstr (identifier1, !=, identifier2);
-}
-
-TESTING_TEST(secret_collection_factory_item)
-{
-	CK_OBJECT_CLASS c_klass = CKO_G_COLLECTION;
-	CK_OBJECT_CLASS i_klass = CKO_SECRET_KEY;
-	const gchar *identifier;
-	GkmObject *object;
-	CK_BBOOL token = CK_TRUE;
-
-	CK_ATTRIBUTE c_attrs[] = {
-		{ CKA_CLASS, &c_klass, sizeof (c_klass) },
-		{ CKA_TOKEN, &token, sizeof (token) },
-		{ CKA_LABEL, "three", 5 },
-		{ CKA_G_CREDENTIAL, &credential, sizeof (credential) },
-	};
-
-	CK_ATTRIBUTE i_attrs[] = {
-		{ CKA_G_COLLECTION, NULL, 0 }, /* Filled below */
-		{ CKA_CLASS, &i_klass, sizeof (i_klass) },
-		{ CKA_TOKEN, &token, sizeof (token) },
-		{ CKA_LABEL, "Item", 4 },
-	};
-
-	object = gkm_session_create_object_for_factory (session, GKM_FACTORY_SECRET_COLLECTION, NULL,
-	                                                c_attrs, G_N_ELEMENTS (c_attrs));
-	g_assert (object != NULL);
-	g_assert (GKM_IS_SECRET_COLLECTION (object));
-	identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
-	g_object_unref (object);
-
-	i_attrs[0].pValue = (gpointer)identifier;
-	i_attrs[0].ulValueLen = strlen (identifier);
-	object = gkm_session_create_object_for_factory (session, GKM_FACTORY_SECRET_ITEM, NULL,
-	                                                i_attrs, G_N_ELEMENTS (i_attrs));
-	g_assert (object != NULL);
-	g_assert (GKM_IS_SECRET_ITEM (object));
-	g_object_unref (object);
-}
-
-TESTING_TEST(secret_collection_token_remove)
-{
-	CK_OBJECT_CLASS klass = CKO_G_COLLECTION;
-	GkmTransaction *transaction;
-	GkmObject *object;
-	CK_BBOOL token = CK_TRUE;
-
-	CK_ATTRIBUTE attrs[] = {
-		{ CKA_CLASS, &klass, sizeof (klass) },
-		{ CKA_TOKEN, &token, sizeof (token) },
-		{ CKA_LABEL, "blah", 4 },
-		{ CKA_G_CREDENTIAL, &credential, sizeof (credential) },
-	};
-
-	object = gkm_session_create_object_for_factory (session, GKM_FACTORY_SECRET_COLLECTION, NULL,
-	                                                attrs, G_N_ELEMENTS (attrs));
-	g_assert (object != NULL);
-	g_assert (GKM_IS_SECRET_COLLECTION (object));
-
-	transaction = gkm_transaction_new ();
-	gkm_module_remove_token_object (module, transaction, object);
-	g_assert (!gkm_transaction_get_failed (transaction));
-	gkm_transaction_complete (transaction);
-	g_object_unref (transaction);
-	g_object_unref (object);
-}
-
-TESTING_TEST(secret_collection_token_item_remove)
-{
-	CK_OBJECT_CLASS c_klass = CKO_G_COLLECTION;
-	CK_OBJECT_CLASS i_klass = CKO_SECRET_KEY;
-	GkmTransaction *transaction;
-	const gchar *identifier;
-	GkmObject *object;
-	CK_BBOOL token = CK_TRUE;
-
-	CK_ATTRIBUTE c_attrs[] = {
-		{ CKA_CLASS, &c_klass, sizeof (c_klass) },
-		{ CKA_TOKEN, &token, sizeof (token) },
-		{ CKA_LABEL, "three", 5 },
-		{ CKA_G_CREDENTIAL, &credential, sizeof (credential) },
-	};
-
-	CK_ATTRIBUTE i_attrs[] = {
-		{ CKA_G_COLLECTION, NULL, 0 }, /* Filled below */
-		{ CKA_CLASS, &i_klass, sizeof (i_klass) },
-		{ CKA_TOKEN, &token, sizeof (token) },
-		{ CKA_LABEL, "Item", 4 },
-	};
-
-	object = gkm_session_create_object_for_factory (session, GKM_FACTORY_SECRET_COLLECTION, NULL,
-	                                                c_attrs, G_N_ELEMENTS (c_attrs));
-	g_assert (object != NULL);
-	g_assert (GKM_IS_SECRET_COLLECTION (object));
-	identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (object));
-	g_object_unref (object);
-
-	i_attrs[0].pValue = (gpointer)identifier;
-	i_attrs[0].ulValueLen = strlen (identifier);
-	object = gkm_session_create_object_for_factory (session, GKM_FACTORY_SECRET_ITEM, NULL,
-	                                                i_attrs, G_N_ELEMENTS (i_attrs));
-	g_assert (object != NULL);
-	g_assert (GKM_IS_SECRET_ITEM (object));
-
-	transaction = gkm_transaction_new ();
-	gkm_module_remove_token_object (module, transaction, object);
-	g_assert (!gkm_transaction_get_failed (transaction));
-	gkm_transaction_complete (transaction);
-	g_object_unref (transaction);
-	g_object_unref (object);
-}
diff --git a/pkcs11/secret-store/tests/unit-test-secret-item.c b/pkcs11/secret-store/tests/unit-test-secret-item.c
deleted file mode 100644
index d82396ec..00000000
--- a/pkcs11/secret-store/tests/unit-test-secret-item.c
+++ /dev/null
@@ -1,438 +0,0 @@
-/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
-/* unit-test-secret-item.c: Test secret item
-
-   Copyright (C) 2009 Stefan Walter
-
-   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 <stef@memberwebs.com>
-*/
-
-#include "config.h"
-
-#include "test-suite.h"
-#include "test-secret-module.h"
-
-#include "gkm-secret-collection.h"
-#include "gkm-secret-fields.h"
-#include "gkm-secret-item.h"
-
-#include "gkm/gkm-credential.h"
-#include "gkm/gkm-session.h"
-#include "gkm/gkm-transaction.h"
-
-#include "pkcs11/pkcs11i.h"
-
-#include <glib.h>
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-static GkmModule *module = NULL;
-static GkmSession *session = NULL;
-static GkmSecretCollection *collection = NULL;
-
-TESTING_SETUP(secret_item)
-{
-	module = test_secret_module_initialize_and_enter ();
-	session = test_secret_module_open_session (TRUE);
-
-	collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
-	                           "module", module,
-	                           "identifier", "test",
-	                           NULL);
-}
-
-TESTING_TEARDOWN(secret_item)
-{
-	if (collection)
-		g_object_unref (collection);
-	collection = NULL;
-
-	test_secret_module_leave_and_finalize ();
-	module = NULL;
-	session = NULL;
-
-}
-
-static void
-unlock_collection(void)
-{
-	GkmCredential *cred;
-	GkmObject *object;
-	CK_RV rv;
-
-	/* Create credential, which unlocks collection */
-	object = GKM_OBJECT (collection);
-	rv = gkm_credential_create (gkm_object_get_module (object),
-	                            gkm_session_get_manager (session),
-	                            object, NULL, 0, &cred);
-	g_assert (rv == CKR_OK);
-
-	gkm_session_add_session_object (session, NULL, GKM_OBJECT (cred));
-	g_object_unref (cred);
-}
-
-TESTING_TEST(secret_item_new)
-{
-	GkmSecretItem *item;
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	g_assert (GKM_IS_SECRET_ITEM (item));
-	g_assert_cmpstr (gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (item)), ==, "the-identifier");
-}
-
-TESTING_TEST(secret_item_create)
-{
-	GkmTransaction *transaction;
-	GkmSecretItem *item;
-
-	transaction = gkm_transaction_new ();
-	item = gkm_secret_collection_create_item (collection, transaction);
-	g_assert (GKM_IS_SECRET_ITEM (item));
-	g_object_ref (item);
-	g_assert (gkm_secret_collection_has_item (collection, item));
-
-	gkm_transaction_complete (transaction);
-	g_object_unref (transaction);
-
-	/* Should still be there */
-	g_assert (gkm_secret_collection_has_item (collection, item));
-	g_object_unref (item);
-}
-
-TESTING_TEST(secret_item_create_failed)
-{
-	GkmTransaction *transaction;
-	GkmSecretItem *item;
-
-	transaction = gkm_transaction_new ();
-	item = gkm_secret_collection_create_item (collection, transaction);
-	g_assert (GKM_IS_SECRET_ITEM (item));
-	g_object_ref (item);
-	g_assert (gkm_secret_collection_has_item (collection, item));
-
-	gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
-	gkm_transaction_complete (transaction);
-	g_object_unref (transaction);
-
-	/* Should no longer be there */
-	g_assert (!gkm_secret_collection_has_item (collection, item));
-	g_object_unref (item);
-}
-
-TESTING_TEST(secret_item_destroy)
-{
-	GkmTransaction *transaction;
-	GkmSecretItem *item;
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	g_assert (gkm_secret_collection_has_item (collection, item));
-	g_object_ref (item);
-
-	transaction = gkm_transaction_new ();
-	gkm_secret_collection_destroy_item (collection, transaction, item);
-	g_assert (!gkm_secret_collection_has_item (collection, item));
-
-	gkm_transaction_complete (transaction);
-	g_object_unref (transaction);
-
-	/* Should not be there */
-	g_assert (!gkm_secret_collection_has_item (collection, item));
-	g_object_unref (item);
-}
-
-TESTING_TEST(secret_item_destroy_failed)
-{
-	GkmTransaction *transaction;
-	GkmSecretItem *item;
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	g_assert (gkm_secret_collection_has_item (collection, item));
-	g_object_ref (item);
-
-	transaction = gkm_transaction_new ();
-	gkm_secret_collection_destroy_item (collection, transaction, item);
-	g_assert (!gkm_secret_collection_has_item (collection, item));
-
-	gkm_transaction_fail (transaction, CKR_GENERAL_ERROR);
-	gkm_transaction_complete (transaction);
-	g_object_unref (transaction);
-
-	/* Should be there */
-	g_assert (gkm_secret_collection_has_item (collection, item));
-	g_object_unref (item);
-}
-
-TESTING_TEST(secret_item_collection_get)
-{
-	GkmSecretItem *item, *check;
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	g_assert (GKM_IS_SECRET_ITEM (item));
-
-	check = gkm_secret_collection_get_item (collection, "the-identifier");
-	g_assert (item == check);
-}
-
-TESTING_TEST(secret_item_collection_items)
-{
-	GList *l, *items;
-	const gchar *identifier;
-
-	gkm_secret_collection_new_item (collection, "one-identifier");
-	gkm_secret_collection_new_item (collection, "two-identifier");
-	gkm_secret_collection_new_item (collection, "three-identifier");
-
-	items = gkm_secret_collection_get_items (collection);
-	g_assert_cmpuint (g_list_length (items), ==, 3);
-	for (l = items; l; l = g_list_next (l)) {
-		identifier = gkm_secret_object_get_identifier (l->data);
-		if (!g_str_equal (identifier, "one-identifier") &&
-		    !g_str_equal (identifier, "two-identifier") &&
-		    !g_str_equal (identifier, "three-identifier"))
-			g_assert_not_reached ();
-	}
-
-	g_list_free (items);
-}
-
-TESTING_TEST(secret_item_collection_remove)
-{
-	GkmSecretItem *item;
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	g_assert (gkm_secret_collection_get_item (collection, "the-identifier") == item);
-
-	gkm_secret_collection_remove_item (collection, item);
-	g_assert (gkm_secret_collection_get_item (collection, "the-identifier") == NULL);
-}
-
-TESTING_TEST(secret_item_is_locked)
-{
-	GkmSecretItem *item;
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	g_assert (gkm_secret_object_is_locked (GKM_SECRET_OBJECT (item), session) ==
-	          gkm_secret_object_is_locked (GKM_SECRET_OBJECT (collection), session));
-
-	unlock_collection();
-
-	g_assert (gkm_secret_object_is_locked (GKM_SECRET_OBJECT (item), session) == FALSE);
-}
-
-TESTING_TEST(secret_item_get_collection)
-{
-	GkmSecretItem *item;
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	g_assert (gkm_secret_item_get_collection (item) == collection);
-}
-
-TESTING_TEST(secret_item_tracks_collection)
-{
-	GkmSecretItem *item;
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	g_object_ref (item);
-
-	unlock_collection();
-
-	/* At this point the item should be 'unlocked' */
-	g_assert (gkm_secret_object_is_locked (GKM_SECRET_OBJECT (item), session) == FALSE);
-
-	g_object_unref (collection);
-	collection = NULL;
-
-	/* Collection went away */
-	g_assert (gkm_secret_item_get_collection (item) == NULL);
-	g_assert (gkm_secret_object_is_locked (GKM_SECRET_OBJECT (item), session) == TRUE);
-
-	g_object_unref (item);
-}
-
-TESTING_TEST(secret_item_get_set_fields)
-{
-	GHashTable *fields = gkm_secret_fields_new ();
-	GHashTable *check;
-	GkmSecretItem *item;
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	gkm_secret_item_set_fields (item, fields);
-	gkm_secret_item_set_fields (item, fields);
-
-	check = gkm_secret_item_get_fields (item);
-	g_assert (check == fields);
-
-	g_hash_table_unref (fields);
-}
-
-TESTING_TEST(secret_item_collection_attr)
-{
-	gchar buffer[32];
-	CK_ATTRIBUTE check = { CKA_G_COLLECTION, buffer, 32 };
-	GkmSecretItem *item;
-	CK_RV rv;
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	rv = gkm_object_get_attribute (GKM_OBJECT (item), session, &check);
-	g_assert (rv == CKR_OK);
-	g_assert (check.ulValueLen == 4);
-	g_assert (memcmp (buffer, "test", 4) == 0);
-}
-
-TESTING_TEST(secret_item_secret_attr)
-{
-	GkmTransaction *transaction = gkm_transaction_new ();
-	CK_ATTRIBUTE attr = { CKA_VALUE, "hello", 5 };
-	gchar buffer[32];
-	CK_ATTRIBUTE check = { CKA_VALUE, buffer, 32 };
-	GkmSecretItem *item;
-	CK_RV rv;
-
-	unlock_collection ();
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	gkm_object_set_attribute (GKM_OBJECT (item), session, transaction, &attr);
-	g_assert (gkm_transaction_get_failed (transaction) == FALSE);
-	gkm_transaction_complete (transaction);
-	g_assert (gkm_transaction_get_result (transaction) == CKR_OK);
-
-	g_object_unref (transaction);
-
-	rv = gkm_object_get_attribute (GKM_OBJECT (item), session, &check);
-	g_assert (rv == CKR_OK);
-	g_assert (check.ulValueLen == 5);
-	g_assert (memcmp (buffer, "hello", 5) == 0);
-}
-
-TESTING_TEST(secret_item_secret_attr_locked)
-{
-	GkmTransaction *transaction = gkm_transaction_new ();
-	CK_ATTRIBUTE attr = { CKA_VALUE, "hello", 5 };
-	gchar buffer[32];
-	CK_ATTRIBUTE check = { CKA_VALUE, buffer, 32 };
-	GkmSecretItem *item;
-	CK_RV rv;
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	gkm_object_set_attribute (GKM_OBJECT (item), session, transaction, &attr);
-	g_assert (gkm_transaction_get_failed (transaction) == TRUE);
-	gkm_transaction_complete (transaction);
-	g_assert (gkm_transaction_get_result (transaction) == CKR_USER_NOT_LOGGED_IN);
-
-	g_object_unref (transaction);
-
-	rv = gkm_object_get_attribute (GKM_OBJECT (item), session, &check);
-	g_assert (rv == CKR_USER_NOT_LOGGED_IN);
-}
-
-TESTING_TEST(secret_item_fields_attr)
-{
-	GkmTransaction *transaction = gkm_transaction_new ();
-	CK_ATTRIBUTE attr = { CKA_G_FIELDS, "name1\0value1\0name2\0value2", 26 };
-	gchar buffer[32];
-	CK_ATTRIBUTE check = { CKA_G_FIELDS, buffer, 32 };
-	GkmSecretItem *item;
-	GHashTable *fields;
-	const gchar *value;
-	CK_RV rv;
-
-	unlock_collection ();
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	gkm_object_set_attribute (GKM_OBJECT (item), session, transaction, &attr);
-	g_assert (gkm_transaction_get_failed (transaction) == FALSE);
-	gkm_transaction_complete (transaction);
-	g_assert (gkm_transaction_get_result (transaction) == CKR_OK);
-
-	g_object_unref (transaction);
-
-	rv = gkm_object_get_attribute (GKM_OBJECT (item), session, &check);
-	g_assert (rv == CKR_OK);
-	g_assert (check.ulValueLen == 26);
-	g_assert (memcmp (buffer, "name1\0value1\0name2\0value2", 26) == 0);
-
-	fields = gkm_secret_item_get_fields (item);
-	g_assert (fields);
-	value = gkm_secret_fields_get (fields, "name1");
-	g_assert_cmpstr (value, ==, "value1");
-	value = gkm_secret_fields_get (fields, "name2");
-	g_assert_cmpstr (value, ==, "value2");
-}
-
-TESTING_TEST(secret_item_fields_attr_locked)
-{
-	GkmTransaction *transaction = gkm_transaction_new ();
-	CK_ATTRIBUTE attr = { CKA_G_FIELDS, "name1\0value1\0name2\0value2", 26 };
-	GkmSecretItem *item;
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-	gkm_object_set_attribute (GKM_OBJECT (item), session, transaction, &attr);
-	g_assert (gkm_transaction_get_failed (transaction) == TRUE);
-	gkm_transaction_complete (transaction);
-	g_assert (gkm_transaction_get_result (transaction) == CKR_USER_NOT_LOGGED_IN);
-
-	g_object_unref (transaction);
-}
-
-TESTING_TEST(secret_item_fields_attr_reverts)
-{
-	GkmTransaction *transaction = gkm_transaction_new ();
-	CK_ATTRIBUTE attr = { CKA_G_FIELDS, "new\0value\0", 10 };
-	gchar buffer[32];
-	CK_ATTRIBUTE check = { CKA_G_FIELDS, buffer, 32 };
-	GkmSecretItem *item;
-	GHashTable *fields;
-	CK_RV rv;
-
-	unlock_collection ();
-
-	item = gkm_secret_collection_new_item (collection, "the-identifier");
-
-	/* Set the old value like so */
-	fields = gkm_secret_fields_new ();
-	gkm_secret_fields_add (fields, "old", "value");
-	gkm_secret_item_set_fields (item, fields);
-	g_hash_table_unref (fields);
-
-	/* Should show old value */
-	rv = gkm_object_get_attribute (GKM_OBJECT (item), session, &check);
-	g_assert (rv == CKR_OK);
-	g_assert (check.ulValueLen == 10);
-	g_assert (memcmp (buffer, "old\0value\0", 10) == 0);
-
-	/* Set the new values */
-	gkm_object_set_attribute (GKM_OBJECT (item), session, transaction, &attr);
-	g_assert (gkm_transaction_get_failed (transaction) == FALSE);
-
-	/* Should have the new value */
-	rv = gkm_object_get_attribute (GKM_OBJECT (item), session, &check);
-	g_assert (rv == CKR_OK);
-	g_assert (check.ulValueLen == 10);
-	g_assert (memcmp (buffer, "new\0value\0", 10) == 0);
-
-	/* Fail the transaction */
-	gkm_transaction_fail (transaction, CKR_CANCEL);
-	gkm_transaction_complete (transaction);
-
-	/* Should show the old value */
-	rv = gkm_object_get_attribute (GKM_OBJECT (item), session, &check);
-	g_assert (rv == CKR_OK);
-	g_assert (check.ulValueLen == 10);
-	g_assert (memcmp (buffer, "old\0value\0", 10) == 0);
-
-	g_object_unref (transaction);
-}
diff --git a/pkcs11/secret-store/tests/unit-test-secret-object.c b/pkcs11/secret-store/tests/unit-test-secret-object.c
deleted file mode 100644
index b915e40a..00000000
--- a/pkcs11/secret-store/tests/unit-test-secret-object.c
+++ /dev/null
@@ -1,269 +0,0 @@
-/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
-/* unit-test-secret-collection.c: Test the collection keyring
-
-   Copyright (C) 2009 Stefan Walter
-
-   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 <stef@memberwebs.com>
-*/
-
-#include "config.h"
-
-#include "test-suite.h"
-#include "test-secret-module.h"
-
-#include "gkm-secret-object.h"
-
-#include "gkm/gkm-transaction.h"
-
-#include "pkcs11/pkcs11i.h"
-
-#include <glib.h>
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-static GkmModule *module = NULL;
-static GkmSession *session = NULL;
-static GkmSecretObject *object = NULL;
-
-TESTING_SETUP(secret_object)
-{
-	module = test_secret_module_initialize_and_enter ();
-	session = test_secret_module_open_session (TRUE);
-
-	object = g_object_new (GKM_TYPE_SECRET_OBJECT,
-	                       "module", module,
-	                       "identifier", "my-identifier",
-	                       NULL);
-
-	g_assert (GKM_IS_SECRET_OBJECT (object));
-}
-
-TESTING_TEARDOWN(secret_object)
-{
-	g_object_unref (object);
-	object = NULL;
-
-	test_secret_module_leave_and_finalize ();
-	module = NULL;
-	session = NULL;
-}
-
-TESTING_TEST(secret_object_is_locked)
-{
-	/* Plain GkmSecretObject is never locked */
-	g_assert (!gkm_secret_object_is_locked (object, session));
-}
-
-TESTING_TEST(secret_object_identifier_prop)
-{
-	const gchar *identifier;
-	identifier = gkm_secret_object_get_identifier (object);
-	g_assert_cmpstr (identifier, ==, "my-identifier");
-}
-
-static void
-was_notified (GObject *obj, GParamSpec *pspec, gpointer user_data)
-{
-	gboolean* notified = user_data;
-	g_assert (GKM_SECRET_OBJECT (obj) == object);
-	g_assert (user_data);
-	*notified = TRUE;
-}
-
-TESTING_TEST(secret_object_created_prop)
-{
-	glong created;
-
-	/* Monitor for changes */
-	gboolean notified = FALSE;
-	g_signal_connect (object, "notify::created", G_CALLBACK (was_notified), &notified);
-
-	/* Default value */
-	created = gkm_secret_object_get_created (object);
-	g_assert (created == 0);
-
-	/* Set a new value */
-	gkm_secret_object_set_created (object, 1247930171);
-	g_assert (notified);
-	created = gkm_secret_object_get_created (object);
-	g_assert (created == 1247930171);
-}
-
-TESTING_TEST(secret_object_modified_prop)
-{
-	glong modified;
-
-	/* Monitor for changes */
-	gboolean notified = FALSE;
-	g_signal_connect (object, "notify::modified", G_CALLBACK (was_notified), &notified);
-
-	/* Default value */
-	modified = gkm_secret_object_get_modified (object);
-	g_assert (modified == 0);
-
-	/* Set a new value */
-	gkm_secret_object_set_modified (object, 1247930171);
-	g_assert (notified);
-	modified = gkm_secret_object_get_modified (object);
-	g_assert (modified == 1247930171);
-}
-
-TESTING_TEST(secret_object_was_modified)
-{
-	GTimeVal tv;
-	g_get_current_time (&tv);
-	gkm_secret_object_was_modified (object);
-	g_assert (tv.tv_sec == gkm_secret_object_get_modified (object));
-}
-
-TESTING_TEST(secret_object_label_prop)
-{
-	const gchar *label;
-
-	/* Monitor for changes */
-	gboolean notified = FALSE;
-	g_signal_connect (object, "notify::label", G_CALLBACK (was_notified), &notified);
-
-	/* Default value */
-	label = gkm_secret_object_get_label (object);
-	g_assert_cmpstr (label, ==, "");
-
-	/* Set a new value */
-	gkm_secret_object_set_label (object, "hello");
-	g_assert (notified);
-	label = gkm_secret_object_get_label (object);
-	g_assert_cmpstr (label, ==, "hello");
-}
-
-TESTING_TEST(secret_object_identifier_get_attr)
-{
-	gchar buffer[32];
-	CK_ATTRIBUTE attr = { CKA_ID, buffer, 32 };
-	CK_RV rv;
-
-	rv = gkm_object_get_attribute (GKM_OBJECT (object), session, &attr);
-	g_assert (rv == CKR_OK);
-	g_assert (attr.ulValueLen == 13);
-	g_assert (memcmp (buffer, "my-identifier", 13) == 0);
-}
-
-TESTING_TEST(secret_object_label_get_attr)
-{
-	gchar buffer[32];
-	CK_ATTRIBUTE attr = { CKA_LABEL, buffer, 32 };
-	CK_RV rv;
-
-	gkm_secret_object_set_label (object, "hello");
-	rv = gkm_object_get_attribute (GKM_OBJECT (object), session, &attr);
-	g_assert (rv == CKR_OK);
-	g_assert (attr.ulValueLen == 5);
-	g_assert (memcmp (buffer, "hello", 5) == 0);
-}
-
-TESTING_TEST(secret_object_label_set_attr)
-{
-	CK_ATTRIBUTE attr = { CKA_LABEL, "hello", 5 };
-	GkmTransaction *transaction = gkm_transaction_new ();
-
-	/* Monitor for changes */
-	gboolean notified = FALSE;
-	g_signal_connect (object, "notify::label", G_CALLBACK (was_notified), &notified);
-
-	gkm_object_set_attribute (GKM_OBJECT (object), session, transaction, &attr);
-	g_assert (!gkm_transaction_get_failed (transaction));
-	g_assert (!notified); /* Not notified yet */
-
-	g_assert_cmpstr (gkm_secret_object_get_label (object), ==, "hello");
-
-	gkm_transaction_complete (transaction);
-	g_assert_cmpstr (gkm_secret_object_get_label (object), ==, "hello");
-	g_assert (notified); /* Notified after transaction complete */
-
-	g_object_unref (transaction);
-}
-
-TESTING_TEST(secret_object_label_set_attr_fail)
-{
-	CK_ATTRIBUTE attr = { CKA_LABEL, "hello", 5 };
-	GkmTransaction *transaction = gkm_transaction_new ();
-	gboolean notified = FALSE;
-
-	/* Set an old value */
-	gkm_secret_object_set_label (object, "old");
-
-	/* Monitor for changes */
-	g_signal_connect (object, "notify::label", G_CALLBACK (was_notified), &notified);
-
-	/* Set a new value */
-	gkm_object_set_attribute (GKM_OBJECT (object), session, transaction, &attr);
-	g_assert (!gkm_transaction_get_failed (transaction));
-	g_assert (!notified); /* Not notified yet */
-
-	/* Temporarily has new value */
-	g_assert_cmpstr (gkm_secret_object_get_label (object), ==, "hello");
-
-	/* Fail and complete transaction */
-	gkm_transaction_fail (transaction, CKR_CANCEL);
-	gkm_transaction_complete (transaction);
-
-	/* Back to old value */
-	g_assert_cmpstr (gkm_secret_object_get_label (object), ==, "old");
-	g_assert (!notified); /* Should never have notified */
-
-	g_object_unref (transaction);
-}
-
-TESTING_TEST(secret_object_modified_get_attr)
-{
-	gchar buffer[32];
-	CK_ATTRIBUTE attr = { CKA_G_MODIFIED, buffer, 32 };
-	CK_RV rv;
-
-	gkm_secret_object_set_modified (object, 1247930171);
-	rv = gkm_object_get_attribute (GKM_OBJECT (object), session, &attr);
-	g_assert (rv == CKR_OK);
-	g_assert (attr.ulValueLen == 16);
-	g_assert (memcmp (buffer, "2009071815161100", 16) == 0);
-}
-
-TESTING_TEST(secret_object_created_get_attr)
-{
-	gchar buffer[32];
-	CK_ATTRIBUTE attr = { CKA_G_CREATED, buffer, 32 };
-	CK_RV rv;
-
-	gkm_secret_object_set_created (object, 1247930171);
-	rv = gkm_object_get_attribute (GKM_OBJECT (object), session, &attr);
-	g_assert (rv == CKR_OK);
-	g_assert (attr.ulValueLen == 16);
-	g_assert (memcmp (buffer, "2009071815161100", 16) == 0);
-}
-
-TESTING_TEST(secret_object_locked_get_attr)
-{
-	gchar buffer[32];
-	CK_ATTRIBUTE attr = { CKA_G_LOCKED, buffer, 32 };
-	CK_RV rv;
-
-	rv = gkm_object_get_attribute (GKM_OBJECT (object), session, &attr);
-	g_assert (rv == CKR_OK);
-	g_assert (attr.ulValueLen == 1);
-	g_assert (memcmp (buffer, "\0", 1) == 0);
-}
diff --git a/pkcs11/secret-store/tests/unit-test-secret-textual.c b/pkcs11/secret-store/tests/unit-test-secret-textual.c
deleted file mode 100644
index 4f4af27d..00000000
--- a/pkcs11/secret-store/tests/unit-test-secret-textual.c
+++ /dev/null
@@ -1,184 +0,0 @@
-/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
-/* unit-test-secret-textual.c: Test textual keyring read and write
-
-   Copyright (C) 2009 Stefan Walter
-
-   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 <stef@memberwebs.com>
-*/
-
-#include "config.h"
-
-#include "test-suite.h"
-#include "test-secret-module.h"
-
-#include "gkm-secret-collection.h"
-#include "gkm-secret-data.h"
-#include "gkm-secret-fields.h"
-#include "gkm-secret-item.h"
-#include "gkm-secret-textual.h"
-
-#include "gkm/gkm-secret.h"
-
-#include "pkcs11/pkcs11i.h"
-
-#include <glib.h>
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-static GkmModule *module = NULL;
-static GkmSession *session = NULL;
-static GkmSecretCollection *collection = NULL;
-static GkmSecretData *sdata = NULL;
-
-TESTING_SETUP(textual)
-{
-	module = test_secret_module_initialize_and_enter ();
-	session = test_secret_module_open_session (TRUE);
-
-	collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
-	                           "module", module,
-	                           "identifier", "test",
-	                           "label", "brigadooooooooooooon",
-	                           NULL);
-
-	sdata = g_object_new (GKM_TYPE_SECRET_DATA, NULL);
-
-	g_assert (GKM_IS_SECRET_COLLECTION (collection));
-
-}
-
-TESTING_TEARDOWN(textual)
-{
-	if (collection)
-		g_object_unref (collection);
-	collection = NULL;
-
-	if (sdata)
-		g_object_unref (sdata);
-	sdata = NULL;
-
-	test_secret_module_leave_and_finalize ();
-	module = NULL;
-	session = NULL;
-}
-
-TESTING_TEST(textual_read)
-{
-	GkmDataResult res;
-	guchar *data;
-	gsize n_data;
-
-	data = testing_data_read ("plain.keyring", &n_data);
-	res = gkm_secret_textual_read (collection, sdata, data, n_data);
-	g_free (data);
-
-	test_secret_collection_validate (collection, sdata);
-
-	g_assert (res == GKM_DATA_SUCCESS);
-}
-
-TESTING_TEST(textual_read_wrong_format)
-{
-	GkmDataResult res;
-	guchar *data;
-	gsize n_data;
-
-	data = testing_data_read ("encrypted.keyring", &n_data);
-	res = gkm_secret_textual_read (collection, sdata, data, n_data);
-	g_free (data);
-
-	g_assert (res == GKM_DATA_UNRECOGNIZED);
-}
-
-TESTING_TEST(textual_read_bad_number)
-{
-	GkmSecretItem *item;
-	GkmDataResult res;
-	const gchar *value;
-	guchar *data;
-	gsize n_data;
-
-	data = testing_data_read ("plain-bad-number.keyring", &n_data);
-	res = gkm_secret_textual_read (collection, sdata, data, n_data);
-	g_free (data);
-
-	g_assert (res == GKM_DATA_SUCCESS);
-
-	item = gkm_secret_collection_get_item (collection, "1");
-	g_assert (GKM_IS_SECRET_ITEM (item));
-	value = gkm_secret_fields_get (gkm_secret_item_get_fields (item), "bad-number");
-	g_assert (value == NULL);
-	value = gkm_secret_fields_get (gkm_secret_item_get_fields (item), "missing-number");
-	g_assert (value == NULL);
-}
-
-TESTING_TEST(textual_write)
-{
-	GkmDataResult res;
-	guchar *data;
-	gsize n_data;
-
-	test_secret_collection_populate (collection, sdata);
-
-	res = gkm_secret_textual_write (collection, sdata, &data, &n_data);
-	g_assert (res == GKM_DATA_SUCCESS);
-	g_assert (data);
-	g_assert (n_data);
-
-	/* Try parsing it again */
-	res = gkm_secret_textual_read (collection, sdata, data, n_data);
-	g_assert (res == GKM_DATA_SUCCESS);
-}
-
-TESTING_TEST(textual_remove_unavailable)
-{
-	GkmDataResult res;
-	GList *items;
-	guchar *data;
-	gsize n_data;
-
-	data = testing_data_read ("plain.keyring", &n_data);
-	res = gkm_secret_textual_read (collection, sdata, data, n_data);
-	g_assert (res == GKM_DATA_SUCCESS);
-
-	/* Two items from the file */
-	items = gkm_secret_collection_get_items (collection);
-	g_assert_cmpint (g_list_length (items), ==, 2);
-	g_list_free (items);
-
-	/* Fill in some more data */
-	test_secret_collection_populate (collection, sdata);
-
-	/* Should have added three more */
-	items = gkm_secret_collection_get_items (collection);
-	g_assert_cmpint (g_list_length (items), ==, 5);
-	g_list_free (items);
-
-	/* Re-read the keyring */
-	res = gkm_secret_textual_read (collection, sdata, data, n_data);
-	g_assert (res == GKM_DATA_SUCCESS);
-
-	/* And we're back to two */
-	items = gkm_secret_collection_get_items (collection);
-	g_assert_cmpint (g_list_length (items), ==, 2);
-	g_list_free (items);
-
-	g_free (data);
-}