Add advanced fixed-size backend tests.

Covers more scenarios specific to the backend,
and interaction between the two backends.

Change-Id: I2ae980ffa8497dffc455761d1958c94db8390d5d

diff --git a/tests/api_tests/test_api_add_remove_user.cpp b/tests/api_tests/test_api_add_remove_user.cpp
index 8fd1b87a77f0c86a8c86adea177469c4f6d25dc9..6e1a16910c3e9a622bec7042e134b24dbc44b0b3 100644 (file)
--- a/tests/api_tests/test_api_add_remove_user.cpp
+++ b/tests/api_tests/test_api_add_remove_user.cpp
@@ -9,7 +9,7 @@
 #include "test_hlp.hpp"
 
 
-const int  action_items = 8;
+const int  action_items = 20;
 
 TEST(subsession_add_remove_user_test, APIAddRemoveUserTest) {
 
@@ -67,6 +67,84 @@ TEST(subsession_add_remove_user_test, APIAddRemoveUserTest) {
                                                        .desc = "Check if remove " + std::string(TestUserStr::user_3) + " is successful (fixed-size backend)",
                                                        .cb_expected = SUBSESSION_ERROR_NONE,
                                                        .cb_desc = "Check if remove " + std::string(TestUserStr::user_3) + " callback is successful (fixed-size backend)", },
+
+                       // Reuse same name, fixed-size backend, same size
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_3, 25*1024)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_3) + " is successful (reused name, fixed-size backend, 25 MB)",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_3) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_3)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if remove " + std::string(TestUserStr::user_3) + " is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if remove " + std::string(TestUserStr::user_3) + " callback is successful", },
+
+                       // Reuse same name, fixed-size backend, different size
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_3, 10*1024)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_3) + " is successful (reused name, fixed-size backend, different size 10 MB)",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_3) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_3)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if remove " + std::string(TestUserStr::user_3) + " is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if remove " + std::string(TestUserStr::user_3) + " callback is successful", },
+
+                       // Both backends reusing the same name alternatingly
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_5, 10*1024)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_5) + " is successful (fixed-size backend, 10 MB)",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_5) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_5)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if remove " + std::string(TestUserStr::user_5) + " is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if remove " + std::string(TestUserStr::user_5) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestUserStr::user_5)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_5) + " is successful (reused name, regular dir backend)",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_5) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_5)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if remove " + std::string(TestUserStr::user_5) + " is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if remove " + std::string(TestUserStr::user_5) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_5, 25*1024)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_5) + " is successful (reused again, fixed-size backend, 25 MB)",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_5) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_5)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if remove " + std::string(TestUserStr::user_5) + " is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if remove " + std::string(TestUserStr::user_5) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestUserStr::user_5)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_5) + " is successful (reused again, regular dir backend)",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_5) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_5)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if remove " + std::string(TestUserStr::user_5) + " is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if remove " + std::string(TestUserStr::user_5) + " callback is successful", },
                }
        };
 

diff --git a/tests/api_tests/test_api_add_remove_user_err.cpp b/tests/api_tests/test_api_add_remove_user_err.cpp
index ca05c86859b0c5d8bf1f8b95c93f33a82bc714fd..0f627791ebc302a05cf28a9a76c939226a2c0a46 100644 (file)
--- a/tests/api_tests/test_api_add_remove_user_err.cpp
+++ b/tests/api_tests/test_api_add_remove_user_err.cpp
@@ -9,7 +9,7 @@
 #include "test_hlp.hpp"
 
 
