depau/libfprint
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
libfprint/tests/test-fpi-ssm.c

1483 lines
54 KiB
C
Raw Normal View History

tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
/*
* FpiSsm Unit tests
* Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "fp-device.h"
#define FP_COMPONENT "SSM"
#include "drivers_api.h"
#include "test-device-fake.h"
#include "fpi-log.h"
/* Utility functions and shared data */
static FpDevice *fake_device = NULL;
typedef struct
{
volatile int ref_count;
int handler_state;
GSList *handlers_chain;
gboolean completed;
GError *error;
gboolean ssm_destroyed;
gboolean expected_last_state;
} FpiSsmTestData;
tests: Fix stack corruption in FpiSsm test Using a function with a void return value for a g_timeout_add is not a good idea after all.
2019-12-17 13:23:54 +00:00
static gboolean
fpi_ssm_test_nullify_pointer (gpointer * nullify_location)
{
*nullify_location = NULL;
return G_SOURCE_REMOVE;
}
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
static FpiSsmTestData *
fpi_ssm_test_data_new (void)
{
FpiSsmTestData *data = g_new0 (FpiSsmTestData, 1);
data->ref_count = 1;
data->handler_state = -1;
return data;
}
static FpiSsmTestData *
fpi_ssm_test_data_ref (FpiSsmTestData *data)
{
g_atomic_int_inc (&data->ref_count);
return data;
}
static void
fpi_ssm_test_data_unref (FpiSsmTestData *data)
{
if (g_atomic_int_dec_and_test (&data->ref_count))
{
g_clear_error (&data->error);
g_slist_free (data->handlers_chain);
g_free (data);
}
}
G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpiSsmTestData, fpi_ssm_test_data_unref)
static void
fpi_ssm_test_data_unref_by_ssm (FpiSsmTestData *data)
{
data->ssm_destroyed = TRUE;
fpi_ssm_test_data_unref (data);
}
enum {
FPI_TEST_SSM_STATE_0,
FPI_TEST_SSM_STATE_1,
FPI_TEST_SSM_STATE_2,
FPI_TEST_SSM_STATE_3,
FPI_TEST_SSM_STATE_NUM
};
static void
test_ssm_handler (FpiSsm *ssm,
FpDevice *dev)
{
FpiSsmTestData *data;
g_assert (dev == fake_device);
g_assert_true (FP_IS_DEVICE (dev));
data = fpi_ssm_get_data (ssm);
data->handler_state = fpi_ssm_get_cur_state (ssm);
data->handlers_chain = g_slist_append (data->handlers_chain,
GINT_TO_POINTER (fpi_ssm_get_cur_state (ssm)));
}
static void
test_ssm_completed_callback (FpiSsm *ssm,
FpDevice *dev,
GError *error)
{
FpiSsmTestData *data;
g_assert (dev == fake_device);
g_assert_true (FP_IS_DEVICE (dev));
data = fpi_ssm_get_data (ssm);
data->completed = TRUE;
data->handlers_chain = g_slist_append (data->handlers_chain,
GINT_TO_POINTER (fpi_ssm_get_cur_state (ssm)));
g_clear_error (&data->error);
data->error = error;
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, data->expected_last_state);
}
static FpiSsm *
ssm: Add cleanup state feature In some situations one may want to guarantee that the last steps of an SSM are run even when the SSM is completed early or failed. This can easily be done by making fpi_ssm_mark_completed jump to the next cleanup stage when called (this also includes mark_failed). Due to the mechanism, it is still possible to explicitly jump cleanup states by using fpi_ssm_jump_to_state, including a jump to the final state in order to skip all cleanup states.
2021-04-23 11:08:49 +00:00
ssm_test_new_full (int nr_states, int cleanup_state, const char *name)
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
{
FpiSsm *ssm;
FpiSsmTestData *data;
ssm: Add cleanup state feature In some situations one may want to guarantee that the last steps of an SSM are run even when the SSM is completed early or failed. This can easily be done by making fpi_ssm_mark_completed jump to the next cleanup stage when called (this also includes mark_failed). Due to the mechanism, it is still possible to explicitly jump cleanup states by using fpi_ssm_jump_to_state, including a jump to the final state in order to skip all cleanup states.
2021-04-23 11:08:49 +00:00
ssm = fpi_ssm_new_full (fake_device, test_ssm_handler, nr_states, cleanup_state, name);
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
data = fpi_ssm_test_data_new ();
data->expected_last_state = nr_states;
fpi_ssm_set_data (ssm, data, (GDestroyNotify) fpi_ssm_test_data_unref_by_ssm);
return ssm;
}
static FpiSsm *
ssm_test_new (void)
{
ssm: Add cleanup state feature In some situations one may want to guarantee that the last steps of an SSM are run even when the SSM is completed early or failed. This can easily be done by making fpi_ssm_mark_completed jump to the next cleanup stage when called (this also includes mark_failed). Due to the mechanism, it is still possible to explicitly jump cleanup states by using fpi_ssm_jump_to_state, including a jump to the final state in order to skip all cleanup states.
2021-04-23 11:08:49 +00:00
return ssm_test_new_full (FPI_TEST_SSM_STATE_NUM, FPI_TEST_SSM_STATE_NUM, "FPI_TEST_SSM");
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
}
static gboolean
test_ssm_cancel_delayed_action_delayed (gpointer data)
{
FpiSsm *ssm = data;
fpi_ssm_cancel_delayed_state_change (ssm);
return G_SOURCE_REMOVE;
}
static gboolean
test_ssm_cancel_cancellable_delayed (gpointer data)
{
g_cancellable_cancel (G_CANCELLABLE (data));
return G_SOURCE_REMOVE;
}
/* Tests */
static void
test_ssm_new (void)
{
FpiSsm *ssm;
ssm = fpi_ssm_new (fake_device, test_ssm_handler, FPI_TEST_SSM_STATE_NUM);
g_assert_null (fpi_ssm_get_data (ssm));
g_assert_no_error (fpi_ssm_get_error (ssm));
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
fpi_ssm_free (ssm);
}
static void
test_ssm_new_full (void)
{
FpiSsm *ssm;
ssm = fpi_ssm_new_full (fake_device, test_ssm_handler,
ssm: Add cleanup state feature In some situations one may want to guarantee that the last steps of an SSM are run even when the SSM is completed early or failed. This can easily be done by making fpi_ssm_mark_completed jump to the next cleanup stage when called (this also includes mark_failed). Due to the mechanism, it is still possible to explicitly jump cleanup states by using fpi_ssm_jump_to_state, including a jump to the final state in order to skip all cleanup states.
2021-04-23 11:08:49 +00:00
FPI_TEST_SSM_STATE_NUM, FPI_TEST_SSM_STATE_NUM,
"Test SSM Name");
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
g_assert_null (fpi_ssm_get_data (ssm));
g_assert_no_error (fpi_ssm_get_error (ssm));
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
fpi_ssm_free (ssm);
}
static void
test_ssm_new_no_handler (void)
{
tests: Add unused annotation The variables exist for memory management but are unused otherwise. Tag them as such.
2020-05-04 12:57:47 +00:00
G_GNUC_UNUSED g_autoptr(FpiSsm) ssm = NULL;
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*BUG:*handler*");
ssm = fpi_ssm_new (fake_device, NULL, FPI_TEST_SSM_STATE_NUM);
g_test_assert_expected_messages ();
}
static void
test_ssm_new_wrong_states (void)
{
tests: Add unused annotation The variables exist for memory management but are unused otherwise. Tag them as such.
2020-05-04 12:57:47 +00:00
G_GNUC_UNUSED g_autoptr(FpiSsm) ssm = NULL;
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*BUG:*nr_states*");
ssm: Add cleanup state feature In some situations one may want to guarantee that the last steps of an SSM are run even when the SSM is completed early or failed. This can easily be done by making fpi_ssm_mark_completed jump to the next cleanup stage when called (this also includes mark_failed). Due to the mechanism, it is still possible to explicitly jump cleanup states by using fpi_ssm_jump_to_state, including a jump to the final state in order to skip all cleanup states.
2021-04-23 11:08:49 +00:00
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*BUG:*start_cleanup*");
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
ssm = fpi_ssm_new (fake_device, test_ssm_handler, -1);
g_test_assert_expected_messages ();
}
static void
test_ssm_set_data (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
GObject *object = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
g_object_add_weak_pointer (object, (gpointer) & object);
fpi_ssm_set_data (ssm, object, g_object_unref);
g_assert (fpi_ssm_get_data (ssm) == object);
fpi_ssm_set_data (ssm, (gpointer) 0xdeadbeef, NULL);
g_assert (fpi_ssm_get_data (ssm) == (gpointer) 0xdeadbeef);
g_assert_null (object);
}
static void
test_ssm_set_data_cleanup (void)
{
FpiSsm *ssm = ssm_test_new ();
GObject *object = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
g_object_add_weak_pointer (object, (gpointer) & object);
fpi_ssm_set_data (ssm, object, g_object_unref);
g_assert (fpi_ssm_get_data (ssm) == object);
fpi_ssm_free (ssm);
g_assert_null (object);
}
static void
test_ssm_start (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
g_assert_null (data->handlers_chain);
fpi_ssm_start (ssm, NULL);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_assert_no_error (data->error);
g_assert_false (data->ssm_destroyed);
}
static void
test_ssm_start_single (void)
{
g_autoptr(FpiSsmTestData) data = NULL;
FpiSsm *ssm;
ssm: Add cleanup state feature In some situations one may want to guarantee that the last steps of an SSM are run even when the SSM is completed early or failed. This can easily be done by making fpi_ssm_mark_completed jump to the next cleanup stage when called (this also includes mark_failed). Due to the mechanism, it is still possible to explicitly jump cleanup states by using fpi_ssm_jump_to_state, including a jump to the final state in order to skip all cleanup states.
2021-04-23 11:08:49 +00:00
ssm = ssm_test_new_full (1, 1, "FPI_TEST_SSM_SINGLE_STATE");
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, 0);
g_assert_cmpint (data->handler_state, ==, 0);
fpi_ssm_next_state (ssm);
g_assert_cmpint (data->handler_state, ==, 0);
g_assert_true (data->completed);
g_assert_no_error (data->error);
g_assert_true (data->ssm_destroyed);
}
static void
test_ssm_next (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_next_state (ssm);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_next_not_started (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
fpi_ssm_next_state (ssm);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_next_with_delayed (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
gpointer timeout_tracker = GUINT_TO_POINTER (TRUE);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_next_state_delayed (ssm, 10, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*timeout*");
fpi_ssm_next_state (ssm);
g_test_assert_expected_messages ();
tests: Fix stack corruption in FpiSsm test Using a function with a void return value for a g_timeout_add is not a good idea after all.
2019-12-17 13:23:54 +00:00
g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
while (timeout_tracker)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_next_complete (void)
{
FpiSsm *ssm = ssm_test_new ();
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_next_state (ssm);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
fpi_ssm_next_state (ssm);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 3);
fpi_ssm_next_state (ssm);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 4);
fpi_ssm_next_state (ssm);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 5);
g_assert_true (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_jump_to_state (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_jump_to_state (ssm, FPI_TEST_SSM_STATE_2);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
fpi_ssm_jump_to_state (ssm, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 3);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_jump_to_state_not_started (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
fpi_ssm_jump_to_state (ssm, FPI_TEST_SSM_STATE_2);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_jump_to_state_with_delayed (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
gpointer timeout_tracker = GUINT_TO_POINTER (TRUE);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_jump_to_state_delayed (ssm, FPI_TEST_SSM_STATE_2, 10, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*timeout*");
fpi_ssm_jump_to_state (ssm, FPI_TEST_SSM_STATE_2);
g_test_assert_expected_messages ();
tests: Fix stack corruption in FpiSsm test Using a function with a void return value for a g_timeout_add is not a good idea after all.
2019-12-17 13:23:54 +00:00
g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
while (timeout_tracker)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_jump_to_state_last (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_jump_to_state (ssm, FPI_TEST_SSM_STATE_3);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_jump_to_state_wrong (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*nr_states*");
fpi_ssm_jump_to_state (ssm, FPI_TEST_SSM_STATE_NUM + 10);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_NUM + 10);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_NUM + 10);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*state*");
fpi_ssm_jump_to_state (ssm, FPI_TEST_SSM_STATE_0 - 10);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0 - 10);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0 - 10);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 3);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_mark_completed (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
data->expected_last_state = FPI_TEST_SSM_STATE_0;
fpi_ssm_mark_completed (g_steal_pointer (&ssm));
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_true (data->completed);
g_assert_no_error (data->error);
g_assert_true (data->ssm_destroyed);
}
static void
test_ssm_mark_completed_not_started (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
fpi_ssm_mark_completed (g_steal_pointer (&ssm));
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, -1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 0);
g_assert_true (data->ssm_destroyed);
}
static void
test_ssm_mark_completed_with_delayed (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
gpointer timeout_tracker = GUINT_TO_POINTER (TRUE);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
data->expected_last_state = FPI_TEST_SSM_STATE_0;
fpi_ssm_mark_completed_delayed (ssm, 10, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*timeout*");
fpi_ssm_mark_completed (g_steal_pointer (&ssm));
g_test_assert_expected_messages ();
tests: Fix stack corruption in FpiSsm test Using a function with a void return value for a g_timeout_add is not a good idea after all.
2019-12-17 13:23:54 +00:00
g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
while (timeout_tracker)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_true (data->ssm_destroyed);
}
static void
test_ssm_mark_failed (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
data->expected_last_state = FPI_TEST_SSM_STATE_0;
fpi_ssm_mark_failed (g_steal_pointer (&ssm),
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_true (data->completed);
g_assert_error (data->error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_PROTO);
g_assert_true (data->ssm_destroyed);
}
static void
test_ssm_mark_failed_not_started (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
fpi_ssm_mark_failed (g_steal_pointer (&ssm),
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, -1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 0);
g_assert_true (data->ssm_destroyed);
}
static void
test_ssm_mark_failed_with_delayed (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
gpointer timeout_tracker = GUINT_TO_POINTER (TRUE);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_mark_completed_delayed (ssm, 10, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*timeout*");
data->expected_last_state = FPI_TEST_SSM_STATE_0;
fpi_ssm_mark_failed (g_steal_pointer (&ssm),
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
g_test_assert_expected_messages ();
tests: Fix stack corruption in FpiSsm test Using a function with a void return value for a g_timeout_add is not a good idea after all.
2019-12-17 13:23:54 +00:00
g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
while (timeout_tracker)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_true (data->completed);
g_assert_error (data->error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_PROTO);
g_assert_true (data->ssm_destroyed);
}
static void
test_ssm_delayed_next (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_next_state_delayed (ssm, 10, NULL);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
while (data->handler_state == FPI_TEST_SSM_STATE_0)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_delayed_next_cancel (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
gpointer timeout_tracker = GUINT_TO_POINTER (TRUE);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_next_state_delayed (ssm, 10, NULL);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_idle_add_full (G_PRIORITY_HIGH, test_ssm_cancel_delayed_action_delayed, ssm, NULL);
tests: Fix stack corruption in FpiSsm test Using a function with a void return value for a g_timeout_add is not a good idea after all.
2019-12-17 13:23:54 +00:00
g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
while (timeout_tracker)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_delayed_next_cancellable (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(GCancellable) cancellable = g_cancellable_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_next_state_delayed (ssm, 10, cancellable);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_idle_add_full (G_PRIORITY_HIGH, test_ssm_cancel_cancellable_delayed, cancellable, NULL);
while (!g_cancellable_is_cancelled (cancellable))
g_main_context_iteration (NULL, TRUE);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*timeout*");
fpi_ssm_cancel_delayed_state_change (ssm);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_delayed_next_not_started (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
fpi_ssm_next_state_delayed (ssm, 10, NULL);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, -1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 0);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
while (data->handler_state == -1)
g_main_context_iteration (NULL, TRUE);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_delayed_next_complete (void)
{
FpiSsm *ssm = ssm_test_new ();
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_next_state_delayed (ssm, 10, NULL);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
while (data->handler_state == FPI_TEST_SSM_STATE_0)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
fpi_ssm_next_state_delayed (ssm, 10, NULL);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
while (data->handler_state == FPI_TEST_SSM_STATE_1)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 3);
fpi_ssm_next_state_delayed (ssm, 10, NULL);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 3);
while (data->handler_state == FPI_TEST_SSM_STATE_2)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 4);
fpi_ssm_next_state_delayed (ssm, 10, NULL);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 4);
while (!data->completed)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 5);
g_assert_true (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_delayed_jump_to_state (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_jump_to_state_delayed (ssm, FPI_TEST_SSM_STATE_2, 10, NULL);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
while (data->handler_state == FPI_TEST_SSM_STATE_0)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
fpi_ssm_jump_to_state_delayed (ssm, FPI_TEST_SSM_STATE_1, 10, NULL);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
while (data->handler_state == FPI_TEST_SSM_STATE_2)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 3);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_delayed_jump_to_state_cancel (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
gpointer timeout_tracker = GUINT_TO_POINTER (TRUE);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_jump_to_state_delayed (ssm, FPI_TEST_SSM_STATE_2, 10, NULL);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_idle_add_full (G_PRIORITY_HIGH, test_ssm_cancel_delayed_action_delayed, ssm, NULL);
tests: Fix stack corruption in FpiSsm test Using a function with a void return value for a g_timeout_add is not a good idea after all.
2019-12-17 13:23:54 +00:00
g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
while (timeout_tracker)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_delayed_jump_to_state_cancellable (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(GCancellable) cancellable = g_cancellable_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_jump_to_state_delayed (ssm, FPI_TEST_SSM_STATE_2, 10, cancellable);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_idle_add_full (G_PRIORITY_HIGH, test_ssm_cancel_cancellable_delayed, cancellable, NULL);
while (!g_cancellable_is_cancelled (cancellable))
g_main_context_iteration (NULL, TRUE);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*timeout*");
fpi_ssm_cancel_delayed_state_change (ssm);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_delayed_jump_to_state_not_started (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
fpi_ssm_jump_to_state_delayed (ssm, FPI_TEST_SSM_STATE_2, 10, NULL);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, -1);
g_assert_null (data->handlers_chain);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
while (data->handler_state == -1)
g_main_context_iteration (NULL, TRUE);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_delayed_jump_to_state_last (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_jump_to_state_delayed (ssm, FPI_TEST_SSM_STATE_3, 10, NULL);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
while (data->handler_state == FPI_TEST_SSM_STATE_0)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_delayed_jump_to_state_wrong (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*nr_states*");
fpi_ssm_jump_to_state_delayed (ssm, FPI_TEST_SSM_STATE_NUM + 10, 10, NULL);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*nr_states*");
while (g_slist_length (data->handlers_chain) == 1)
g_main_context_iteration (NULL, TRUE);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_NUM + 10);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_NUM + 10);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*state*");
fpi_ssm_jump_to_state_delayed (ssm, FPI_TEST_SSM_STATE_0 - 10, 10, NULL);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_NUM + 10);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_NUM + 10);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*state*");
while (g_slist_length (data->handlers_chain) == 2)
g_main_context_iteration (NULL, TRUE);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0 - 10);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0 - 10);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 3);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_delayed_mark_completed (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
data->expected_last_state = FPI_TEST_SSM_STATE_0;
fpi_ssm_mark_completed_delayed (g_steal_pointer (&ssm), 10, NULL);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
while (g_slist_length (data->handlers_chain) == 1)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_true (data->completed);
g_assert_no_error (data->error);
g_assert_true (data->ssm_destroyed);
}
static void
test_ssm_delayed_mark_completed_not_started (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
fpi_ssm_mark_completed_delayed (ssm, 10, NULL);
g_test_assert_expected_messages ();
tests: Fix stack corruption in FpiSsm test Using a function with a void return value for a g_timeout_add is not a good idea after all.
2019-12-17 13:23:54 +00:00
g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &ssm);
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
while (ssm != NULL)
g_main_context_iteration (NULL, TRUE);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, -1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 0);
g_assert_true (data->ssm_destroyed);
}
static void
test_ssm_delayed_mark_completed_cancel (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
gpointer timeout_tracker = GUINT_TO_POINTER (TRUE);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_mark_completed_delayed (ssm, 10, NULL);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_idle_add_full (G_PRIORITY_HIGH, test_ssm_cancel_delayed_action_delayed, ssm, NULL);
tests: Fix stack corruption in FpiSsm test Using a function with a void return value for a g_timeout_add is not a good idea after all.
2019-12-17 13:23:54 +00:00
g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
while (timeout_tracker)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_assert_false (data->completed);
g_assert_no_error (data->error);
g_assert_false (data->ssm_destroyed);
}
static void
test_ssm_delayed_mark_completed_cancellable (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(GCancellable) cancellable = g_cancellable_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_mark_completed_delayed (ssm, 10, cancellable);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_idle_add_full (G_PRIORITY_HIGH, test_ssm_cancel_cancellable_delayed, cancellable, NULL);
while (!g_cancellable_is_cancelled (cancellable))
g_main_context_iteration (NULL, TRUE);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*timeout*");
fpi_ssm_cancel_delayed_state_change (ssm);
g_test_assert_expected_messages ();
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_assert_false (data->completed);
g_assert_no_error (data->error);
}
static void
test_ssm_delayed_cancel_error (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*timeout*");
fpi_ssm_cancel_delayed_state_change (ssm);
g_test_assert_expected_messages ();
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*timeout*");
fpi_ssm_cancel_delayed_state_change (ssm);
g_test_assert_expected_messages ();
}
static void
test_ssm_subssm_start (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsm) subssm =
ssm: Add cleanup state feature In some situations one may want to guarantee that the last steps of an SSM are run even when the SSM is completed early or failed. This can easily be done by making fpi_ssm_mark_completed jump to the next cleanup stage when called (this also includes mark_failed). Due to the mechanism, it is still possible to explicitly jump cleanup states by using fpi_ssm_jump_to_state, including a jump to the final state in order to skip all cleanup states.
2021-04-23 11:08:49 +00:00
ssm_test_new_full (FPI_TEST_SSM_STATE_NUM, FPI_TEST_SSM_STATE_NUM, "FPI_TEST_SUB_SSM");
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
Uncrustify with newer version
2020-06-02 11:55:19 +00:00
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
g_autoptr(FpiSsmTestData) subdata =
fpi_ssm_test_data_ref (fpi_ssm_get_data (subssm));
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_start_subsm (ssm, subssm);
g_assert_cmpint (subdata->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (subssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (subdata->handlers_chain), ==, 1);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_next_state (subssm);
g_assert_cmpint (subdata->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (subdata->handlers_chain), ==, 2);
g_assert_no_error (subdata->error);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
subdata->expected_last_state = FPI_TEST_SSM_STATE_1;
fpi_ssm_mark_completed (g_steal_pointer (&subssm));
g_assert_cmpint (subdata->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (subdata->handlers_chain), ==, 2);
g_assert_true (subdata->ssm_destroyed);
g_assert_no_error (subdata->error);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_false (data->completed);
g_assert_false (data->ssm_destroyed);
g_assert_no_error (data->error);
}
static void
test_ssm_subssm_mark_failed (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsm) subssm =
ssm: Add cleanup state feature In some situations one may want to guarantee that the last steps of an SSM are run even when the SSM is completed early or failed. This can easily be done by making fpi_ssm_mark_completed jump to the next cleanup stage when called (this also includes mark_failed). Due to the mechanism, it is still possible to explicitly jump cleanup states by using fpi_ssm_jump_to_state, including a jump to the final state in order to skip all cleanup states.
2021-04-23 11:08:49 +00:00
ssm_test_new_full (FPI_TEST_SSM_STATE_NUM, FPI_TEST_SSM_STATE_NUM, "FPI_TEST_SUB_SSM");
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
g_autoptr(FpiSsmTestData) data =
fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
g_autoptr(FpiSsmTestData) subdata =
fpi_ssm_test_data_ref (fpi_ssm_get_data (subssm));
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_start_subsm (g_steal_pointer (&ssm), subssm);
g_assert_cmpint (subdata->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (subssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (subdata->handlers_chain), ==, 1);
data->expected_last_state = FPI_TEST_SSM_STATE_0;
subdata->expected_last_state = FPI_TEST_SSM_STATE_0;
fpi_ssm_mark_failed (g_steal_pointer (&subssm),
fpi_device_error_new (FP_DEVICE_ERROR_BUSY));
g_assert_cmpint (subdata->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (subdata->handlers_chain), ==, 1);
g_assert_true (subdata->ssm_destroyed);
g_assert_no_error (subdata->error);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_true (data->completed);
g_assert_true (data->ssm_destroyed);
g_assert_error (data->error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_BUSY);
}
static void
test_ssm_subssm_start_with_started (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsm) subssm =
ssm: Add cleanup state feature In some situations one may want to guarantee that the last steps of an SSM are run even when the SSM is completed early or failed. This can easily be done by making fpi_ssm_mark_completed jump to the next cleanup stage when called (this also includes mark_failed). Due to the mechanism, it is still possible to explicitly jump cleanup states by using fpi_ssm_jump_to_state, including a jump to the final state in order to skip all cleanup states.
2021-04-23 11:08:49 +00:00
ssm_test_new_full (FPI_TEST_SSM_STATE_NUM, FPI_TEST_SSM_STATE_NUM, "FPI_TEST_SUB_SSM");
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
Uncrustify with newer version
2020-06-02 11:55:19 +00:00
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
g_autoptr(FpiSsmTestData) subdata =
fpi_ssm_test_data_ref (fpi_ssm_get_data (subssm));
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_start (subssm, test_ssm_completed_callback);
g_assert_cmpuint (g_slist_length (subdata->handlers_chain), ==, 1);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*completed*");
fpi_ssm_start_subsm (ssm, subssm);
g_test_assert_expected_messages ();
g_assert_cmpint (subdata->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (subssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (subdata->handlers_chain), ==, 2);
subdata->expected_last_state = FPI_TEST_SSM_STATE_0;
fpi_ssm_mark_completed (g_steal_pointer (&subssm));
g_assert_cmpint (subdata->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (subdata->handlers_chain), ==, 2);
g_assert_true (subdata->ssm_destroyed);
g_assert_no_error (subdata->error);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_false (data->completed);
g_assert_false (data->ssm_destroyed);
g_assert_no_error (data->error);
}
static void
test_ssm_subssm_start_with_delayed (void)
{
g_autoptr(FpiSsm) ssm = ssm_test_new ();
g_autoptr(FpiSsm) subssm =
ssm: Add cleanup state feature In some situations one may want to guarantee that the last steps of an SSM are run even when the SSM is completed early or failed. This can easily be done by making fpi_ssm_mark_completed jump to the next cleanup stage when called (this also includes mark_failed). Due to the mechanism, it is still possible to explicitly jump cleanup states by using fpi_ssm_jump_to_state, including a jump to the final state in order to skip all cleanup states.
2021-04-23 11:08:49 +00:00
ssm_test_new_full (FPI_TEST_SSM_STATE_NUM, FPI_TEST_SSM_STATE_NUM, "FPI_TEST_SUB_SSM");
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
FpiSsmTestData *data = fpi_ssm_get_data (ssm);
Uncrustify with newer version
2020-06-02 11:55:19 +00:00
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
g_autoptr(FpiSsmTestData) subdata =
fpi_ssm_test_data_ref (fpi_ssm_get_data (subssm));
gpointer timeout_tracker = GUINT_TO_POINTER (TRUE);
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
fpi_ssm_next_state_delayed (ssm, 10, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*BUG:*timeout*");
fpi_ssm_start_subsm (ssm, subssm);
g_test_assert_expected_messages ();
tests: Fix stack corruption in FpiSsm test Using a function with a void return value for a g_timeout_add is not a good idea after all.
2019-12-17 13:23:54 +00:00
g_timeout_add (100, G_SOURCE_FUNC (fpi_ssm_test_nullify_pointer), &timeout_tracker);
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
while (timeout_tracker)
g_main_context_iteration (NULL, TRUE);
g_assert_cmpint (subdata->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpint (fpi_ssm_get_cur_state (subssm), ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (subdata->handlers_chain), ==, 1);
subdata->expected_last_state = FPI_TEST_SSM_STATE_0;
fpi_ssm_mark_completed (g_steal_pointer (&subssm));
g_assert_cmpint (subdata->handler_state, ==, FPI_TEST_SSM_STATE_0);
g_assert_cmpuint (g_slist_length (subdata->handlers_chain), ==, 1);
g_assert_true (subdata->ssm_destroyed);
g_assert_no_error (subdata->error);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpint (fpi_ssm_get_cur_state (ssm), ==, FPI_TEST_SSM_STATE_1);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_false (data->completed);
g_assert_false (data->ssm_destroyed);
g_assert_no_error (data->error);
}
ssm: Add cleanup state feature In some situations one may want to guarantee that the last steps of an SSM are run even when the SSM is completed early or failed. This can easily be done by making fpi_ssm_mark_completed jump to the next cleanup stage when called (this also includes mark_failed). Due to the mechanism, it is still possible to explicitly jump cleanup states by using fpi_ssm_jump_to_state, including a jump to the final state in order to skip all cleanup states.
2021-04-23 11:08:49 +00:00
static void
test_ssm_cleanup_complete (void)
{
FpiSsm *ssm = ssm_test_new_full (4, FPI_TEST_SSM_STATE_2, "FPI_TEST_SSM");
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
data->expected_last_state = FPI_TEST_SSM_STATE_3;
/* Completing jumps to the cleanup state */
fpi_ssm_mark_completed (ssm);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_false (data->completed);
g_assert_false (data->ssm_destroyed);
/* Completing again jumps to the next cleanup state */
fpi_ssm_mark_completed (ssm);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 3);
g_assert_false (data->completed);
g_assert_false (data->ssm_destroyed);
/* Completing again finalizes everything */
fpi_ssm_mark_completed (ssm);
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 4);
g_assert_true (data->completed);
g_assert_no_error (data->error);
g_assert_true (data->ssm_destroyed);
}
static void
test_ssm_cleanup_fail (void)
{
FpiSsm *ssm = ssm_test_new_full (4, FPI_TEST_SSM_STATE_2, "FPI_TEST_SSM");
g_autoptr(FpiSsmTestData) data = fpi_ssm_test_data_ref (fpi_ssm_get_data (ssm));
fpi_ssm_start (ssm, test_ssm_completed_callback);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 1);
data->expected_last_state = FPI_TEST_SSM_STATE_3;
/* Failing jumps to the cleanup state */
fpi_ssm_mark_failed (ssm, g_error_new (G_IO_ERROR, G_IO_ERROR_CANCELLED, "non-cleanup"));
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_2);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 2);
g_assert_false (data->completed);
g_assert_false (data->ssm_destroyed);
/* Failing again jumps to the next cleanup state */
fpi_ssm_mark_failed (ssm, g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED, "cleanup 1"));
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 3);
g_assert_false (data->completed);
g_assert_false (data->ssm_destroyed);
/* Failing again finalizes everything */
fpi_ssm_mark_failed (ssm, g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED, "cleanup 2"));
g_assert_cmpint (data->handler_state, ==, FPI_TEST_SSM_STATE_3);
g_assert_cmpuint (g_slist_length (data->handlers_chain), ==, 4);
g_assert_true (data->completed);
g_assert_error (data->error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
g_assert_true (data->ssm_destroyed);
}
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
int
main (int argc, char *argv[])
{
g_autoptr(FpDevice) device = NULL;
g_test_init (&argc, &argv, NULL);
device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
fake_device = device;
g_object_add_weak_pointer (G_OBJECT (device), (gpointer) & fake_device);
g_test_add_func ("/ssm/new", test_ssm_new);
g_test_add_func ("/ssm/new/full", test_ssm_new_full);
g_test_add_func ("/ssm/new/no_handler", test_ssm_new_no_handler);
g_test_add_func ("/ssm/new/wrong_states", test_ssm_new_wrong_states);
g_test_add_func ("/ssm/set_data", test_ssm_set_data);
g_test_add_func ("/ssm/set_data/cleanup", test_ssm_set_data_cleanup);
g_test_add_func ("/ssm/start", test_ssm_start);
g_test_add_func ("/ssm/start/single", test_ssm_start_single);
g_test_add_func ("/ssm/next", test_ssm_next);
g_test_add_func ("/ssm/next/complete", test_ssm_next_complete);
g_test_add_func ("/ssm/next/not_started", test_ssm_next_not_started);
g_test_add_func ("/ssm/next/with_delayed", test_ssm_next_with_delayed);
g_test_add_func ("/ssm/jump_to_state", test_ssm_jump_to_state);
g_test_add_func ("/ssm/jump_to_state/not_started", test_ssm_jump_to_state_not_started);
g_test_add_func ("/ssm/jump_to_state/with_delayed", test_ssm_jump_to_state_with_delayed);
g_test_add_func ("/ssm/jump_to_state/last", test_ssm_jump_to_state_last);
g_test_add_func ("/ssm/jump_to_state/wrong", test_ssm_jump_to_state_wrong);
g_test_add_func ("/ssm/mark_completed", test_ssm_mark_completed);
g_test_add_func ("/ssm/mark_completed/not_started", test_ssm_mark_completed_not_started);
g_test_add_func ("/ssm/mark_completed/with_delayed", test_ssm_mark_completed_with_delayed);
g_test_add_func ("/ssm/mark_failed", test_ssm_mark_failed);
g_test_add_func ("/ssm/mark_failed/not_started", test_ssm_mark_failed_not_started);
g_test_add_func ("/ssm/mark_failed/with_delayed", test_ssm_mark_failed_with_delayed);
g_test_add_func ("/ssm/delayed/next", test_ssm_delayed_next);
g_test_add_func ("/ssm/delayed/next/cancel", test_ssm_delayed_next_cancel);
g_test_add_func ("/ssm/delayed/next/cancellable", test_ssm_delayed_next_cancellable);
g_test_add_func ("/ssm/delayed/next/not_started", test_ssm_delayed_next_not_started);
g_test_add_func ("/ssm/delayed/next/complete", test_ssm_delayed_next_complete);
g_test_add_func ("/ssm/delayed/jump_to_state", test_ssm_delayed_jump_to_state);
g_test_add_func ("/ssm/delayed/jump_to_state/cancel", test_ssm_delayed_jump_to_state_cancel);
g_test_add_func ("/ssm/delayed/jump_to_state/cancellable", test_ssm_delayed_jump_to_state_cancellable);
g_test_add_func ("/ssm/delayed/jump_to_state/not_started", test_ssm_delayed_jump_to_state_not_started);
g_test_add_func ("/ssm/delayed/jump_to_state/last", test_ssm_delayed_jump_to_state_last);
g_test_add_func ("/ssm/delayed/jump_to_state/wrong", test_ssm_delayed_jump_to_state_wrong);
g_test_add_func ("/ssm/delayed/mark_completed", test_ssm_delayed_mark_completed);
g_test_add_func ("/ssm/delayed/mark_completed/cancel", test_ssm_delayed_mark_completed_cancel);
g_test_add_func ("/ssm/delayed/mark_completed/cancellable", test_ssm_delayed_mark_completed_cancellable);
g_test_add_func ("/ssm/delayed/mark_completed/not_started", test_ssm_delayed_mark_completed_not_started);
g_test_add_func ("/ssm/delayed/cancel/error", test_ssm_delayed_cancel_error);
g_test_add_func ("/ssm/subssm/start", test_ssm_subssm_start);
g_test_add_func ("/ssm/subssm/start/with_started", test_ssm_subssm_start_with_started);
g_test_add_func ("/ssm/subssm/start/with_delayed", test_ssm_subssm_start_with_delayed);
g_test_add_func ("/ssm/subssm/mark_failed", test_ssm_subssm_mark_failed);
ssm: Add cleanup state feature In some situations one may want to guarantee that the last steps of an SSM are run even when the SSM is completed early or failed. This can easily be done by making fpi_ssm_mark_completed jump to the next cleanup stage when called (this also includes mark_failed). Due to the mechanism, it is still possible to explicitly jump cleanup states by using fpi_ssm_jump_to_state, including a jump to the final state in order to skip all cleanup states.
2021-04-23 11:08:49 +00:00
g_test_add_func ("/ssm/cleanup/complete", test_ssm_cleanup_complete);
g_test_add_func ("/ssm/cleanup/fail", test_ssm_cleanup_fail);
tests: Add unit tests for fpi-ssm Verify that the state machine actions are done as we expected, being the main tool for drivers, better to check that is done as we expect.
2019-12-12 17:42:46 +00:00
return g_test_run ();
}
Reference in a new issue Copy permalink