/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ /* test-transaction.c: Test transaction functionality Copyright (C) 2008 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, . Author: Stef Walter */ #include "config.h" #include "gkm/gkm-transaction.h" #include typedef struct { int unused; } Test; static void setup (Test* test, gconstpointer unused) { GDir *dir; const gchar *directory; const gchar *basename; gchar *filename; directory = "/tmp"; dir = g_dir_open (directory, 0, NULL); g_assert (dir); for (;;) { basename = g_dir_read_name (dir); if (basename == NULL) break; if (g_str_has_prefix (basename, "transaction-")) { filename = g_build_filename (directory, basename, NULL); g_unlink (filename); g_free (filename); } } g_dir_close (dir); } static void teardown (Test *test, gconstpointer unused) { } static void test_transaction_empty (Test* test, gconstpointer unused) { GkmTransaction *transaction; gboolean completed, failed; CK_RV result; transaction = gkm_transaction_new (); g_assert (GKM_IS_TRANSACTION (transaction)); g_assert (gkm_transaction_get_failed (transaction) == FALSE); g_assert (gkm_transaction_get_completed (transaction) == FALSE); g_assert (gkm_transaction_get_result (transaction) == CKR_OK); gkm_transaction_complete (transaction); /* Make sure values are actually set */ result = (CK_RV)-1; completed = failed = FALSE; g_object_get (transaction, "completed", &completed, "failed", &failed, "result", &result, NULL); g_assert (result == CKR_OK); g_assert (completed == TRUE); g_assert (failed == FALSE); g_object_unref (transaction); } static void test_transaction_fail (Test* test, gconstpointer unused) { GkmTransaction *transaction; transaction = gkm_transaction_new (); gkm_transaction_fail (transaction, CKR_ARGUMENTS_BAD); g_assert (gkm_transaction_get_failed (transaction) == TRUE); g_assert (gkm_transaction_get_completed (transaction) == FALSE); g_assert (gkm_transaction_get_result (transaction) == CKR_ARGUMENTS_BAD); gkm_transaction_complete (transaction); g_assert (gkm_transaction_get_failed (transaction) == TRUE); g_assert (gkm_transaction_get_completed (transaction) == TRUE); g_assert (gkm_transaction_get_result (transaction) == CKR_ARGUMENTS_BAD); g_object_unref (transaction); } static gboolean completed_signal (GkmTransaction *transaction, gpointer data) { g_assert (GKM_IS_TRANSACTION (transaction)); g_assert (data); *((guint*)data) = TRUE; return TRUE; } static gboolean completed_callback (GkmTransaction *transaction, GObject *object, gpointer data) { g_assert (GKM_IS_TRANSACTION (transaction)); g_assert (data); /* In this case we set the object to the transaction for fun */ g_assert (GKM_IS_TRANSACTION (transaction)); g_assert (transaction == GKM_TRANSACTION (object)); *((guint*)data) = gkm_transaction_get_failed (transaction); return TRUE; } static void test_transaction_signals_success (Test* test, gconstpointer unused) { GkmTransaction *transaction = gkm_transaction_new (); /* Initialize with some invalid values */ guint completed = 3; guint failed = 3; g_signal_connect (transaction, "complete", G_CALLBACK (completed_signal), &completed); gkm_transaction_add (transaction, transaction, completed_callback, &failed); /* No callbacks called yet */ g_assert (completed == 3); g_assert (failed == 3); gkm_transaction_complete (transaction); g_assert (completed == TRUE); g_assert (failed == FALSE); g_object_unref (transaction); } static void test_transaction_signals_failure (Test* test, gconstpointer unused) { GkmTransaction *transaction = gkm_transaction_new (); /* Initialize with some invalid values */ guint completed = 3; guint failed = 3; g_signal_connect (transaction, "complete", G_CALLBACK (completed_signal), &completed); gkm_transaction_add (transaction, transaction, completed_callback, &failed); gkm_transaction_fail (transaction, CKR_ARGUMENTS_BAD); /* No callbacks called yet */ g_assert (completed == 3); g_assert (failed == 3); gkm_transaction_complete (transaction); g_assert (completed == TRUE); g_assert (failed == TRUE); g_object_unref (transaction); } static guint order_value = 3; static gboolean order_callback (GkmTransaction *transaction, GObject *object, gpointer data) { g_assert (GKM_IS_TRANSACTION (transaction)); g_assert (data); g_assert (GPOINTER_TO_UINT (data) == order_value); --order_value; return TRUE; } static void test_transaction_order_is_reverse (Test* test, gconstpointer unused) { GkmTransaction *transaction = gkm_transaction_new (); order_value = 3; gkm_transaction_add (transaction, transaction, order_callback, GUINT_TO_POINTER (1)); gkm_transaction_add (transaction, transaction, order_callback, GUINT_TO_POINTER (2)); gkm_transaction_add (transaction, transaction, order_callback, GUINT_TO_POINTER (3)); gkm_transaction_complete (transaction); g_object_unref (transaction); } static void test_transaction_dispose_completes (Test* test, gconstpointer unused) { GkmTransaction *transaction = gkm_transaction_new (); /* Initialize with some invalid values */ guint completed = 3; g_signal_connect (transaction, "complete", G_CALLBACK (completed_signal), &completed); g_object_run_dispose (G_OBJECT (transaction)); g_assert (completed == TRUE); g_object_unref (transaction); } static void test_remove_file_success (Test* test, gconstpointer unused) { GkmTransaction *transaction = gkm_transaction_new (); const gchar *filename = "/tmp/transaction-remove"; g_assert (g_file_set_contents (filename, "xxx", 3, NULL)); g_assert (g_file_test (filename, G_FILE_TEST_IS_REGULAR)); gkm_transaction_remove_file (transaction, filename); g_assert (!gkm_transaction_get_failed (transaction)); g_assert (!g_file_test (filename, G_FILE_TEST_IS_REGULAR)); gkm_transaction_complete (transaction); g_assert (!g_file_test (filename, G_FILE_TEST_IS_REGULAR)); g_object_unref (transaction); } static void test_remove_file_abort (Test* test, gconstpointer unused) { GkmTransaction *transaction = gkm_transaction_new (); const gchar *filename = "/tmp/transaction-remove"; gchar *data; gsize n_data; g_assert (g_file_set_contents (filename, "xxx", 3, NULL)); g_assert (g_file_test (filename, G_FILE_TEST_IS_REGULAR)); gkm_transaction_remove_file (transaction, filename); g_assert (!gkm_transaction_get_failed (transaction)); g_assert (!g_file_test (filename, G_FILE_TEST_IS_REGULAR)); /* Fail the transaction */ gkm_transaction_fail (transaction, CKR_FUNCTION_FAILED); gkm_transaction_complete (transaction); g_assert (gkm_transaction_get_failed (transaction)); g_assert (g_file_test (filename, G_FILE_TEST_IS_REGULAR)); g_assert (g_file_get_contents (filename, &data, &n_data, NULL)); g_assert_cmpuint (n_data, ==, 3); g_assert_cmpstr (data, ==, "xxx"); g_free (data); g_unlink (filename); g_object_unref (transaction); } static void test_remove_file_non_exist (Test* test, gconstpointer unused) { GkmTransaction *transaction = gkm_transaction_new (); const gchar *filename = "/tmp/transaction-non-existant"; g_unlink (filename); /* Should succeed even though not exist */ gkm_transaction_remove_file (transaction, filename); g_assert (!gkm_transaction_get_failed (transaction)); gkm_transaction_complete (transaction); g_object_unref (transaction); } static void do_test_write_file (Test* test) { GkmTransaction *transaction = gkm_transaction_new (); const gchar *filename = "/tmp/transaction-test"; gchar *data; gsize n_data; gkm_transaction_write_file (transaction, filename, (const guchar*)"value", 5); g_assert (!gkm_transaction_get_failed (transaction)); g_assert (g_file_get_contents (filename, &data, &n_data, NULL)); g_assert_cmpuint (n_data, ==, 5); g_assert_cmpstr (data, ==, "value"); g_free (data); gkm_transaction_complete (transaction); g_assert (g_file_get_contents (filename, &data, &n_data, NULL)); g_assert_cmpuint (n_data, ==, 5); g_assert_cmpstr (data, ==, "value"); g_free (data); g_object_unref (transaction); } static void test_write_file (Test* test, gconstpointer unused) { /* Run it two times so that that the second one works on an existing file "/tmp/transaction-test". */ do_test_write_file (test); do_test_write_file (test); } static void test_write_large_file (Test* test, gconstpointer test_data) { guint buffersize = GPOINTER_TO_UINT (test_data); GkmTransaction *transaction = gkm_transaction_new (); const gchar *filename = "/tmp/transaction-test"; gchar *data; gsize n_data; guchar *buffer; int i; buffer = g_malloc (buffersize); for (i=0; i < buffersize; i++) buffer[i] = i; gkm_transaction_write_file (transaction, filename, buffer, buffersize); g_assert (!gkm_transaction_get_failed (transaction)); g_assert (g_file_get_contents (filename, &data, &n_data, NULL)); g_assert_cmpuint (n_data, ==, buffersize); for (i=0; i < buffersize; i++) g_assert_cmpuint (buffer[i], ==, ((guchar*)data)[i]); g_free (data); gkm_transaction_complete (transaction); g_assert (g_file_get_contents (filename, &data, &n_data, NULL)); g_assert_cmpuint (n_data, ==, buffersize); for (i=0; i < buffersize; i++) g_assert_cmpuint (buffer[i], ==, ((guchar*)data)[i]); g_free (data); g_object_unref (transaction); g_free (buffer); } static void do_test_write_file_abort_gone (Test* test) { GkmTransaction *transaction = gkm_transaction_new (); const gchar *filename = "/tmp/transaction-test"; gchar *data; gsize n_data; g_unlink (filename); gkm_transaction_write_file (transaction, filename, (const guchar*)"value", 5); g_assert (!gkm_transaction_get_failed (transaction)); g_assert (g_file_get_contents (filename, &data, &n_data, NULL)); g_assert_cmpuint (n_data, ==, 5); g_assert_cmpstr (data, ==, "value"); g_free (data); gkm_transaction_fail (transaction, CKR_GENERAL_ERROR); gkm_transaction_complete (transaction); g_assert (!g_file_test (filename, G_FILE_TEST_IS_REGULAR)); g_object_unref (transaction); } static void test_write_file_abort_gone (Test* test, gconstpointer unused) { do_test_write_file_abort_gone (test); do_test_write_file_abort_gone (test); } static void do_test_write_file_abort_revert (Test* test) { GkmTransaction *transaction = gkm_transaction_new (); const gchar *filename = "/tmp/transaction-test"; gchar *data; g_assert (g_file_set_contents (filename, "my original", -1, NULL)); gkm_transaction_write_file (transaction, filename, (const guchar*)"new value", 9); g_assert (!gkm_transaction_get_failed (transaction)); g_assert (g_file_get_contents (filename, &data, NULL, NULL)); g_assert_cmpstr (data, ==, "new value"); g_free (data); gkm_transaction_fail (transaction, CKR_GENERAL_ERROR); gkm_transaction_complete (transaction); g_assert (g_file_get_contents (filename, &data, NULL, NULL)); g_assert_cmpstr (data, ==, "my original"); g_free (data); g_object_unref (transaction); } static void test_write_file_abort_revert (Test* test, gconstpointer unused) { do_test_write_file_abort_revert (test); do_test_write_file_abort_revert (test); } static void test_unique_file_conflict (Test* test, gconstpointer unused) { GkmTransaction *transaction = gkm_transaction_new (); const gchar *filename = "/tmp/transaction-test"; gchar *dirname; gchar *basename; gchar *result; dirname = g_path_get_dirname (filename); basename = g_path_get_basename (filename); g_assert (g_file_set_contents (filename, "data", -1, NULL)); result = gkm_transaction_unique_file (transaction, dirname, basename); g_assert (!gkm_transaction_get_failed (transaction)); g_assert (result); g_assert_cmpstr (result, !=, basename); g_assert_cmpstr (result, ==, "transaction-test_1"); g_free (dirname); g_free (basename); g_free (result); g_object_unref (transaction); } static void test_unique_file_conflict_with_ext (Test* test, gconstpointer unused) { GkmTransaction *transaction = gkm_transaction_new (); const gchar *filename = "/tmp/transaction-test.ext"; gchar *dirname; gchar *basename; gchar *result; dirname = g_path_get_dirname (filename); basename = g_path_get_basename (filename); g_assert (g_file_set_contents (filename, "data", -1, NULL)); result = gkm_transaction_unique_file (transaction, dirname, basename); g_assert (!gkm_transaction_get_failed (transaction)); g_assert (result); g_assert_cmpstr (result, !=, basename); g_assert_cmpstr (result, ==, "transaction-test_1.ext"); g_free (dirname); g_free (basename); g_free (result); g_object_unref (transaction); } static void test_unique_file_no_conflict (Test* test, gconstpointer unused) { GkmTransaction *transaction = gkm_transaction_new (); const gchar *dirname = "/tmp"; gchar *result; result = gkm_transaction_unique_file (transaction, dirname, "transaction-another"); g_assert (!gkm_transaction_get_failed (transaction)); g_assert (result); g_assert_cmpstr (result, ==, "transaction-another"); g_free (result); g_object_unref (transaction); } int main (int argc, char **argv) { #if !GLIB_CHECK_VERSION(2,35,0) g_type_init (); #endif g_test_init (&argc, &argv, NULL); g_test_add ("/gkm/transaction/transaction_empty", Test, NULL, setup, test_transaction_empty, teardown); g_test_add ("/gkm/transaction/transaction_fail", Test, NULL, setup, test_transaction_fail, teardown); g_test_add ("/gkm/transaction/transaction_signals_success", Test, NULL, setup, test_transaction_signals_success, teardown); g_test_add ("/gkm/transaction/transaction_signals_failure", Test, NULL, setup, test_transaction_signals_failure, teardown); g_test_add ("/gkm/transaction/transaction_order_is_reverse", Test, NULL, setup, test_transaction_order_is_reverse, teardown); g_test_add ("/gkm/transaction/transaction_dispose_completes", Test, NULL, setup, test_transaction_dispose_completes, teardown); g_test_add ("/gkm/transaction/remove_file_success", Test, NULL, setup, test_remove_file_success, teardown); g_test_add ("/gkm/transaction/remove_file_abort", Test, NULL, setup, test_remove_file_abort, teardown); g_test_add ("/gkm/transaction/remove_file_non_exist", Test, NULL, setup, test_remove_file_non_exist, teardown); g_test_add ("/gkm/transaction/write_file", Test, NULL, setup, test_write_file, teardown); { /* Several test runs at different sizes. Note that the copy function, used if hardlinks do not work, uses a 512 byte buffer. */ guint buffersizes[] = { 2000, 1024, 510, 511, 512, 513, 514, 0 }; int i; gchar test_name[39]; for (i = 0; buffersizes[i]; i++) { g_sprintf (test_name, "/gkm/transaction/write_large_file_%u", buffersizes[i]); g_test_add (test_name, Test, GUINT_TO_POINTER (buffersizes[i]), setup, test_write_large_file, teardown); } } g_test_add ("/gkm/transaction/write_file_abort_gone", Test, NULL, setup, test_write_file_abort_gone, teardown); g_test_add ("/gkm/transaction/write_file_abort_revert", Test, NULL, setup, test_write_file_abort_revert, teardown); g_test_add ("/gkm/transaction/unique_file_conflict", Test, NULL, setup, test_unique_file_conflict, teardown); g_test_add ("/gkm/transaction/unique_file_conflict_with_ext", Test, NULL, setup, test_unique_file_conflict_with_ext, teardown); g_test_add ("/gkm/transaction/unique_file_no_conflict", Test, NULL, setup, test_unique_file_no_conflict, teardown); return g_test_run (); }