-const int  action_items = 26;
+const int  action_items = 40;
 
 TEST(subsession_add_remove_test, FailAtAddRemoveUser) {
        using ud_t = ud_data_t<std::array<api_call_res_t, action_items>>;
@@ -178,6 +178,118 @@ TEST(subsession_add_remove_test, FailAtAddRemoveUser) {
                                                        .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
                                                        .cb_desc = "Check if remove [ " + std::string(TestBadUserStr::bad_user_20) + " ] callback returns error (fixed-size backend)", },
 
+                       // Trying to add regular-dir subsession when fixed-size already exists under that name
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_3, 25*1024)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_3) + " is successful (fixed-size backend, 25 MB)",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_3) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestUserStr::user_3)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_3) + " (regular dir backend) successfully sends request",
+                                                       .cb_expected = SUBSESSION_ERROR_ALREADY_EXISTS,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_3) + " callback returns error ERROR_ALREADY_EXISTS", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_3)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if remove " + std::string(TestUserStr::user_3) + " is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if remove " + std::string(TestUserStr::user_3) + " callback is successful", },
+
+                       // Trying to add fixed-size subsession when regular-dir already exists
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestUserStr::user_4)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_4) + " is successful (regular dir backend)",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_4) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_4, 25*1024)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_4) + " (fixed-size backend, 25 MB) successfully sends request returns ERROR_ALREADY_EXISTS",
+                                                       .cb_expected = SUBSESSION_ERROR_ALREADY_EXISTS,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_4) + " callback returns ERROR_ALREADY_EXISTS", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_4)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if remove " + std::string(TestUserStr::user_4) + " is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if remove " + std::string(TestUserStr::user_4) + " callback is successful", },
+
+                       // Trying to add fixed-size subsession when fixed-size already exists
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_5, 25*1024)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_5) + " is successful (fixed-size backend, 25 MB)",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_5) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_5, 25*1024)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_5) + " (fixed-size backend, 25 MB) successfully sends request",
+                                                       .cb_expected = SUBSESSION_ERROR_ALREADY_EXISTS,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_5) + " callback returns ERROR_ALREADY_EXISTS", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_5, 25*1024)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_5) + " (fixed-size backend, 10 MB) successfully sends request",
+                                                       .cb_expected = SUBSESSION_ERROR_ALREADY_EXISTS,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_5) + " callback returns ERROR_ALREADY_EXISTS", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_5)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if remove " + std::string(TestUserStr::user_5) + " is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if remove " + std::string(TestUserStr::user_5) + " callback is successful", },
+
+                       // Trying to add fixed-size subsession with insufficient size for overhead
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_6, 0)),
+                                                       .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_6) + " (fixed-size backend, 0 kB) returns ERROR_INVALID_PARAMETER",
+                                                       .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_6) + " callback returns error", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_6, 200)),
+                                                       .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_6) + " (fixed-size backend, 200 kB) returns ERROR_INVALID_PARAMETER",
+                                                       .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_6) + " callback returns error", },
+
+#if 0 // don't forget action_items++ if you restore this
+
+                       /* FIXME: the "success" below is fake. We are counting on IO_ERROR caused by filesystem not being able to fit such huge image.
+                        * We indeed receive IO_ERROR but it's actually because the service is busy trying to fill the entire FS and does not respond
+                        * to calls, so we bail out on timeout which also happens to result in IO_ERROR. This is a deeper problem but hopefully, since
+                        * the action here is privileged, we can count on nobody creating absurdly huge subsessions. */
+
+                       // Trying to add fixed-size subsession which doesn't fit
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_6, 2000000000)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_6) + " (fixed-size backend, 2 TB) successfully sends request",
+                                                       .cb_expected = SUBSESSION_ERROR_IO_ERROR,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_6) + " callback returns ERROR_IO_ERROR", },
+
+
+                       /* FIXME 2: the below cannot be tested properly using the current testing framework alongside the call above, at least without
+                        * a bit of a rewrite. All calls are done immediately and then their results are just received sequentially via async callback,
+                        * while the service is single-threaded. This means that any call that runs into timeout also automatically fails all tests below it. */
+#endif
+
+                       // Make sure failed attempts don't prevent a valid subsession
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_6, 25*1024)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add  " + std::string(TestUserStr::user_6) + " is successful (fixed-size backend, 25 MB)",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if add " + std::string(TestUserStr::user_6) + " callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_6)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if remove " + std::string(TestUserStr::user_6) + " is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if remove " + std::string(TestUserStr::user_6) + " callback is successful", },
                }
        };
 

diff --git a/tests/api_tests/test_api_switch_user_completion.cpp b/tests/api_tests/test_api_switch_user_completion.cpp
index ec0a789812c9b39a7014ef412dc94828e716e1d2..68f0784a0757d1bcd78f5f8397238f94cb414def 100644 (file)
--- a/tests/api_tests/test_api_switch_user_completion.cpp
+++ b/tests/api_tests/test_api_switch_user_completion.cpp
@@ -12,7 +12,7 @@
 
 TEST(subsession_switch_user_completion, APISwitchUserCompletion) {
 
-       const int prologue_items = 4;
+       const int prologue_items = 12;
        using ud_prologue_t = ud_data_t<std::array<api_call_res_t, prologue_items>>;
        ud_prologue_t prologue = { .loop = g_main_loop_new(NULL, FALSE),
                .results = std::array<api_call_res_t, prologue_items>  {
@@ -37,18 +37,67 @@ TEST(subsession_switch_user_completion, APISwitchUserCompletion) {
                                .cb_expected = SUBSESSION_ERROR_NONE,
                                .cb_desc = "Check if add [ " + std::string(TestUserStr::user_2) + " ] callback is successful", },
 
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_3, 15*1024)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if add [ " + std::string(TestUserStr::user_3) + " ], fixed-size backend (15 MB), is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if add [ " + std::string(TestUserStr::user_3) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_4, 40*1024)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if add [ " + std::string(TestUserStr::user_4) + " ], fixed-size backend (40 MB), is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if add [ " + std::string(TestUserStr::user_4) + " ] callback is successful", },
+
+                       // Switch between them a bit
                        api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_1)),
                                .expected = SUBSESSION_ERROR_NONE,
                                .desc = "Check if switch to [ " + std::string(TestUserStr::user_1) + " ] is successful",
                                .cb_expected = SUBSESSION_ERROR_NONE,
                                .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_1) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_2)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_3)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if switch to [ " + std::string(TestUserStr::user_3) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if switch to [ " + std::string(TestUserStr::user_3) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_2)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_4)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if switch to [ " + std::string(TestUserStr::user_4) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if switch to [ " + std::string(TestUserStr::user_4) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_0)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if switch to [ " + std::string(TestUserStr::user_0) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if switch to [ " + std::string(TestUserStr::user_0) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_1)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if switch to [ " + std::string(TestUserStr::user_1) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if switch to [ " + std::string(TestUserStr::user_1) + " ] callback is successful", },
                }
        };
 
        loop_run_for_test(callback_pending<ud_prologue_t, api_call_res_t>, &prologue, prologue.loop);
        summarize<prologue_items>(prologue.results);
 
-       const int action_items = 2;
+       const int action_items = 7;
        using ud_t = ud_data_t<std::array<api_call_res_t, action_items>>;
 
        ud_t ud_data = { .loop = g_main_loop_new(NULL, FALSE),
@@ -65,6 +114,36 @@ TEST(subsession_switch_user_completion, APISwitchUserCompletion) {
                                                        .desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] is successful",
                                                        .cb_expected = SUBSESSION_ERROR_NONE,
                                                        .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_2) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_3)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_3) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_3) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_2)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_2) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_4)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_4) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_4) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_0)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_0) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_0) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_4)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_4) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_4) + " ] callback is successful", },
                }
        };
 
@@ -76,7 +155,7 @@ TEST(subsession_switch_user_completion, APISwitchUserCompletion) {
        EXPECT_EQ(res, SUBSESSION_ERROR_NONE);
 
 
-       const int epilogue_items = 3;
+       const int epilogue_items = 5;
        using ud_epilogue_t = ud_data_t<std::array<api_call_res_t, epilogue_items>>;
        ud_epilogue_t epilogue = { .loop = g_main_loop_new(NULL, FALSE),
                .results = std::array<api_call_res_t, epilogue_items>  {
@@ -98,6 +177,18 @@ TEST(subsession_switch_user_completion, APISwitchUserCompletion) {
                                .desc = "Check if remove[ " + std::string(TestUserStr::user_2) + " ] is successful",
                                .cb_expected = SUBSESSION_ERROR_NONE,
                                .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_2) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestUserStr::user_3)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if remove [ " + std::string(TestUserStr::user_3) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_3) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestUserStr::user_4)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if remove[ " + std::string(TestUserStr::user_4) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_4) + " ] callback is successful", },
                }
        };
 

diff --git a/tests/api_tests/test_api_switch_user_wait.cpp b/tests/api_tests/test_api_switch_user_wait.cpp
index 864e4c6ef0eb23dda213d605c3e3c9cdba514fb1..1007b66fb4476e4d7d0d87e4e2989492b01a3932 100644 (file)
--- a/tests/api_tests/test_api_switch_user_wait.cpp
+++ b/tests/api_tests/test_api_switch_user_wait.cpp
@@ -12,7 +12,7 @@
 
 TEST(subsession_switch_user_wait, APISwitchUserStarted) {
 
-       const int prologue_items = 4;
+       const int prologue_items = 12;
        using ud_prologue_t = ud_data_t<std::array<api_call_res_t, prologue_items>>;
        ud_prologue_t prologue = { .loop = g_main_loop_new(NULL, FALSE),
                .results = std::array<api_call_res_t, prologue_items>  {
@@ -35,18 +35,67 @@ TEST(subsession_switch_user_wait, APISwitchUserStarted) {
                                .cb_expected = SUBSESSION_ERROR_NONE,
                                .cb_desc = "Check if add [ " + std::string(TestUserStr::user_2) + " ] callback is successful", },
 
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_3, 20*1024)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if add [ " + std::string(TestUserStr::user_3) + " ] is successful (fixed-size backend, 20 MB)",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if add [ " + std::string(TestUserStr::user_3) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_4, 30*1024)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if add [ " + std::string(TestUserStr::user_4) + " ] is successful (fixed-size backend, 30 MB)",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if add [ " + std::string(TestUserStr::user_4) + " ] callback is successful", },
+
+                       // Switch between them a bit
                        api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_1)),
                                .expected = SUBSESSION_ERROR_NONE,
                                .desc = "Check if switch to [ " + std::string(TestUserStr::user_1) + " ] is successful",
                                .cb_expected = SUBSESSION_ERROR_NONE,
                                .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_1) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_2)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_3)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if switch to [ " + std::string(TestUserStr::user_3) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if switch to [ " + std::string(TestUserStr::user_3) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_2)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_4)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if switch to [ " + std::string(TestUserStr::user_4) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if switch to [ " + std::string(TestUserStr::user_4) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_0)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if switch to [ " + std::string(TestUserStr::user_0) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if switch to [ " + std::string(TestUserStr::user_0) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_1)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if switch to [ " + std::string(TestUserStr::user_1) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if switch to [ " + std::string(TestUserStr::user_1) + " ] callback is successful", },
                }
        };
 
        loop_run_for_test(callback_pending<ud_prologue_t, api_call_res_t>, &prologue, prologue.loop);
        summarize<prologue_items>(prologue.results);
 
-       const int action_items = 2;
+       const int action_items = 7;
        using ud_t = ud_data_t<std::array<api_call_res_t, action_items>>;
 
        ud_t ud_data = { .loop = g_main_loop_new(NULL, FALSE),
@@ -63,6 +112,36 @@ TEST(subsession_switch_user_wait, APISwitchUserStarted) {
                                                        .desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] is successful",
                                                        .cb_expected = SUBSESSION_ERROR_NONE,
                                                        .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_2) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_3)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_3) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_3) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_2)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_2) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_4)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_4) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_4) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_0)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_0) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_0) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_4)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_4) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_4) + " ] callback is successful", },
                }
        };
 
@@ -74,7 +153,7 @@ TEST(subsession_switch_user_wait, APISwitchUserStarted) {
        EXPECT_EQ(res, SUBSESSION_ERROR_NONE);
 
 
-       const int epilogue_items = 3;
+       const int epilogue_items = 5;
        using ud_epilogue_t = ud_data_t<std::array<api_call_res_t, epilogue_items>>;
        ud_epilogue_t epilogue = { .loop = g_main_loop_new(NULL, FALSE),
                .results = std::array<api_call_res_t, epilogue_items>  {
@@ -96,6 +175,18 @@ TEST(subsession_switch_user_wait, APISwitchUserStarted) {
                                .desc = "Check if remove[ " + std::string(TestUserStr::user_2) + " ] is successful",
                                .cb_expected = SUBSESSION_ERROR_NONE,
                                .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_2) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestUserStr::user_3)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if remove [ " + std::string(TestUserStr::user_3) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_3) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestUserStr::user_4)),
+                               .expected = SUBSESSION_ERROR_NONE,
+                               .desc = "Check if remove[ " + std::string(TestUserStr::user_4) + " ] is successful",
+                               .cb_expected = SUBSESSION_ERROR_NONE,
+                               .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_4) + " ] callback is successful", },
                }
        };
 

diff --git a/tests/api_tests/test_api_switchuser.cpp b/tests/api_tests/test_api_switchuser.cpp
index e21a8c8dac7323907b2ad4db7e7366016a716132..bf8e45de228a42f76baf0f81971fb2661a5a4546 100644 (file)
--- a/tests/api_tests/test_api_switchuser.cpp
+++ b/tests/api_tests/test_api_switchuser.cpp
@@ -7,7 +7,7 @@
 
 // Test
 
-const int action_items = 15;
+const int action_items = 29;
 
 TEST(subsession_switch_user_test, APISwitchUserTest) {
 
@@ -41,6 +41,19 @@ TEST(subsession_switch_user_test, APISwitchUserTest) {
                                                        .cb_expected = SUBSESSION_ERROR_NONE,
                                                        .cb_desc = "Check if add [ " + std::string(TestUserStr::user_3) + " ] callback is successful", },
 
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_4, 15*1024)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add [ " + std::string(TestUserStr::user_4) + " ] is successful (fixed-size backend, 15 MB)",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if add [ " + std::string(TestUserStr::user_4) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_add_user_fixed_size_l<subsession_5001>( TestUserStr::user_5, 30*1024)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if add [ " + std::string(TestUserStr::user_5) + " ] is successful (fixed-size backend, 30 MB)",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if add [ " + std::string(TestUserStr::user_5) + " ] callback is successful", },
+
+                       // Default -> regular dir
                        api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_3)),
                                                        .expected = SUBSESSION_ERROR_NONE,
                                                        .desc = "Check if switch to [ " + std::string(TestUserStr::user_3) + " ] is successful",
@@ -53,6 +66,7 @@ TEST(subsession_switch_user_test, APISwitchUserTest) {
                                                        .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
                                                        .cb_desc = "Check if getting current user [" + std::string(TestUserStr::user_3) + " ]  is done", },
 
+                       // Regular dir -> regular dir
                        api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_2)),
                                                        .expected = SUBSESSION_ERROR_NONE,
                                                        .desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] is successful",
@@ -65,6 +79,33 @@ TEST(subsession_switch_user_test, APISwitchUserTest) {
                                                        .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
                                                        .cb_desc = "Check if getting current user [" + std::string(TestUserStr::user_2) + " ]  is done", },
 
+                       // Regular dir -> fixed size
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_4)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_4) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_4) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_get_current_user_l<subsession_5001>( TestUserStr::user_4)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if current  [ " + std::string(TestUserStr::user_4) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+                                                       .cb_desc = "Check if getting current user [" + std::string(TestUserStr::user_4) + " ]  is done", },
+
+                       // Fixed size -> fixed size
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_5)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_5) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_5) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_get_current_user_l<subsession_5001>( TestUserStr::user_5)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if current  [ " + std::string(TestUserStr::user_5) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+                                                       .cb_desc = "Check if getting current user [" + std::string(TestUserStr::user_5) + " ]  is done", },
+
+                       // Fixed size -> regular dir
                        api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_1)),
                                                        .expected = SUBSESSION_ERROR_NONE,
                                                        .desc = "Check if switch to [ " + std::string(TestUserStr::user_1) + " ] is successful",
@@ -77,6 +118,20 @@ TEST(subsession_switch_user_test, APISwitchUserTest) {
                                                        .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
                                                        .cb_desc = "Check if getting current user [" + std::string(TestUserStr::user_1) + " ]  is done", },
 
+                       // Regular dir -> default
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_0)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_0) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to" + std::string(TestUserStr::user_0) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_get_current_user_l<subsession_5001>( TestUserStr::user_0)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if current  [ " + std::string(TestUserStr::user_0) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+                                                       .cb_desc = "Check if getting current user [" + std::string(TestUserStr::user_0) + " ]  is done", },
+
+                       // Default -> default
                        api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_0)),
                                                        .expected = SUBSESSION_ERROR_NONE,
                                                        .desc = "Check if switch to [ " + std::string(TestUserStr::user_0) + " ] is successful",
@@ -89,6 +144,33 @@ TEST(subsession_switch_user_test, APISwitchUserTest) {
                                                        .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
                                                        .cb_desc = "Check if getting current user [" + std::string(TestUserStr::user_0) + " ]  is done", },
 
+                       // Default -> fixed-size
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_5)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_5) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to" + std::string(TestUserStr::user_5) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_5)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_5) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to" + std::string(TestUserStr::user_5) + " ] callback is successful", },
+
+                       // Fixed-size -> default
+                       api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestUserStr::user_0)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if switch to [ " + std::string(TestUserStr::user_0) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if switch to" + std::string(TestUserStr::user_0) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_get_current_user_l<subsession_5001>( TestUserStr::user_0)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if current  [ " + std::string(TestUserStr::user_0) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+                                                       .cb_desc = "Check if getting current user [" + std::string(TestUserStr::user_0) + " ]  is done", },
+
+                       // Cleanup
                        api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_1)),
                                                        .expected = SUBSESSION_ERROR_NONE,
                                                        .desc = "Check if remove [ " + std::string(TestUserStr::user_1) + " ] is successful",
@@ -106,6 +188,18 @@ TEST(subsession_switch_user_test, APISwitchUserTest) {
                                                        .desc = "Check if remove [ " + std::string(TestUserStr::user_3) + " ] is successful",
                                                        .cb_expected = SUBSESSION_ERROR_NONE,
                                                        .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_3) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_4)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if remove [ " + std::string(TestUserStr::user_4) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_4) + " ] callback is successful", },
+
+                       api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_5)),
+                                                       .expected = SUBSESSION_ERROR_NONE,
+                                                       .desc = "Check if remove [ " + std::string(TestUserStr::user_5) + " ] is successful",
+                                                       .cb_expected = SUBSESSION_ERROR_NONE,
+                                                       .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_5) + " ] callback is successful", },
                }
        };
 

diff --git a/tests/api_tests/test_hlp.hpp b/tests/api_tests/test_hlp.hpp
index 7ba36dac71267158d2d8fe1b08b5f6fe2a53d4d6..0d945992962d759ca1974e7b9a2d89f39ba27b4a 100644 (file)
--- a/tests/api_tests/test_hlp.hpp
+++ b/tests/api_tests/test_hlp.hpp
@@ -28,6 +28,9 @@ namespace TestUserStr {
        [[maybe_unused]]  static subsession_user_t user_1 = "user_1";
        [[maybe_unused]]  static subsession_user_t user_2 = "user_2";
        [[maybe_unused]]  static subsession_user_t user_3 = "user_3";
+       [[maybe_unused]]  static subsession_user_t user_4 = "user_4";
+       [[maybe_unused]]  static subsession_user_t user_5 = "user_5";
+       [[maybe_unused]]  static subsession_user_t user_6 = "user_6";
        [[maybe_unused]]  static subsession_user_t user_19 = "user__length__is_19";
 };