add_subdirectory(common)
add_subdirectory(libsessiond)
add_subdirectory(sessiond)
-add_subdirectory(clientExample)
+#add_subdirectory(clientExample)
option(ENABLE_TARGET_TESTS "On target tests" ON)
if(ENABLE_TARGET_TESTS)
#include <stdint.h>
#include <tizen.h>
+#define SUBSESSION_INITIAL_SID ""
+#define SUBSESSION_USER_MAXLEN 20
+
+typedef char subsession_user_t[SUBSESSION_USER_MAXLEN];
+
/**
* @brief Enumeration for error codes of subsession routines.
* @since_tizen 7.0
union {
struct {
- int user;
+ subsession_user_t user;
} add_user;
struct {
- int user;
+ subsession_user_t user;
} remove_user;
struct {
uint64_t switch_id;
- int prev_user;
- int next_user;
+ subsession_user_t prev_user;
+ subsession_user_t next_user;
} switch_user;
};
} subsession_event_info;
-#define SUBSESSION_INITIAL_SID ""
-#define SUBSESSION_USER_MAXLEN 20
-
/**
* @brief Callback fired when requested operation completes.
* @since_tizen 7.0
* @since_tizen 7.0
*
* @param[in] session_uid User ID of the session
- * @param[in] user Subsession ID to be created
+ * @param[in] user Subsession user name to be created
* @param[in] cb Callback to be called when operation completes or error is reported
* @param[in] cb_data User defined data
*
* @retval #SUBSESSION_ERROR_INVALID_PARAMETER Provided parameter is invalid
* @retval #SUBSESSION_ERROR_OUT_OF_MEMORY Out of memory
* @remarks Use `subsession_get_user_list()` to list currently used session IDs.
+ * Subsession ID must not start with a dot or have slashes.
*/
-int subsession_add_user(int session_uid, int user, subsession_reply_callback cb, void *cb_data);
+int subsession_add_user(int session_uid, const subsession_user_t user, subsession_reply_callback cb, void *cb_data);
/**
* @brief Request existing subsession to be removed.
* @since_tizen 7.0
*
* @param[in] session_uid User ID of the session
- * @param[in] user Subsession ID to be removed
+ * @param[in] user Subsession user name to be removed
* @param[in] cb Callback to be called when operation completes or error is reported
* @param[in] cb_data User defined data
*
* In order remove currently used session ID first switch to special session ID "" (empty string),
* and only after switch completes, remove previously active session ID.
*/
-int subsession_remove_user(int session_uid, int user, subsession_reply_callback cb, void *cb_data);
+int subsession_remove_user(int session_uid, const subsession_user_t user, subsession_reply_callback cb, void *cb_data);
/**
* @brief Switch subsession.
* @since_tizen 7.0
*
* @param[in] session_uid User ID of the session
- * @param[in] next_user Target subsession ID
+ * @param[in] next_user Target subsession user name to be switched to
* @param[in] cb Callback to be called when operation completes or error is reported
* @param[in] cb_data User defined data
*
* Special subsession ID "" (empty string) can be switched to, when it's required to deactivate
* current subsession (this step is needed when current session is to be removed).
*/
-int subsession_switch_user(int session_uid, int next_user, subsession_reply_callback cb, void *cb_data);
+int subsession_switch_user(int session_uid, const subsession_user_t next_user, subsession_reply_callback cb, void *cb_data);
/**
* @brief Get list of all available subsessions for given session ID
* @retval #SUBSESSION_ERROR_NOT_SUPPORTED Not supported
* @remarks You must free user_list using free()
*/
-int subsession_get_user_list(int session_uid, int **user_list, int *user_count);
+int subsession_get_user_list(int session_uid, subsession_user_t **user_list, int *user_count);
/**
* @brief Get currently active subsession ID for given session ID
* @retval #SUBSESSION_ERROR_PERMISSION_DENIED Not permitted
* @retval #SUBSESSION_ERROR_NOT_SUPPORTED Not supported
*/
-int subsession_get_current_user(int session_uid, int *user);
+int subsession_get_current_user(int session_uid, subsession_user_t user);
/**
* @brief Callback fired when registered events occur.
#include <gio/gio.h>
#include <tizen.h>
+#include <ctype.h>
#undef LOG_TAG
#define LOG_TAG "LIBSESSIOND"
.dbus_signal = "SwitchUserCompleted"
};
-
typedef struct {
void *client_callback;
void *client_callback_data;
void *reply_data;
} reply_client_data_t;
+
+int is_user_id_null(const char *user_id) {
+ if(user_id == NULL) {
+ LOGE("user_id is NULL");
+ return TRUE;
+ }
+ return FALSE;
+}
+
+
+int has_added_user_correct_length(const char *user_id) {
+
+ if(strnlen(user_id, SUBSESSION_USER_MAXLEN) > SUBSESSION_USER_MAXLEN-1) {
+ LOGE("user_id length:%lu > SUBSESSION_USER_MAXLEN", strnlen(user_id, SUBSESSION_USER_MAXLEN) );
+ return TRUE;
+ }
+
+ if(strnlen(user_id, SUBSESSION_USER_MAXLEN) == 0){
+ LOGE("user_id length: == 0");
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+int has_dot_first_in_name(const char *user_id) {
+ if(user_id[0] == '.') {
+ LOGE("user_id starts with '.'");
+ return TRUE;
+ }
+ return FALSE;
+}
+
+int is_not_correct_name(const char *user_id) {
+ for (size_t i = 0; i < (strnlen(user_id, SUBSESSION_USER_MAXLEN)); ++i) {
+ if (strchr(user_id, '/')) {
+ LOGE("user_id contains: /");
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+gboolean error_on_bad_user_id(const char *user_id) {
+ return (
+ is_user_id_null(user_id)
+ || has_added_user_correct_length(user_id)
+ || has_dot_first_in_name(user_id)
+ || is_not_correct_name(user_id)
+ );
+}
+
+int has_switched_user_correct_length(const char *user_id) {
+
+ if (strnlen(user_id, SUBSESSION_USER_MAXLEN) > SUBSESSION_USER_MAXLEN-1) {
+ LOGE("user_id length:%lu > SUBSESSION_USER_MAXLEN", strnlen(user_id, SUBSESSION_USER_MAXLEN) );
+ return TRUE;
+ }
+
+ if (strnlen(user_id, SUBSESSION_USER_MAXLEN) == 0) {
+ return FALSE;
+ }
+ return FALSE;
+}
+
+gboolean error_on_switch_bad_user_id(const char *user_id) {
+ return (
+ is_user_id_null(user_id)
+ || has_switched_user_correct_length(user_id)
+ || has_dot_first_in_name(user_id)
+ || is_not_correct_name(user_id)
+ );
+}
+
+
static int get_dbus_error_mapping_to_subsession_error(const char *dbus_error)
{
size_t arr_size = sizeof(error_mappings) / sizeof(error_mappings[0]);
)
int client_session_uid = 0;
- maybe_g_variant_get_int_(signal_client_data->params, "(i)", &client_session_uid);
+ maybe_g_variant_get_or_ret_diff_(signal_client_data->params, "(i)", &client_session_uid);
maybe_not_comparable_if(
session_uid_is_not_valid(client_session_uid)
)
int params_session_uid = 0;
- maybe_g_variant_get_int_(params, "(i)", ¶ms_session_uid);
+ maybe_g_variant_get_or_ret_diff_(params, "(i)", ¶ms_session_uid);
maybe_not_comparable_if(
int_not_valid(params_session_uid)
)
signal_client_data_t *signal_client_data = (signal_client_data_t*)client_data;
int client_session_uid = 0;
- maybe_g_variant_get_int_(signal_client_data->params, "(i)", &client_session_uid);
+ maybe_g_variant_get_or_ret_diff_(signal_client_data->params, "(i)", &client_session_uid);
maybe_not_comparable_if(
- user_id_is_not_valid(client_session_uid)
+ int_not_valid(client_session_uid)
)
GVariant *params = (GVariant *)parameters;
int params_session_uid = 0;
uint64_t params_switch_id = 0;
- int params_prev_user = 0;
- int params_next_user = 0;
+ char* params_prev_user = NULL;
+ char* params_next_user = NULL;
- maybe_g_variant_get_int_(params, "(ixii)",
+ maybe_g_variant_get_or_ret_diff_(params, "(ixss)",
¶ms_session_uid,
¶ms_switch_id,
¶ms_prev_user,
);
maybe_not_comparable_if(
- session_uid_is_not_valid(params_session_uid,
- switch_id_is_not_valid(params_switch_id,
- switched_user_id_is_not_valid(params_prev_user,
- switched_user_id_is_not_valid(params_next_user))))
+ int_not_valid(params_session_uid,
+ switch_id_is_not_valid(params_switch_id))
)
+ g_free(params_prev_user);
+ g_free(params_next_user);
+
if( client_session_uid == params_session_uid) {
return COMPARATOR_RESULT_SAME_;
}
static gint g_compare_session_uid_params_wait (gconstpointer client_data, gconstpointer parameters) {
+
maybe_not_comparable_if(
client_data_are_null(client_data,
parameters_are_null(parameters))
signal_client_data_t *signal_client_data = (signal_client_data_t*)client_data;
int client_session_uid = 0;
- maybe_g_variant_get_int_(signal_client_data->params, "(i)", &client_session_uid);
+ maybe_g_variant_get_or_ret_diff_(signal_client_data->params, "(i)", &client_session_uid);
maybe_not_comparable_if(
session_uid_is_not_valid(client_session_uid)
)
GVariant *params = (GVariant *)parameters;
int params_session_uid = 0;
- int user_id = 0;
+ char *user_id = NULL;
- maybe_g_variant_get_int_(params, "(ii)", ¶ms_session_uid, &user_id);
+
+ maybe_g_variant_get_or_ret_diff_(params, "(is)", ¶ms_session_uid, &user_id);
maybe_not_comparable_if(
- session_uid_is_not_valid(params_session_uid,
- user_id_is_not_valid(user_id))
+ session_uid_is_not_valid(params_session_uid)
)
+ g_free(user_id);
+
+
if( client_session_uid == params_session_uid) {
return COMPARATOR_RESULT_SAME_;
}
signal_client_data_t *signal_data = find_in_callbacks_data(client_callbacks_data, parameters, g_compare_session_uid_params_wait);
if(signal_data == NULL || signal_data->client_callback == NULL ) {
- LOGE("signal data: (%s), callback (%s)", signal_data == NULL ? "NULL" : "not NULL", signal_data->client_callback == NULL ? "NULL" : "not NULL");
+ LOGE("signal data: (%s), callback (%s)", signal_data == NULL ? "NULL" : "not NULL", signal_data == NULL ? "NULL" : signal_data->client_callback == NULL ? "NULL" : "not NULL");
return ;
}
subsession_event_info event_info;
event_info.event = SUBSESSION_ADD_USER_WAIT;
- maybe_g_variant_get_void_(parameters, "(ii)", &event_info.session_uid, &event_info.add_user.user);
+
+ char *user_id = NULL;
+
+ maybe_g_variant_get_or_ret_(parameters, "(is)", &event_info.session_uid, &user_id);
+
+ if (error_on_bad_user_id(user_id)) {
+ g_free(user_id);
+ return;
+ }
+ memcpy(event_info.add_user.user, user_id, strnlen(user_id, SUBSESSION_USER_MAXLEN)+1);
+ g_free(user_id);
subsession_event_callback event_callback = signal_data->client_callback;
event_callback(event_info, signal_data->client_callback_data);
signal_client_data_t *signal_data = find_in_callbacks_data(client_callbacks_data, parameters, g_compare_session_uid_params_wait);
if(signal_data == NULL || signal_data->client_callback == NULL ) {
- LOGE("signal data (%s), callback (%s)", signal_data == NULL ? "NULL" : "not NULL", signal_data->client_callback == NULL ? "NULL" : "not NULL");
+ LOGE("signal data: (%s), callback (%s)", signal_data == NULL ? "NULL" : "not NULL", signal_data == NULL ? "NULL" : signal_data->client_callback == NULL ? "NULL" : "not NULL");
return ;
}
-
subsession_event_info event_info;
event_info.event = SUBSESSION_REMOVE_USER_WAIT;
- maybe_g_variant_get_void_(parameters, "(ii)", &event_info.session_uid, &event_info.remove_user.user);
+
+ char *user_id = NULL;
+ maybe_g_variant_get_or_ret_(parameters, "(is)", &event_info.session_uid, &user_id);
+
+ if (error_on_bad_user_id(user_id)) {
+ g_free(user_id);
+ return;
+ }
+ memcpy(event_info.remove_user.user, user_id, strnlen(user_id, SUBSESSION_USER_MAXLEN)+1);
+ g_free(user_id);
subsession_event_callback event_callback = signal_data->client_callback;
event_callback(event_info, signal_data->client_callback_data);
signal_client_data_t *signal_data = find_in_callbacks_data(client_callbacks_data, parameters, g_compare_session_uid_params_switch_wait);
if(signal_data == NULL || signal_data->client_callback == NULL ) {
- LOGE("signal data: (%s), callback (%s)", signal_data == NULL ? "NULL" : "not NULL", signal_data->client_callback == NULL ? "NULL" : "not NULL");
+ LOGE("signal data: (%s), callback (%s)", signal_data == NULL ? "NULL" : "not NULL", signal_data == NULL ? "NULL" : signal_data->client_callback == NULL ? "NULL" : "not NULL");
return ;
}
subsession_event_info event_info = {0};
+ char *prev_user = NULL;
+ char *next_user = NULL;
+
event_info.event = SUBSESSION_SWITCH_USER_WAIT;
- maybe_g_variant_get_void_(parameters, "(ixii)",
+ maybe_g_variant_get_or_ret_(parameters, "(ixss)",
&event_info.session_uid,
&event_info.switch_user.switch_id,
- &event_info.switch_user.prev_user,
- &event_info.switch_user.next_user);
+ &prev_user,
+ &next_user);
+
+ if (error_on_switch_bad_user_id( prev_user) || error_on_switch_bad_user_id(next_user)) {
+ g_free(prev_user);
+ g_free(next_user);
+ return;
+ }
+ memcpy(event_info.switch_user.prev_user, prev_user, strnlen(prev_user, SUBSESSION_USER_MAXLEN)+1);
+ memcpy(event_info.switch_user.next_user, next_user, strnlen(next_user, SUBSESSION_USER_MAXLEN)+1);
+
+ g_free(prev_user);
+ g_free(next_user);
subsession_event_callback event_callback = signal_data->client_callback;
+
event_callback(event_info, signal_data->client_callback_data);
}
signal_client_data_t *signal_data = find_in_callbacks_data(client_callbacks_data, parameters, g_compare_session_uid_params_switch_wait);
if(signal_data == NULL || signal_data->client_callback == NULL) {
- LOGE("signal data: (%s), callback (%s)", signal_data == NULL ? "NULL" : "not NULL", signal_data->client_callback == NULL ? "NULL" : "not NULL");
+ LOGE("signal data: (%s), callback (%s)", signal_data == NULL ? "NULL" : "not NULL", signal_data == NULL ? "NULL" : signal_data->client_callback == NULL ? "NULL" : "not NULL");
return ;
}
+ char *prev_user = NULL;
+ char *next_user = NULL;
+
subsession_event_info event_info = {0};
event_info.event = SUBSESSION_SWITCH_USER_COMPLETION;
- maybe_g_variant_get_void_(parameters, "(ixii)",
+ maybe_g_variant_get_or_ret_(parameters, "(ixss)",
&event_info.session_uid,
&event_info.switch_user.switch_id,
- &event_info.switch_user.prev_user,
- &event_info.switch_user.next_user);
+ &prev_user,
+ &next_user);
+
+ if (error_on_switch_bad_user_id( prev_user) || error_on_switch_bad_user_id(next_user)) {
+ g_free(prev_user);
+ g_free(next_user);
+ return;
+ }
+
+ memcpy(event_info.switch_user.prev_user, prev_user, strnlen(prev_user, SUBSESSION_USER_MAXLEN)+1);
+ memcpy(event_info.switch_user.next_user, next_user, strnlen(next_user, SUBSESSION_USER_MAXLEN)+1);
+
+ g_free(prev_user);
+ g_free(next_user);
subsession_event_callback event_callback = signal_data->client_callback;
event_callback(event_info, signal_data->client_callback_data);
MAKE_SURE_CONNECTION_IS_NOT_NULL();
if(params == NULL) {
+ LOGE("params is NULL");
return_with_log_error_result_(SUBSESSION_ERROR_OUT_OF_MEMORY);
}
return SUBSESSION_ERROR_NONE;
}
-EXPORT_API int subsession_add_user(int session_uid, int user, subsession_reply_callback cb, void *cb_data) {
+EXPORT_API int subsession_add_user(int session_uid, const subsession_user_t user, subsession_reply_callback cb, void *cb_data) {
return_if(
session_uid_is_not_valid(session_uid,
user_id_is_not_valid(user))
)
+
return_with_log_error_result_(call_method_async
( dbus_method_call.AddUser
- , g_variant_new("(ii)", session_uid, user)
+ , g_variant_new("(is)", session_uid, user)
, cb, cb_data
))
}
-EXPORT_API int subsession_remove_user(int session_uid, int user, subsession_reply_callback cb, void *cb_data) {
+EXPORT_API int subsession_remove_user(int session_uid, const subsession_user_t user, subsession_reply_callback cb, void *cb_data) {
return_if(
- int_not_valid(session_uid,
- int_not_valid(user))
+ session_uid_is_not_valid(session_uid,
+ user_id_is_not_valid(user))
)
return_with_log_error_result_(call_method_async
( dbus_method_call.RemoveUser
- , g_variant_new("(ii)", session_uid, user)
+ , g_variant_new("(is)", session_uid, user)
, cb, cb_data
))
}
-EXPORT_API int subsession_switch_user(int session_uid, int next_user, subsession_reply_callback cb, void *cb_data) {
+EXPORT_API int subsession_switch_user(int session_uid, const subsession_user_t next_user, subsession_reply_callback cb, void *cb_data) {
return_if(
- int_not_valid_on_switch(session_uid,
- int_not_valid_on_switch(next_user))
+ switched_user_is_not_valid(next_user,
+ session_uid_is_not_valid(session_uid))
)
return_with_log_error_result_(call_method_async
( dbus_method_call.SwitchUser
- , g_variant_new("(ii)", session_uid, next_user)
+ , g_variant_new("(is)", session_uid, next_user)
, cb, cb_data
))
}
int register_event_callback(client_callbacks_data_t *callbacks_data, GDBusSignalCallback signal_callback, int session_uid, subsession_event_callback cb, void * cb_data) {
return_if(
- callbacks_data_are_null(callbacks_data,
signal_callback_is_null(signal_callback,
session_uid_is_not_valid(session_uid,
- callback_is_null(cb))))
+ callback_is_null(cb)))
)
GVariant * params = g_variant_new("(i)", session_uid);
registered_signal_t registered_signal = subsession_register_event_in_list(callbacks_data, default_wait_params_, cb_data_ );
if(registered_signal.error != SUBSESSION_ERROR_NONE) {
+ LOGE("registered_signal.error = %d", registered_signal.error);
return_with_log_error_result_(registered_signal.error);
}
if (method_call_result == 0) {
return SUBSESSION_ERROR_NONE;
}
+ LOGE("method_call_result == %d", method_call_result);
+ log_if_error_(method_call_result)
client_data_cleansweep_mt(registered_signal.signal_client_data, callbacks_data);
return SUBSESSION_ERROR_NONE;
}
-int subsession_add_user_wait_done(int session_uid, int user) {
+int subsession_add_user_wait_done(int session_uid, subsession_user_t user) {
- GVariant * params = g_variant_new("(ii)", session_uid, user);
+ GVariant * params = g_variant_new("(is)", session_uid, user);
return_with_log_error_result_(method_call_no_signal(dbus_method_call.AddUserDone, params));
}
-int subsession_remove_user_wait_done(int session_uid, int user) {
+int subsession_remove_user_wait_done(int session_uid,subsession_user_t user) {
- GVariant * params = g_variant_new("(ii)", session_uid, user);
+ GVariant * params = g_variant_new("(is)", session_uid, user);
return_with_log_error_result_(method_call_no_signal(dbus_method_call.RemoveUserDone, params));
}
case SUBSESSION_SWITCH_USER_WAIT:
return_if(
- switched_user_id_is_not_valid(info.switch_user.switch_id)
+ switch_id_is_not_valid(info.switch_user.switch_id)
)
return subsession_switch_wait_done(info.session_uid, info.switch_user.switch_id);
break;
default:
- return SUBSESSION_ERROR_INVALID_PARAMETER;
+ {
+ ret_if_err_( SUBSESSION_ERROR_INVALID_PARAMETER)
+ }
}
- return SUBSESSION_ERROR_NOT_SUPPORTED;
+ return_with_log_error_result_( SUBSESSION_ERROR_INVALID_PARAMETER)
}
-EXPORT_API int subsession_get_user_list(int session_uid, int **user_list, int *user_count) {
+EXPORT_API int subsession_get_user_list(int session_uid, subsession_user_t **user_list, int *user_count) {
return_if(
session_uid_is_not_valid(session_uid,
user_count_ptr_is_null(user_count))
g_autoptr(GVariant) out = NULL;
int ret = method_call_no_signal_return(dbus_method_call.GetUserList,
g_variant_new("(i)", session_uid),
- G_VARIANT_TYPE("(ai)"),
+ G_VARIANT_TYPE("(as)"),
&out);
if (ret != 0)
gsize elem_no = 0;
// We don't need to free this.
- const guint *data = g_variant_get_fixed_array(array, &elem_no, sizeof(int));
+ const char **data = g_variant_get_strv(array, &elem_no);
if(user_list != NULL) {
- *user_list = calloc(elem_no, sizeof(int32_t));
-
- if (!*user_list) {
- return TIZEN_ERROR_OUT_OF_MEMORY;
+ void * raw_data = calloc(elem_no, SUBSESSION_USER_MAXLEN);
+ if (raw_data == NULL) {
+ return SUBSESSION_ERROR_OUT_OF_MEMORY;
}
+ *user_list = (subsession_user_t *)raw_data;
+
+
for (gsize i = 0; i < elem_no; ++i) {
- (*user_list)[i] = data[i];
+ memcpy((*user_list)[i], data[i], strnlen(data[i], SUBSESSION_USER_MAXLEN)+1);
}
}
-
*user_count = elem_no;
return TIZEN_ERROR_NONE;
}
-EXPORT_API int subsession_get_current_user(int session_uid, int *user) {
+EXPORT_API int subsession_get_current_user(int session_uid, subsession_user_t user) {
return_if(session_uid_is_not_valid(session_uid,
current_user_ptr_is_null(user)))
g_error_free(call_sync_error);
return ret;
}
+ char *get_user = NULL;
+
+ maybe_g_variant_get_or_error_invalid(retgv,"(s)", &get_user);
+
+ if(get_user == NULL) {
+ return_with_log_error_result_(SUBSESSION_ERROR_OUT_OF_MEMORY);
+ }
- maybe_g_variant_get_int_(retgv,"(i)", user);
+ memcpy(user, get_user, strnlen(get_user, SUBSESSION_USER_MAXLEN)+1);
+ free(get_user);
return SUBSESSION_ERROR_NONE;
}
#include <tizen.h>
#include "sessiond.h"
+
typedef struct {
GDBusConnection *connection;
gchar * bus_name;
#define COMPARATOR_RESULT_DIFFERENT_ -1
//use when function return err value
-#define maybe_g_variant_get_int_(var, c_str_, args...) \
+#define maybe_g_variant_get_or_ret_diff_(var, c_str_, args...) \
if (!g_variant_is_of_type(var, G_VARIANT_TYPE(c_str_) )) { return COMPARATOR_RESULT_DIFFERENT_ ; } \
g_variant_get(var, c_str_, args)
+
//use if function return void type
-#define maybe_g_variant_get_void_(var, c_str_, args...) \
+#define maybe_g_variant_get_or_ret_(var, c_str_, args...) \
if (!g_variant_is_of_type(var, G_VARIANT_TYPE(c_str_) )) { return; } \
g_variant_get(var, c_str_, args)
#define int_not_valid(a, ...) || (a <= 0) __VA_ARGS__
#define session_uid_is_not_valid(a, ...) || (a <= 0) __VA_ARGS__
-#define user_id_is_not_valid(a, ...) || (a <= 0) __VA_ARGS__
+#define user_id_is_not_valid(a, ...) || (error_on_bad_user_id(a)) __VA_ARGS__
-#define switched_user_id_is_not_valid(a, ...) || (a < 0) __VA_ARGS__
-#define switch_id_is_not_valid(a, ...) || (a <= 0) __VA_ARGS__
+#define switched_user_is_not_valid(a, ...) || (error_on_switch_bad_user_id(a)) __VA_ARGS__
+#define switch_id_is_not_valid(a, ...) || (a <= 0) __VA_ARGS__
#define int_not_valid_on_switch(a, ...) || (a < 0) __VA_ARGS__
#define maybe_not_comparable_if(a) diff_if_not_compared_(a, COMPARATOR_RESULT_DIFFERENT_)
#define return_if(a) error_if(a, SUBSESSION_ERROR_INVALID_PARAMETER)
+#define maybe_g_variant_get_or_error_invalid(var, c_str_, args...) \
+ if (!g_variant_is_of_type(var, G_VARIANT_TYPE(c_str_) )) { log_if_error_( SUBSESSION_ERROR_INVALID_PARAMETER) \
+ return SUBSESSION_ERROR_INVALID_PARAMETER; } \
+ g_variant_get(var, c_str_, args)
+
#ifdef __cplusplus
}
#endif
find_package(PkgConfig)
pkg_check_modules(DEPS REQUIRED IMPORTED_TARGET glib-2.0 gio-2.0 gobject-2.0)
-
function(add_libsd_target_test name wraps)
message("target_test: cmake src dir ====> ${CMAKE_SOURCE_DIR}")
set(CMAKE_CXX_STANDARD 20)
add_libsd_target_test(api_adduserwait "")
add_libsd_target_test(api_removeuserwait "")
add_libsd_target_test(api_switch_user_wait "")
-add_libsd_target_test(api_reg_unreg_add_user_wait "")
add_libsd_target_test(api_switch_user_completion "")
add_libsd_target_test(api_get_user_list "")
add_libsd_target_test(api_event_wait_done_err "")
#include "sessiond.h"
#include "test_hlp.hpp"
-// Test
-typedef struct {
- int callback_result;
-} test_user_data;
-
-typedef struct {
- GMainLoop * loop;
- test_user_data *user_data;
-}ud_ctrl;
-
-
-int callback_pending_reference;
-
-gboolean callback_pending_o(gpointer data) {
-
- ud_ctrl *ud = (ud_ctrl*)data;
- gboolean is_pending = g_main_context_pending(NULL);
- gint ctrl_value = g_atomic_int_get(&callback_pending_reference);
-
- if(is_pending == TRUE) {
- return TRUE;
- }
-
- if(ctrl_value >= 2) {
- g_main_loop_quit((GMainLoop*)ud->loop);
- }
- return TRUE;
-}
-
-void test_reply_adduser_callback_o (int result, void *cb_data) {
-
- g_atomic_int_inc(&callback_pending_reference);
-
- if (cb_data == NULL) {
- return;
- }
-
- test_user_data *user_data = (test_user_data *)cb_data;
- user_data->callback_result = result;
-}
-
-void test_reply_removeuser_callback_o (int result, void *cb_data) {
-
- g_atomic_int_inc(&callback_pending_reference);
- if (cb_data == NULL) {
- return;
- }
-
- test_user_data *user_data = (test_user_data *)cb_data;
- user_data->callback_result = result;
-}
+const int action_items = 2;
TEST(subsession_add_remove_user_test, APIAddRemoveUserTest) {
- ud_ctrl ud_o;
- ud_o.loop = g_main_loop_new(NULL, FALSE);
-
- g_atomic_int_set(&callback_pending_reference, 0);
-
- test_user_data test_add_ud_o;
- test_add_ud_o.callback_result = -1;
-
- std::cout << head_ << "Add: subsession: ," << test_subsession_uid << "user: " << TestUser::user_2 << std::endl;
- int add_user_res = subsession_add_user(test_subsession_uid, TestUser::user_2, test_reply_adduser_callback_o, (void *)&test_add_ud_o);
+ using ud_t = ud_data_t<std::array<api_call_res_t, action_items>>;
- test_user_data test_remove_ud_o;
- test_remove_ud_o.callback_result = -1;
- std::cout << head_ << "Remove: subsession: ," << test_subsession_uid << "user: " << TestUser::user_2 << std::endl;
- int remove_user_res = subsession_remove_user(test_subsession_uid, TestUser::user_2, test_reply_removeuser_callback_o, (void *)&test_remove_ud_o);
+ ud_t ud_data = { .loop = g_main_loop_new(NULL, FALSE),
+ .results = std::array<api_call_res_t, action_items> {
- guint idle_id = g_idle_add(callback_pending_o,(gpointer*)&ud_o);
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestUserStr::user_1)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if add " + std::string(TestUserStr::user_1) + " is successful",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if add " + std::string(TestUserStr::user_1) + "callback is successful", },
- g_main_loop_run(ud_o.loop);
- g_source_remove(idle_id);
- g_main_loop_unref(ud_o.loop);
+ 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",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if remove " + std::string(TestUserStr::user_1) + "callback is successful", },
+ }
+ };
- EXPECT_EQ(add_user_res, 0);
- EXPECT_EQ(remove_user_res, 0);
- EXPECT_EQ(0, test_add_ud_o.callback_result);
- EXPECT_EQ(0, test_remove_ud_o.callback_result);
+ loop_run_for_test(callback_pending<ud_t, api_call_res_t>, &ud_data, ud_data.loop);
+ summarize<action_items>(ud_data.results);
}
#include "sessiond.h"
#include "test_hlp.hpp"
-using tud_ = test_user_data_cb_t;
-using ud_add_user_fail = struct ud_ctrl_t<tud_, tud_, tud_, tud_, tud_>;
-
-struct add_user_fail {
- enum action {
- add_user_0 = 0,
- add_user_minus_1,
- add_user_1,
- add_user_1_again,
- remove_user_1,
- action_items,
- };
-};
-
-TEST(subsession_add_remove_test, FailAtAddUser) {
-
- ud_add_user_fail ud = { .loop = g_main_loop_new(NULL, FALSE),
- .t = ud_add_user_fail::the_tuple(),
- };
-
- std::apply([](auto &... args){( (init_user_s<tud_ &, subsession_5002>(args) ), ...); }, ud.t );
-
- std::array<res_t_cb, add_user_fail::action_items> results {
- res_t_cb{ add_user_wrap<ud_add_user_fail, add_user_fail::add_user_0>(TestUser::user_0, test_reply_callback_default, ud),
- SUBSESSION_ERROR_INVALID_PARAMETER, "Check if adding user 0 returns error",
- std::get<add_user_fail::add_user_0>(ud.t),
- SUBSESSION_ERROR_INVALID_PARAMETER, "Check if adding user 0 returns error in callback" },
-
- res_t_cb{ add_user_wrap<ud_add_user_fail, add_user_fail::add_user_minus_1>(-(TestUser::user_1), test_reply_callback_default, ud),
- SUBSESSION_ERROR_INVALID_PARAMETER, "Check if adding user -1 returns error",
- std::get<add_user_fail::add_user_minus_1>(ud.t),
- SUBSESSION_ERROR_INVALID_PARAMETER, "Check if adding user -1 returns error in callback" },
-
- res_t_cb{ add_user_wrap<ud_add_user_fail, add_user_fail::add_user_1>( (TestUser::user_1), test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if adding user 1 returns no error",
- std::get<add_user_fail::add_user_1>(ud.t),
- SUBSESSION_ERROR_NONE, "Check if adding user 1 returns no error in callback" },
-
- res_t_cb{ add_user_wrap<ud_add_user_fail, add_user_fail::add_user_1_again>( (TestUser::user_1), test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if adding user 1 again returns no error" ,
- std::get<add_user_fail::add_user_1_again>(ud.t),
- SUBSESSION_ERROR_ALREADY_EXISTS, "Check if adding user 1 returns error in callback" },
-
- res_t_cb{ remove_user_wrap<ud_add_user_fail, add_user_fail::remove_user_1>( (TestUser::user_1), test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if removing user 1 returns no error",
- std::get<add_user_fail::remove_user_1>(ud.t),
- SUBSESSION_ERROR_NONE, "Check if emoving user 1 returns no error in callback" },
- };
-
- loop_run_for_test(callback_pending_ud<ud_add_user_fail>,(gpointer*)&ud, ud.loop);
-
- summarize_results_cb<add_user_fail::action_items>(results);
-}
-
-using ud_remove_user_fail = struct ud_ctrl_t<tud_, tud_, tud_, tud_, tud_, tud_> ;
-
-struct remove_user_fail {
- enum action {
- remove_user_0 = 0,
- remove_user_1,
- remove_user_minus_1,
- add_user_1,
- remove_user_1_existing,
- remove_user_1_again,
- action_items,
- };
-};
-
-TEST(subsession_add_remove_test, FailAtRemoveUser) {
- ud_remove_user_fail ud = { .loop = g_main_loop_new(NULL, FALSE),
-
- .t = ud_remove_user_fail::the_tuple(),
- };
-
- std::apply([](auto &... args){( (init_user_s<tud_ &, subsession_5003>(args) ), ...); }, ud.t );
-
- std::array<res_t_cb, remove_user_fail::action_items> results {
-
- res_t_cb{ remove_user_wrap<ud_remove_user_fail, remove_user_fail::remove_user_0>( (TestUser::user_0), test_reply_callback_default, ud),
- SUBSESSION_ERROR_INVALID_PARAMETER, "Check if removing user 0 returns error",
- std::get<remove_user_fail::remove_user_0>(ud.t),
- SUBSESSION_ERROR_INVALID_PARAMETER, "Check if emoving user 0 returns error in callback" },
-
- res_t_cb{ remove_user_wrap<ud_remove_user_fail, remove_user_fail::remove_user_1>( (TestUser::user_1), test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if removing non existing user 1 returns no error",
- std::get<remove_user_fail::remove_user_1>(ud.t),
- SUBSESSION_ERROR_NOT_AVAILABLE, "Check if removing non existing user 1 returns error in callback"},
-
- res_t_cb{ remove_user_wrap<ud_remove_user_fail, remove_user_fail::remove_user_minus_1>( -(TestUser::user_1), test_reply_callback_default, ud),
- SUBSESSION_ERROR_INVALID_PARAMETER, "Check if removing non existing user -1 returns error",
- std::get<remove_user_fail::remove_user_minus_1>(ud.t),
- SUBSESSION_ERROR_INVALID_PARAMETER, "Check if removing non existing user -1 returns error in callback"},
-
- res_t_cb{ add_user_wrap<ud_remove_user_fail, remove_user_fail::add_user_1>( TestUser::user_1, test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if adding non existing user 1 returns no error",
- std::get<remove_user_fail::add_user_1>(ud.t),
- SUBSESSION_ERROR_NONE, "Check if adding non existing user 1 returns no error in callback"},
-
- res_t_cb{ remove_user_wrap<ud_remove_user_fail, remove_user_fail::remove_user_1_existing>( TestUser::user_1, test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if removing user 1 returns no error" ,
- std::get<remove_user_fail::remove_user_1_existing>(ud.t),
- SUBSESSION_ERROR_NONE, "Check if removing user 1 returns no error in callback"},
-
- res_t_cb{ remove_user_wrap<ud_remove_user_fail, remove_user_fail::remove_user_1_again>( TestUser::user_1, test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if removing 1 again returns no error",
- std::get<remove_user_fail::remove_user_1_again>(ud.t),
- SUBSESSION_ERROR_NOT_AVAILABLE, "Check if removing user 1 returns error in callback"},
+const int action_items = 11;
+
+TEST(subsession_add_remove_test, FailAtAddRemoveUser) {
+ 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),
+ .results = std::array<api_call_res_t, action_items> {
+
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestBadUserStr::bad_user_1)),
+ .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .desc = "Check if add [ " + std::string(TestBadUserStr::bad_user_1) + " ] returns error",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if add [ " + std::string(TestBadUserStr::bad_user_1) + " ] callback returns error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestBadUserStr::bad_user_1)),
+ .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .desc = "Check if remove [ " + std::string(TestBadUserStr::bad_user_1) + " ] returns error",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if remove [ " + std::string(TestBadUserStr::bad_user_1) + " ] callback returns error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestBadUserStr::bad_user_3)),
+ .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .desc = "Check if add [ " + std::string(TestBadUserStr::bad_user_3) + " ] returns error",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if add [ " + std::string(TestBadUserStr::bad_user_3) + " ] callback returns error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestBadUserStr::bad_user_3)),
+ .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .desc = "Check if remove [ " + std::string(TestBadUserStr::bad_user_3) + " ] returns error",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if remove [ " + std::string(TestBadUserStr::bad_user_3) + " ] callback returns error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestBadUserStr::bad_user_2)),
+ .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .desc = "Check if add [ " + std::string(TestBadUserStr::bad_user_2) + " ] returns error",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if add [ " + std::string(TestBadUserStr::bad_user_2) + " ] callback returns error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestBadUserStr::bad_user_2)),
+ .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .desc = "Check if remove [ " + std::string(TestBadUserStr::bad_user_2) + " ] returns error",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if remove [ " + std::string(TestBadUserStr::bad_user_2) + " ] callback returns error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestBadUserStr::bad_user_empty)),
+ .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .desc = "Check if add [ " + std::string(TestBadUserStr::bad_user_empty) + " ] returns error",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if add [ " + std::string(TestBadUserStr::bad_user_empty) + " ] callback returns error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestBadUserStr::bad_user_empty)),
+ .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .desc = "Check if remove [ " + std::string(TestBadUserStr::bad_user_empty) + " ] returns error",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if remove [ " + std::string(TestBadUserStr::bad_user_empty) + " ] callback returns error", },
+
+ 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 non existent [ " + std::string(TestUserStr::user_1) + " ] returns no error",
+ .cb_expected = SUBSESSION_ERROR_NOT_AVAILABLE,
+ .cb_desc = "Check if remove non exixtent [ " + std::string(TestUserStr::user_1) + " ] callback returns error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestBadUserStr::bad_user_long)),
+ .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .desc = "Check if add [ " + std::string(TestBadUserStr::bad_user_long) + " ] returns error",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if add [ " + std::string(TestBadUserStr::bad_user_long) + " ] callback returns error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestBadUserStr::bad_user_long)),
+ .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .desc = "Check if remove [ " + std::string(TestBadUserStr::bad_user_long) + " ] returns error",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if remove [ " + std::string(TestBadUserStr::bad_user_long) + " ] callback returns error", },
+
+ }
};
- loop_run_for_test(callback_pending_ud<ud_remove_user_fail>,(gpointer*)&ud, ud.loop);
-
- summarize_results_cb<remove_user_fail::action_items>(results);
-
+ loop_run_for_test(callback_pending<ud_t, api_call_res_t>, &ud_data, ud_data.loop);
+ summarize<action_items>(ud_data.results);
}
#include "test_hlp.hpp"
-// Test
-
-typedef struct {
- int session_uid;
- int user_id;
- int callback_result;
-} test_user_data_t;
-
-typedef struct {
- int user;
- int session_uid;
-} test_user_wait_data_t;
-
-template <typename... Args>
-bool all_true(Args... args)
-{
- return (... && args);
-}
-
-int callback_adduser_reference;
-
-void test_reply_adduser_callback (int result, void *cb_data) {
-
- g_atomic_int_inc(&callback_adduser_reference);
-
- if (cb_data == NULL) {
- return;
- }
-
- test_user_data_t *user_data = (test_user_data_t *)cb_data;
- user_data->callback_result = result;
-}
-
-int callback_removeuser_reference;
-
-void test_reply_removeuser_callback (int result, void *cb_data) {
-
- g_atomic_int_inc(&callback_removeuser_reference);
-
- if (cb_data == NULL) {
- return;
- }
-
- test_user_data_t *user_data = (test_user_data_t *)cb_data;
- user_data->callback_result = result;
-}
-
-int callback_adduserstarted_reference;
-
-void test_subsession_add_user_wait_callback(subsession_event_info info, void *cb_data) {
-
-
- test_user_data_t *user_data = (test_user_data_t *)cb_data;
-
- if (cb_data == NULL)
- return;
-
- user_data->user_id = info.add_user.user;
- user_data->session_uid = info.session_uid;
-
- user_data->callback_result = subsession_event_wait_done(info);
- g_atomic_int_inc(&callback_adduserstarted_reference);
-}
-
-using ud_ = struct ud_ctrl_t<int*, int*, int*>;
+const int action_items = 3;
TEST(subsession_add_user_wait_test, APIAddUserWaitTest) {
- ud_ ud = { .loop = g_main_loop_new (NULL, FALSE),
- .t = {
- &callback_adduser_reference,
- &callback_removeuser_reference,
- &callback_adduserstarted_reference,
+ 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),
+ .results = std::array<api_call_res_t, action_items> {
+
+ api_call_res_t{ .call_result = std::move(subsession_register_event_add_user_l<subsession_5001>()),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if register add user event is successful",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if register add user event callback is successful", },
+
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestUserStr::user_1)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if add [ " + std::string(TestUserStr::user_1) + " ] is successful",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if add [ " + std::string(TestUserStr::user_1) + " ] callback is successful", },
+
+ 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",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_1) + " ] callback is successful", },
}
- };
-
- std::apply([](auto... args){( (_set_0(args) ), ...); }, ud.t );
- test_user_data_t test_add_wait_1_2 = {
- .session_uid = -1,
- .user_id = -3,
- .callback_result = -1
};
- //int subsession_register_event_callback(int session_uid, subsession_event_type_e event_bits, subsession_event_callback cb, void *cb_data);
-
- int add_user_wait_res_1_2 = subsession_register_event_callback(test_subsession_uid, SUBSESSION_ADD_USER_WAIT ,test_subsession_add_user_wait_callback, (void*)&test_add_wait_1_2);
-
- test_user_data_t test_add_1_2 = {
- .session_uid = test_subsession_uid,
- .user_id = 2,
- .callback_result = -1,
- };
-
-
- int add_user_res_1_2 = subsession_add_user(test_add_1_2.session_uid, test_add_1_2.user_id,
- test_reply_adduser_callback, (void *)&test_add_1_2);
-
- test_user_data_t test_remove_1_2 = {
- .session_uid = test_subsession_uid,
- .user_id = 2,
- .callback_result = -1,
- };
-
- int remove_user_res_1_2 = subsession_remove_user(test_remove_1_2.session_uid, test_remove_1_2.user_id,
- test_reply_removeuser_callback, (void *)&test_remove_1_2);
-
- g_idle_add(callback_pending<ud_>,(gpointer*)&ud);
- g_main_loop_run(ud.loop);
+ loop_run_for_test(callback_pending<ud_t, api_call_res_t>, &ud_data, ud_data.loop);
- EXPECT_EQ(add_user_wait_res_1_2, 0);
- EXPECT_EQ(add_user_res_1_2, 0);
- EXPECT_EQ(remove_user_res_1_2, 0);
+ int res = subsession_unregister_event_callback(subsession_5001::subsession_uid(), SUBSESSION_ADD_USER_WAIT);
- EXPECT_EQ(0, test_add_wait_1_2.callback_result);
- EXPECT_EQ(2, test_add_wait_1_2.user_id);
- EXPECT_EQ(test_subsession_uid, test_add_wait_1_2.session_uid);
+ EXPECT_EQ(res, SUBSESSION_ERROR_NONE);
- EXPECT_EQ(0, test_add_1_2.callback_result);
- EXPECT_EQ(0, test_remove_1_2.callback_result);
+ summarize<action_items>(ud_data.results);
}
.session_uid = subsession_5001::subsession_uid(),
.switch_user = {
.switch_id = 1,
- .prev_user = TestUser::user_1,
- .next_user = TestUser::user_2
+ .prev_user{*TestUserStr::user_1},
+ .next_user{*TestUserStr::user_2}
}
};
- auto get_info = [&] (int suid, subsession_event_type_e e) {
+ auto get_info = [&] ( int suid, subsession_event_type_e e) {
auto tmp = e_info;
tmp.event = e;
tmp.session_uid = suid;
#include<iostream>
#include <algorithm>
#include <array>
+#include <vector>
+#include <functional>
#include <gtest/gtest.h>
#include <gio/gio.h>
#include <pthread.h>
}
template<typename T>
-void summarize_results_for_get_user_list(tgl_ &data, T &&expected_users) {
+void summarize_results_for_get_user_list(tgl_ &data, T expected_users) {
std::cout << head_ << "Check if got users number ( " << expected_users.size() << " ) is same as expected ( "<< data.user_count << " )."<< std::endl;
EXPECT_EQ(expected_users.size(), data.user_count);
if(expected_users.size() == 0 || data.user_count == 0) {
return;
}
+ std::vector<std::string> got_users_v;
+
+ for (int i = 0; i < data.user_count; i++) {
+ got_users_v.push_back(std::string(data.user_list[i]));
+ }
std::sort(expected_users.begin(), expected_users.end());
- std::sort(data.user_list, data.user_list + data.user_count);
+ std::sort(got_users_v.begin(), got_users_v.end());
std::cout << head_ << "Check if expected users list is same as given."<< std::endl;
for (int i = 0; i < data.user_count; ++i) {
- EXPECT_EQ(data.user_list[i], expected_users[i]);
+ EXPECT_EQ(expected_users[i].compare(got_users_v[i]), 0);
+ //std::cout << got_users_v[i] << std::endl;
}
-
}
-
TEST(subsession_get_user_list, GetUserListOk) {
ud_get_user_t ud = { .loop = g_main_loop_new(NULL, FALSE),
res_t{ get_user_list_wrap<ud_get_user_t, get_user::get_user_list_0>(ud),
SUBSESSION_ERROR_NONE, "Check if get list with only user 0 returns no error" },
- res_t{ add_user_wrap<ud_get_user_t, get_user::add_user_1>(TestUser::user_1, test_reply_callback_default, ud),
+ res_t{ add_user_wrap<ud_get_user_t, get_user::add_user_1>(TestUserStr::user_1, test_reply_callback_default, ud),
SUBSESSION_ERROR_NONE, "Check if adding user 1 returns no error" },
- res_t{ add_user_wrap<ud_get_user_t, get_user::add_user_2>(TestUser::user_2, test_reply_callback_default, ud),
+ res_t{ add_user_wrap<ud_get_user_t, get_user::add_user_2>(TestUserStr::user_2, test_reply_callback_default, ud),
SUBSESSION_ERROR_NONE, "Check if adding user 2 returns no error" },
res_t{ get_user_list_wrap<ud_get_user_t, get_user::get_user_list_1_2>(ud),
res_t{ get_user_list_count_only_wrap<ud_get_user_t, get_user::get_user_list_1_2_count_only>(ud),
SUBSESSION_ERROR_NONE, "Check if get counter only for user 1 and 2 returns no error" },
- res_t{ remove_user_wrap<ud_get_user_t, get_user::remove_user_1>(TestUser::user_1, test_reply_callback_default, ud),
+ res_t{ remove_user_wrap<ud_get_user_t, get_user::remove_user_1>(TestUserStr::user_1, test_reply_callback_default, ud),
SUBSESSION_ERROR_NONE, "Check if removing user 1 returns no error" },
- res_t{ remove_user_wrap<ud_get_user_t, get_user::remove_user_2>(TestUser::user_2, test_reply_callback_default, ud),
+ res_t{ remove_user_wrap<ud_get_user_t, get_user::remove_user_2>(TestUserStr::user_2, test_reply_callback_default, ud),
SUBSESSION_ERROR_NONE, "Check if removing user 2 returns no error" },
};
loop_run_for_test(callback_pending_ud<ud_get_user_t>,(gpointer*)&ud, ud.loop);
- summarize_results_for_get_user_list(std::get<get_user::get_user_list_0>(ud.t), std::array<int, 0>{});
- summarize_results_for_get_user_list(std::get<get_user::get_user_list_1_2>(ud.t), std::array<int, 2>{1, 2});
- summarize_results_for_counted_only_get_user_list(std::get<get_user::get_user_list_1_2_count_only>(ud.t), 2);
+ summarize_results_for_get_user_list(std::get<get_user::get_user_list_0>(ud.t), std::array<std::string, 0>());
+ std::array<std::string, 2> arr{std::string(TestUserStr::user_1), std::string(TestUserStr::user_2)};
+ summarize_results_for_get_user_list<std::array<std::string, 2>>(std::get<get_user::get_user_list_1_2>(ud.t), arr);
+ summarize_results_for_counted_only_get_user_list(std::get<get_user::get_user_list_1_2_count_only>(ud.t), 2);
summarize_results<get_user::action_items>(results);
}
+++ /dev/null
-#include<iostream>
-#include <gtest/gtest.h>
-#include <gio/gio.h>
-#include <pthread.h>
-
-#include <tuple>
-#include <utility>
-#include <iostream>
-#include "sessiond.h"
-
-#include "test_hlp.hpp"
-
-// Test
-
-typedef struct {
- int session_uid;
- int user_id;
- int callback_result;
-} test_user_data_t;
-
-typedef struct {
- int user;
- int session_uid;
-} test_user_wait_data_t;
-
-int callback_adduser_reference;
-
-void test_reply_adduser_callback (int result, void *cb_data) {
-
- g_atomic_int_inc(&callback_adduser_reference);
-
- if (cb_data == NULL) {
- return;
- }
-
- test_user_data_t *user_data = (test_user_data_t *)cb_data;
- user_data->callback_result = result;
-}
-
-int callback_removeuser_reference;
-
-void test_reply_removeuser_callback (int result, void *cb_data) {
-
- g_atomic_int_inc(&callback_removeuser_reference);
-
- if (cb_data == NULL) {
- return;
- }
-
- test_user_data_t *user_data = (test_user_data_t *)cb_data;
- user_data->callback_result = result;
-}
-
-int callback_adduserstarted_reference;
-
-void test_subsession_add_user_wait_callback(subsession_event_info info, void *cb_data) {
-
- test_user_data_t *user_data = (test_user_data_t *)cb_data;
-
- if (cb_data == NULL)
- return;
-
- user_data->user_id = info.add_user.user;
- user_data->session_uid = info.session_uid;
-
- user_data->callback_result = subsession_event_wait_done(info);
- g_atomic_int_inc(&callback_adduserstarted_reference);
-}
-
-using ud_ = struct ud_ctrl_t<int*, int*, int*>;
-
-TEST(subsession_register_and_remove_user_wait_test, APIRegisterAndRemoveAddUserWaitTest) {
-
- ud_ ud = { .loop = g_main_loop_new (NULL, FALSE),
- .t = {
- &callback_adduser_reference,
- &callback_removeuser_reference,
- &callback_adduserstarted_reference,
- }
- };
-
- std::apply([](auto... args){( (_set_0(args) ), ...); }, ud.t );
-
- test_user_data_t test_add_wait_1_2 = {
- .session_uid = -1,
- .user_id = -3,
- .callback_result = -1
- };
-
- //int subsession_register_event_callback(int session_uid, subsession_event_type_e event_bits, subsession_event_callback cb, void *cb_data);
-
- int reg_add_user_wait_res_1_2 = subsession_register_event_callback(test_subsession_uid, SUBSESSION_ADD_USER_WAIT ,test_subsession_add_user_wait_callback, (void*)&test_add_wait_1_2);
-
- test_user_data_t test_add_1_2 = {
- .session_uid = test_subsession_uid,
- .user_id = 2,
- .callback_result = -1,
- };
-
- int add_user_res_1_2 = subsession_add_user(test_add_1_2.session_uid, test_add_1_2.user_id,
- test_reply_adduser_callback, (void *)&test_add_1_2);
-
- test_user_data_t test_remove_1_2 = {
- .session_uid = test_subsession_uid,
- .user_id = 2,
- .callback_result = -1,
- };
- int remove_user_res_1_2 = subsession_remove_user(test_remove_1_2.session_uid, test_remove_1_2.user_id,
- test_reply_removeuser_callback, (void *)&test_remove_1_2);
-
- g_atomic_int_inc(&callback_adduserstarted_reference);
- int rem_add_user_wait_res_1_2 = subsession_unregister_event_callback(test_subsession_uid, SUBSESSION_ADD_USER_WAIT);
-
- g_idle_add(callback_pending<ud_>,(gpointer*)&ud);
- g_main_loop_run(ud.loop);
-
- EXPECT_EQ(reg_add_user_wait_res_1_2, 0);
- EXPECT_EQ(add_user_res_1_2, 0);
- EXPECT_EQ(remove_user_res_1_2, 0);
-
- EXPECT_EQ(-1, test_add_wait_1_2.callback_result);
- EXPECT_EQ(-3, test_add_wait_1_2.user_id);
- EXPECT_EQ(-1, test_add_wait_1_2.session_uid);
-
- EXPECT_EQ(0, test_add_1_2.callback_result);
- EXPECT_EQ(0, test_remove_1_2.callback_result);
- EXPECT_EQ(rem_add_user_wait_res_1_2, 0);
-
-}
#include "sessiond.h"
#include "test_hlp.hpp"
-using tud_ = test_user_data_cb_t;
-using ud_register_event_fail = struct ud_ctrl_t<tud_, tud_, tud_, tud_, tud_>;
-
-struct register_event_fail {
- enum action {
- register_bad_session_uid = 0,
- register_seesion_ok,
- register_again_error,
- unregister_session_ok,
- unregister_session_again_error,
- action_items,
- };
-};
+const int action_items = 5;
TEST(register_event, FailAtRegisterEvent) {
- ud_register_event_fail ud = { .loop = g_main_loop_new(NULL, FALSE),
- .t = ud_register_event_fail::the_tuple(),
- };
-
- std::apply([](auto &... args){( (init_user_s<tud_ &, subsession_5001>(args) ), ...); }, ud.t );
-
- init_user_s<tud_ &, bad_subsession_5004>(std::get<register_event_fail::register_bad_session_uid>(ud.t));
+ using ud_t = ud_data_t<std::array<api_register_only_res_t, action_items>>;
+ ud_t ud_data = { .loop = g_main_loop_new(NULL, FALSE),
+ .results = std::array<api_register_only_res_t, action_items> {
- std::array<res_t, register_event_fail::action_items> results {
- res_t{ register_event_wrap<ud_register_event_fail, register_event_fail::register_bad_session_uid, true>(SUBSESSION_ADD_USER_WAIT, test_event_add_user_callback, ud),
- SUBSESSION_ERROR_INVALID_PARAMETER, "Check if bad session uid is returns error"},
+ api_register_only_res_t{ .call_result = std::move(subsession_register_event_add_user_l<bad_subsession_5004, true>()),
+ .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .desc = "Check if bad session uid is returns error", },
- res_t {register_event_wrap<ud_register_event_fail, register_event_fail::register_seesion_ok, true>(SUBSESSION_ADD_USER_WAIT, test_event_add_user_callback, ud),
- SUBSESSION_ERROR_NONE, "Check if registered session returns no error"},
+ api_register_only_res_t{ .call_result = std::move(subsession_register_event_add_user_l<subsession_5001, true>()),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "heck if registered session returns no error", },
- res_t { register_event_wrap<ud_register_event_fail, register_event_fail::register_again_error, true>(SUBSESSION_ADD_USER_WAIT, test_event_add_user_callback, ud),
- SUBSESSION_ERROR_ALREADY_EXISTS, "Check if registered session returns already exists error"},
+ api_register_only_res_t{ .call_result = std::move(subsession_register_event_add_user_l<subsession_5001, true>()),
+ .expected = SUBSESSION_ERROR_ALREADY_EXISTS,
+ .desc = "Check if registered session returns already exists error", },
- res_t { unregister_event_wrap <ud_register_event_fail, register_event_fail::unregister_session_ok, true>(SUBSESSION_ADD_USER_WAIT, test_event_add_user_callback, ud),
- SUBSESSION_ERROR_NONE, "Check if unregistered session returns no error"},
+ api_register_only_res_t{ .call_result = std::move(subsession_unregister_event_add_user_l<subsession_5001, true>()),
+ .expected =SUBSESSION_ERROR_NONE,
+ .desc = "Check if unregistered session returns no error", },
- res_t { unregister_event_wrap <ud_register_event_fail, register_event_fail::unregister_session_again_error, true>(SUBSESSION_ADD_USER_WAIT, test_event_add_user_callback, ud),
- SUBSESSION_ERROR_NOT_AVAILABLE, "Check if unregistered the same session returns error"},
+ api_register_only_res_t{ .call_result = std::move(subsession_unregister_event_add_user_l<subsession_5001, true>()),
+ .expected = SUBSESSION_ERROR_NOT_AVAILABLE,
+ .desc = "Check if unregistered the same session returns error", },
+ }
};
- loop_run_for_test(callback_pending_ud<ud_register_event_fail>,(gpointer*)&ud, ud.loop);
+ loop_run_for_test(callback_pending<ud_t, api_register_only_res_t>, &ud_data, ud_data.loop);
+ summarize_no_cb<action_items>(ud_data.results);
- summarize_results<register_event_fail::action_items>(results);
}
#include "sessiond.h"
#include "test_hlp.hpp"
-
-// Test
-
-typedef struct {
- int session_uid;
- int user_id;
- int callback_result;
-} test_user_data_t;
-
-typedef struct {
- int user;
- int session_uid;
-} test_user_wait_data_t;
-
-int callback_adduser_reference;
-
-void test_reply_adduser_callback (int result, void *cb_data) {
-
- g_atomic_int_inc(&callback_adduser_reference);
-
- if (cb_data == NULL) {
- return;
- }
-
- test_user_data_t *user_data = (test_user_data_t *)cb_data;
- user_data->callback_result = result;
-}
-
-int callback_removeuser_reference;
-
-void test_reply_removeuser_callback (int result, void *cb_data) {
-
- g_atomic_int_inc(&callback_removeuser_reference);
-
- if (cb_data == NULL) {
- return;
- }
-
- test_user_data_t *user_data = (test_user_data_t *)cb_data;
- user_data->callback_result = result;
-}
-
-int callback_remove_user_started_reference;
-
-void test_subsession_remove_user_wait_callback(subsession_event_info info, void *cb_data) {
-
- test_user_data_t *user_data = (test_user_data_t *)cb_data;
-
- if (cb_data == NULL)
- return;
-
- user_data->user_id = info.remove_user.user;
- user_data->session_uid = info.session_uid;
-
- user_data->callback_result = 0;
-
- user_data->callback_result = subsession_event_wait_done(info);
-
- g_atomic_int_inc(&callback_remove_user_started_reference);
-}
-
-using ud_ = struct ud_ctrl_t<int*, int*, int*>;
+const int action_items = 3;
TEST(subsession_remove_user_wait_test, APIRemoveUserWaitTest) {
- ud_ ud = { .loop = g_main_loop_new (NULL, FALSE),
- .t = {
- &callback_adduser_reference,
- &callback_removeuser_reference,
- &callback_remove_user_started_reference,
+ 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),
+ .results = std::array<api_call_res_t, action_items> {
+
+ api_call_res_t{ .call_result = std::move(subsession_register_event_remove_user_l<subsession_5001>()),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if register remove user event is successful",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if register remove user event callback is successful", },
+
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestUserStr::user_1)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if add [ " + std::string(TestUserStr::user_1) + " ] is successful",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if add [ " + std::string(TestUserStr::user_1) + " ] callback is successful", },
+
+ 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",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_1) + " ] callback is successful", },
}
};
- std::apply([](auto... args){( (_set_0(args) ), ...); }, ud.t );
-
- test_user_data_t test_remove_wait_1_2 = {
- .session_uid = -1,
- .user_id = -3,
- .callback_result = -1
- };
-
- //int subsession_register_event_callback(int session_uid, subsession_event_type_e event_bits, subsession_event_callback cb, void *cb_data);
-
- int remove_user_wait_res_1_2 = subsession_register_event_callback(test_subsession_uid, SUBSESSION_REMOVE_USER_WAIT
- ,test_subsession_remove_user_wait_callback, (void*)&test_remove_wait_1_2);
-
- test_user_data_t test_add_1_2 = {
- .session_uid = test_subsession_uid,
- .user_id = 2,
- .callback_result = -1,
- };
-
- int add_user_res_1_2 = subsession_add_user(test_add_1_2.session_uid, test_add_1_2.user_id,
- test_reply_adduser_callback, (void *)&test_add_1_2);
-
- test_user_data_t test_remove_1_2 = {
- .session_uid = test_subsession_uid,
- .user_id = 2,
- .callback_result = -1,
- };
-
- int remove_user_res_1_2 = subsession_remove_user(test_remove_1_2.session_uid, test_remove_1_2.user_id,
- test_reply_removeuser_callback, (void *)&test_remove_1_2);
-
-
- g_idle_add(callback_pending<ud_>,(gpointer*)&ud);
- g_main_loop_run(ud.loop);
+ loop_run_for_test(callback_pending<ud_t, api_call_res_t>, &ud_data, ud_data.loop);
- EXPECT_EQ(remove_user_wait_res_1_2, 0);
- EXPECT_EQ(add_user_res_1_2, 0);
- EXPECT_EQ(remove_user_res_1_2, 0);
+ int res = subsession_unregister_event_callback(subsession_5001::subsession_uid(), SUBSESSION_REMOVE_USER_WAIT);
- EXPECT_EQ(0, test_remove_wait_1_2.callback_result);
- EXPECT_EQ(2, test_remove_wait_1_2.user_id);
- EXPECT_EQ(test_subsession_uid, test_remove_wait_1_2.session_uid);
+ EXPECT_EQ(res, SUBSESSION_ERROR_NONE);
- EXPECT_EQ(0, test_add_1_2.callback_result);
- EXPECT_EQ(0, test_remove_1_2.callback_result);
+ summarize<action_items>(ud_data.results);
}
#include "test_hlp.hpp"
-void test_switch_callback(int result, void *cb_data) {
-
- test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
-
- user_data->callback_result = result;
- g_atomic_int_inc(&user_data->callback_reference);
-}
-
-void test_subsession_switch_user_completion_callback(subsession_event_info info, void *cb_data) {
-
- test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
- user_data->session_uid = info.session_uid;
- user_data->switch_id = info.switch_user.switch_id;
- user_data->user_id = info.switch_user.next_user;
- user_data->prev_user_id = info.switch_user.prev_user;
- user_data->callback_result = -1;
-
- if(user_data->user_id == TestUser::user_2 || user_data->user_id == TestUser::user_0){
- user_data->callback_result = 0;
- g_atomic_int_inc(&user_data->callback_reference);
- }
-}
-
-enum {
- add_user_1 = 0,
- add_user_2,
- remove_user_1,
- remove_user_2,
- switch_user_to_1,
- switch_user_to_2,
- switch_user_to_0,
- switch_completion,
-};
-
-using tud_ = test_user_data_cb_t;
-using ud_ = struct ud_ctrl_t<tud_, tud_, tud_, tud_, tud_, tud_, tud_, tud_>;
-
TEST(subsession_switch_user_completion, APISwitchUserCompletion) {
- ud_ ud = { .loop = g_main_loop_new (NULL, FALSE),
- .t = std::tuple<tud_, tud_, tud_, tud_, tud_, tud_, tud_, tud_>(),
+ const int prologue_items = 4;
+ 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> {
+
+ 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_add_user_l<subsession_5001>( TestUserStr::user_1)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if add [ " + std::string(TestUserStr::user_1) + " ] is successful",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if add [ " + std::string(TestUserStr::user_1) + " ] callback is successful", },
+
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestUserStr::user_2)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if add [ " + std::string(TestUserStr::user_2) + " ] is successful",
+ .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_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", },
+ }
};
- std::apply([](auto &... args){( (init_user<tud_ &>(args) ), ...); }, ud.t );
+ loop_run_for_test(callback_pending<ud_prologue_t, api_call_res_t>, &prologue, prologue.loop);
+ summarize<prologue_items>(prologue.results);
- std::get<switch_completion>(ud.t).session_uid = -1;
- int switch_user_completion_res = subsession_register_event_callback(test_subsession_uid, SUBSESSION_SWITCH_USER_COMPLETION,
- test_subsession_switch_user_completion_callback, (void *)&std::get<switch_completion>(ud.t) );
+ const int action_items = 2;
+ using ud_t = ud_data_t<std::array<api_call_res_t, action_items>>;
- int add_user_res_1 = add_user_wrap<ud_, add_user_1>(TestUser::user_1, test_reply_callback_default, ud);
- int add_user_res_2 = add_user_wrap<ud_, add_user_2>(TestUser::user_2, test_reply_callback_default, ud);
+ ud_t ud_data = { .loop = g_main_loop_new(NULL, FALSE),
+ .results = std::array<api_call_res_t, action_items> {
- std::get<switch_user_to_1>(ud.t).prev_user_id = TestUser::user_1;
- std::get<switch_user_to_1>(ud.t).user_id = TestUser::user_1;
+ api_call_res_t{ .call_result = std::move(subsession_register_event_switch_user_completion_l<subsession_5001>()),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if register add user event is successful",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if register add user event callback is successful", },
- int switch_user_res_to_1 = subsession_switch_user(test_subsession_uid, std::get<switch_user_to_1>(ud.t).user_id, test_switch_callback, (void *)&std::get<switch_user_to_1>(ud.t));
-
- std::get<switch_user_to_2>(ud.t).prev_user_id = TestUser::user_1;
- std::get<switch_user_to_2>(ud.t).user_id = TestUser::user_2;
+ 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", },
+ }
+ };
- int switch_user_res_to_2 = subsession_switch_user(test_subsession_uid, std::get<switch_user_to_2>(ud.t).user_id, test_switch_callback, (void *)&std::get<switch_user_to_2>(ud.t));
+ loop_run_for_test(callback_pending<ud_t, api_call_res_t>, &ud_data, ud_data.loop);
+ summarize<action_items>(ud_data.results);
- std::get<switch_user_to_0>(ud.t).prev_user_id = TestUser::user_2;
- std::get<switch_user_to_0>(ud.t).user_id = TestUser::user_0;
- int switch_user_res_to_0 = subsession_switch_user(test_subsession_uid, std::get<switch_user_to_0>(ud.t).user_id, test_switch_callback, (void *)&std::get<switch_user_to_0>(ud.t));
+ int res = subsession_unregister_event_callback(subsession_5001::subsession_uid(), SUBSESSION_SWITCH_USER_COMPLETION);
+ EXPECT_EQ(res, SUBSESSION_ERROR_NONE);
- int remove_user_res_1 = remove_user_wrap<ud_, remove_user_1>(TestUser::user_1, test_reply_callback_default, ud);
- int remove_user_res_2 = remove_user_wrap<ud_, remove_user_2>(TestUser::user_2, test_reply_callback_default, ud);
- g_idle_add(callback_pending_ud<ud_>,(gpointer*)&ud);
- g_main_loop_run(ud.loop);
+ const int epilogue_items = 3;
+ 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> {
- EXPECT_EQ(switch_user_completion_res, 0);
- EXPECT_EQ(add_user_res_1, 0);
- EXPECT_EQ(remove_user_res_1, 0);
- EXPECT_EQ(switch_user_res_to_1, 0);
- EXPECT_EQ(switch_user_res_to_2, 0);
- EXPECT_EQ(switch_user_res_to_0, 0);
- EXPECT_EQ(add_user_res_2, 0);
- EXPECT_EQ(remove_user_res_2, 0);
+ 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", },
- EXPECT_EQ(0, std::get<add_user_1>(ud.t).callback_result);
- EXPECT_EQ(0, std::get<add_user_2>(ud.t).callback_result);
- EXPECT_EQ(0, std::get<switch_user_to_1>(ud.t).callback_result);
- EXPECT_EQ(0, std::get<switch_user_to_2>(ud.t).callback_result);
- EXPECT_EQ(0, std::get<remove_user_1>(ud.t).callback_result);
- EXPECT_EQ(0, std::get<remove_user_2>(ud.t).callback_result);
+ 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",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_1) + " ] callback is successful", },
- auto &user_data_result = std::get<switch_completion>(ud.t);
+ api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestUserStr::user_2)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .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", },
+ }
+ };
- EXPECT_EQ(0, user_data_result.callback_result);
- EXPECT_EQ(user_data_result.session_uid, test_subsession_uid);
- EXPECT_EQ(user_data_result.user_id, TestUser::user_0);
- EXPECT_EQ(user_data_result.prev_user_id, TestUser::user_2);
+ loop_run_for_test(callback_pending<ud_epilogue_t, api_call_res_t>, &epilogue, epilogue.loop);
+ summarize<epilogue_items>(epilogue.results);
}
#include "test_hlp.hpp"
-//const int user_1 = 1;
-//const int user_2 = 2;
-
-void test_subsession_switch_user_wait_callback(subsession_event_info info, void *cb_data) {
-
- test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
-
- user_data->session_uid = info.session_uid;
- user_data->switch_id = info.switch_user.switch_id;
- user_data->user_id = info.switch_user.next_user;
- user_data->prev_user_id = info.switch_user.prev_user;
- user_data->callback_result = subsession_event_wait_done(info);
-
- if (user_data->user_id == TestUser::user_0 || user_data->user_id == TestUser::user_2) {
- g_atomic_int_inc(&user_data->callback_reference);
- }
-}
-
-enum {
- add_user_1 = 0,
- add_user_2,
- remove_user_1,
- remove_user_2,
- switch_user_to_1,
- switch_user_to_2,
- switch_user_to_0,
- switch_wait,
-};
-
-using tud_ = test_user_data_cb_t;
-using ud_ = struct ud_ctrl_t<tud_, tud_, tud_, tud_, tud_, tud_, tud_, tud_>;
-
TEST(subsession_switch_user_wait, APISwitchUserStarted) {
- ud_ ud = { .loop = g_main_loop_new (NULL, FALSE),
- .t = std::tuple<tud_, tud_, tud_, tud_, tud_, tud_, tud_, tud_>(),
+ const int prologue_items = 4;
+ 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> {
+
+ 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_add_user_l<subsession_5001>( TestUserStr::user_1)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if add [ " + std::string(TestUserStr::user_1) + " ] is successful",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if add [ " + std::string(TestUserStr::user_1) + " ] callback is successful", },
+
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestUserStr::user_2)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if add [ " + std::string(TestUserStr::user_2) + " ] is successful",
+ .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_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", },
+ }
};
- std::apply([](auto &... args){( (init_user<tud_ &>(args) ), ...); }, ud.t );
-
- std::get<switch_wait>(ud.t).session_uid = -1;
- int switch_user_wait_res = subsession_register_event_callback(test_subsession_uid, SUBSESSION_SWITCH_USER_WAIT,
- test_subsession_switch_user_wait_callback, (void *)&std::get<switch_wait>(ud.t) );
+ loop_run_for_test(callback_pending<ud_prologue_t, api_call_res_t>, &prologue, prologue.loop);
+ summarize<prologue_items>(prologue.results);
- int add_user_res_1 = add_user_wrap<ud_, add_user_1>(TestUser::user_1, test_reply_callback_default, ud);
- int add_user_res_2 = add_user_wrap<ud_, add_user_2>(TestUser::user_2, test_reply_callback_default, ud);
+ const int action_items = 2;
+ using ud_t = ud_data_t<std::array<api_call_res_t, action_items>>;
- std::get<switch_user_to_1>(ud.t).prev_user_id = TestUser::user_1;
- std::get<switch_user_to_1>(ud.t).user_id = TestUser::user_1;
+ ud_t ud_data = { .loop = g_main_loop_new(NULL, FALSE),
+ .results = std::array<api_call_res_t, action_items> {
- int switch_user_res_to_1 = subsession_switch_user(test_subsession_uid, std::get<switch_user_to_1>(ud.t).user_id, test_reply_callback_default, (void *)&std::get<switch_user_to_1>(ud.t));
+ api_call_res_t{ .call_result = std::move(subsession_register_event_switch_user_l<subsession_5001>()),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if register switch user event is successful",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if register add user event callback is successful", },
- std::get<switch_user_to_2>(ud.t).prev_user_id = TestUser::user_1;
- std::get<switch_user_to_2>(ud.t).user_id = TestUser::user_2;
+ 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", },
+ }
+ };
- int switch_user_res_to_2 = subsession_switch_user(test_subsession_uid, std::get<switch_user_to_2>(ud.t).user_id, test_reply_callback_default, (void *)&std::get<switch_user_to_2>(ud.t));
+ loop_run_for_test(callback_pending<ud_t, api_call_res_t>, &ud_data, ud_data.loop);
+ summarize<action_items>(ud_data.results);
- std::get<switch_user_to_0>(ud.t).prev_user_id = TestUser::user_2;
- std::get<switch_user_to_0>(ud.t).user_id = TestUser::user_0;
- int switch_user_res_to_0 = subsession_switch_user(test_subsession_uid, std::get<switch_user_to_0>(ud.t).user_id, test_reply_callback_default, (void *)&std::get<switch_user_to_0>(ud.t));
+ int res = subsession_unregister_event_callback(subsession_5001::subsession_uid(), SUBSESSION_SWITCH_USER_WAIT);
+ EXPECT_EQ(res, SUBSESSION_ERROR_NONE);
- int remove_user_res_1 = remove_user_wrap<ud_, remove_user_1>(TestUser::user_1, test_reply_callback_default, ud);
- int remove_user_res_2 = remove_user_wrap<ud_, remove_user_2>(TestUser::user_2, test_reply_callback_default, ud);
- g_idle_add(callback_pending_ud<ud_>,(gpointer*)&ud);
- g_main_loop_run(ud.loop);
+ const int epilogue_items = 3;
+ 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> {
- EXPECT_EQ(switch_user_wait_res, 0);
- EXPECT_EQ(add_user_res_1, 0);
- EXPECT_EQ(remove_user_res_1, 0);
- EXPECT_EQ(switch_user_res_to_1, 0);
- EXPECT_EQ(switch_user_res_to_2, 0);
- EXPECT_EQ(switch_user_res_to_0, 0);
- EXPECT_EQ(add_user_res_2, 0);
- EXPECT_EQ(remove_user_res_2, 0);
+ 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", },
- EXPECT_EQ(0, std::get<add_user_1>(ud.t).callback_result);
- EXPECT_EQ(0, std::get<add_user_2>(ud.t).callback_result);
- EXPECT_EQ(0, std::get<switch_user_to_1>(ud.t).callback_result);
- EXPECT_EQ(0, std::get<switch_user_to_2>(ud.t).callback_result);
- EXPECT_EQ(0, std::get<switch_user_to_0>(ud.t).callback_result);
- EXPECT_EQ(0, std::get<remove_user_1>(ud.t).callback_result);
- EXPECT_EQ(0, std::get<remove_user_2>(ud.t).callback_result);
+ 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",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_1) + " ] callback is successful", },
+ api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestUserStr::user_2)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .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", },
+ }
+ };
- auto &user_data_result = std::get<switch_wait>(ud.t);
+ loop_run_for_test(callback_pending<ud_epilogue_t, api_call_res_t>, &epilogue, epilogue.loop);
+ summarize<epilogue_items>(epilogue.results);
- EXPECT_EQ(0, user_data_result.callback_result);
- EXPECT_EQ(user_data_result.session_uid, test_subsession_uid);
- EXPECT_EQ(user_data_result.user_id, TestUser::user_0);
- EXPECT_EQ(user_data_result.prev_user_id, TestUser::user_2);
}
// Test
-typedef struct {
- int callback_result;
- int session_id;
- int user_id;
-} test_user_data;
-
-
-typedef struct {
- int callback_result;
- int session_id;
- int prev_user_id;
- int next_user_id;
-} test_user_data_switch;
-
-typedef struct {
- GMainLoop * loop;
- test_user_data *user_data;
-}ud_ctrl;
-
-
-int callback_adduser_reference;
-int callback_removeuser_reference;
-int callback_switchuser_reference;
-
-const int test_session_id = 5001;
-
-gboolean callback_pending(gpointer data) {
-
- ud_ctrl *ud = (ud_ctrl*)data;
- gboolean is_pending = g_main_context_pending(NULL);
- gint callback_adduser_calls = g_atomic_int_get(&callback_adduser_reference);
- gint callback_removeuser_calls = g_atomic_int_get(&callback_removeuser_reference);
- gint callback_switchuser_calls = g_atomic_int_get(&callback_switchuser_reference);
-
- if(is_pending == TRUE) {
- return TRUE;
- }
-
- bool loop_quit_ready =
- (callback_adduser_calls >= 2) &&
- (callback_removeuser_calls >= 2) &&
- (callback_switchuser_calls >= 1) ;
-
- if(loop_quit_ready) {
- g_main_loop_quit((GMainLoop*)ud->loop);
- }
- return TRUE;
-}
-
-void test_reply_adduser_callback (int result, void *cb_data) {
-
- g_atomic_int_inc(&callback_adduser_reference);
-
- if (cb_data == NULL) {
- return;
- }
-
- test_user_data *user_data = (test_user_data *)cb_data;
- user_data->callback_result = result;
-}
-
-void test_reply_switchuser_callback (int result, void *cb_data) {
-
- g_atomic_int_inc(&callback_switchuser_reference);
-
- if (cb_data == NULL) {
- return;
- }
-
- test_user_data_switch *user_data = (test_user_data_switch *)cb_data;
- user_data->callback_result = result;
-}
-
-void test_reply_removeuser_callback (int result, void *cb_data) {
-
- g_atomic_int_inc(&callback_removeuser_reference);
-
- if (cb_data == NULL) {
- return;
- }
-
- test_user_data *user_data = (test_user_data *)cb_data;
- user_data->callback_result = result;
-}
+const int action_items = 15;
TEST(subsession_switch_user_test, APISwitchUserTest) {
- GMainLoop* loop = NULL;
- loop = g_main_loop_new (NULL, FALSE);
- g_atomic_int_set(&callback_adduser_reference, 0);
- g_atomic_int_set(&callback_switchuser_reference, 0);
- g_atomic_int_set(&callback_removeuser_reference, 0);
-
- test_user_data test_add_1_1;
- test_add_1_1.session_id = test_session_id;
- test_add_1_1.user_id = 1;
- test_add_1_1.callback_result = -1;
- int add_user_res_1_1 = subsession_add_user(test_add_1_1.session_id, test_add_1_1.user_id, test_reply_adduser_callback, (void *)&test_add_1_1);
-
- test_user_data test_add_1_2;
- test_add_1_2.session_id = test_session_id;
- test_add_1_2.user_id = 2;
- test_add_1_2.callback_result = -1;
- int add_user_res_1_2 = subsession_add_user(test_add_1_2.session_id, test_add_1_2.user_id, test_reply_adduser_callback, (void *)&test_add_1_2);
-
-
- test_user_data_switch test_switch_1_1_to_2;
- test_switch_1_1_to_2.session_id = test_session_id;
- test_switch_1_1_to_2.prev_user_id = 1;
- test_switch_1_1_to_2.next_user_id = 2;
- test_switch_1_1_to_2.callback_result = -1;
-
- int switch_user_res_1_1_to_2 = subsession_switch_user(test_switch_1_1_to_2.session_id,
- test_switch_1_1_to_2.next_user_id,
- test_reply_switchuser_callback, (void *)&test_switch_1_1_to_2);
-
- int got_current_user = 0;
-
- int get_curr_user_res = subsession_get_current_user(test_session_id, &got_current_user);
-
- test_user_data_switch test_switch_1_2_to_0;
- test_switch_1_2_to_0.session_id = test_session_id;
- test_switch_1_2_to_0.prev_user_id = 2;
- test_switch_1_2_to_0.next_user_id = 0;
- test_switch_1_2_to_0.callback_result = -1;
-
- int switch_user_res_1_2_to_0 = subsession_switch_user(test_switch_1_2_to_0.session_id,
- test_switch_1_2_to_0.next_user_id,
- test_reply_switchuser_callback, (void *)&test_switch_1_2_to_0);
-
- test_user_data test_remove_1_1;
- test_remove_1_1.session_id = test_session_id;
- test_remove_1_1.user_id = 1;
- test_remove_1_1.callback_result = -1;
- int remove_user_res_1_1 = subsession_remove_user(test_remove_1_1.session_id, test_remove_1_1.user_id, test_reply_removeuser_callback, (void *)&test_remove_1_1);
-
- test_user_data test_remove_1_2;
- test_remove_1_2.session_id = test_session_id;
- test_remove_1_2.user_id = 2;
- test_remove_1_2.callback_result = -1;
- int remove_user_res_1_2 = subsession_remove_user(test_remove_1_2.session_id, test_remove_1_2.user_id, test_reply_removeuser_callback, (void *)&test_remove_1_2);
-
- ud_ctrl ud;
- ud.loop = loop;
-
- g_idle_add(callback_pending,(gpointer*)&ud);
- g_main_loop_run(loop);
-
- EXPECT_EQ(add_user_res_1_1, 0);
- EXPECT_EQ(add_user_res_1_2, 0);
-
- EXPECT_EQ(switch_user_res_1_1_to_2, 0);
- EXPECT_EQ(switch_user_res_1_2_to_0, 0);
- EXPECT_EQ(switch_user_res_1_2_to_0, 0);
-
- EXPECT_EQ(remove_user_res_1_1, 0);
- EXPECT_EQ(remove_user_res_1_2, 0);
- EXPECT_EQ(get_curr_user_res, 0);
-
- EXPECT_EQ(got_current_user, 2);
-
- EXPECT_EQ(0, test_add_1_1.callback_result);
- EXPECT_EQ(0, test_add_1_2.callback_result);
- EXPECT_EQ(0, test_switch_1_1_to_2.callback_result);
- EXPECT_EQ(0, test_switch_1_2_to_0.callback_result);
- EXPECT_EQ(0, test_remove_1_1.callback_result);
- EXPECT_EQ(0, test_remove_1_2.callback_result);
+ 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),
+ .results = std::array<api_call_res_t, action_items> {
+
+ 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_add_user_l<subsession_5001>( TestUserStr::user_1)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if add [ " + std::string(TestUserStr::user_1) + " ] is successful",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if add " + std::string(TestUserStr::user_1) + " ] callback is successful", },
+
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestUserStr::user_2)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if add [ " + std::string(TestUserStr::user_2) + " ] is successful",
+ .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_l<subsession_5001>( TestUserStr::user_3)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if add [ " + std::string(TestUserStr::user_3) + " ] 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_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_get_current_user_l<subsession_5001>( TestUserStr::user_3)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if current [ " + std::string(TestUserStr::user_3) + " ] is successful",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if getting current user [" + std::string(TestUserStr::user_3) + " ] is done", },
+
+ 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_get_current_user_l<subsession_5001>( TestUserStr::user_2)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if current [ " + std::string(TestUserStr::user_2) + " ] is successful",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if getting current user [" + std::string(TestUserStr::user_3) + " ] is done", },
+
+ 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_get_current_user_l<subsession_5001>( TestUserStr::user_1)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if current [ " + std::string(TestUserStr::user_1) + " ] is successful",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if getting current user [" + std::string(TestUserStr::user_1) + " ] is done", },
+
+ 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", },
+
+ 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",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if remove [ " + std::string(TestUserStr::user_1) + " ] callback is successful", },
+
+ api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>(TestUserStr::user_2)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .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", },
+ }
+ };
+
+ loop_run_for_test(callback_pending<ud_t, api_call_res_t>, &ud_data, ud_data.loop);
+ summarize<action_items>(ud_data.results);
}
#include "sessiond.h"
#include "test_hlp.hpp"
-using tud_ = test_user_data_cb_t;
-using ud_switch_user_fail = struct ud_ctrl_t<tud_, tud_, tud_, tud_, tud_, tud_, tud_, tud_, tud_, tud_>;
-
-struct switch_user_fail {
- enum action {
- switch_user_0 = 0,
- switch_non_existing_user_1,
- switch_user_minus_1,
- add_user_1,
- add_user_2,
- switch_to_user_2,
- remove_switched_user_2,
- switch_to_user_0_again,
- remove_user_1,
- remove_user_2,
- action_items
- };
-};
+
+const int action_items = 11;
TEST(subsession_switch_user_test, FailAtSwitchUser) {
- ud_switch_user_fail ud = { .loop = g_main_loop_new(NULL, FALSE),
- .t = ud_switch_user_fail::the_tuple(),
+ 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),
+ .results = std::array<api_call_res_t, action_items> {
+ 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 non existing [ " + std::string(TestUserStr::user_1) + " ] returns no error",
+ .cb_expected = SUBSESSION_ERROR_NOT_AVAILABLE,
+ .cb_desc = "Check if switch to non existing [" + std::string(TestUserStr::user_1) + " ] callback returns error", },
+
+ 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 non existing [ " + std::string(TestUserStr::user_1) + " ] returns no error",
+ .cb_expected = SUBSESSION_ERROR_NOT_AVAILABLE,
+ .cb_desc = "Check if switch to non existing [" + std::string(TestUserStr::user_1) + " ] callback returns error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_switch_user_l<subsession_5001>( TestBadUserStr::bad_user_3)),
+ .expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .desc = "Check if switch to [ " + std::string(TestBadUserStr::bad_user_3) + " ] returns error",
+ .cb_expected = SUBSESSION_ERROR_INVALID_PARAMETER,
+ .cb_desc = "Check if switch to non existing [" + std::string(TestBadUserStr::bad_user_3) + " ] callback returns error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestUserStr::user_1)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if add [ " + std::string(TestUserStr::user_1) + " ] returns no error",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if add [" + std::string(TestUserStr::user_1) + " ] callback returns no error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_add_user_l<subsession_5001>( TestUserStr::user_2)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if add [ " + std::string(TestUserStr::user_2) + " ] returns no error",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if add [" + std::string(TestUserStr::user_2) + " ] callback returns no error", },
+
+ 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) + " ] returns no error",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_2) + " ] callback returns no error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestUserStr::user_2)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] again returns no error",
+ .cb_expected = SUBSESSION_ERROR_RESOURCE_BUSY,
+ .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_2) + " ] again callback returns error", },
+
+ 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) + " ] returns no error",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_0) + " ] callback returns no error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestUserStr::user_1)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if switch to [ " + std::string(TestUserStr::user_1) + " ] returns no error",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_1) + " ] callback returns no error", },
+
+ api_call_res_t{ .call_result = std::move(subsession_remove_user_l<subsession_5001>( TestUserStr::user_2)),
+ .expected = SUBSESSION_ERROR_NONE,
+ .desc = "Check if switch to [ " + std::string(TestUserStr::user_2) + " ] returns no error",
+ .cb_expected = SUBSESSION_ERROR_NONE,
+ .cb_desc = "Check if switch to [" + std::string(TestUserStr::user_2) + " ] callback returns no error", },
+ }
};
- std::apply([](auto &... args){( (init_user_s<tud_ &, subsession_5001>(args) ), ...); }, ud.t );
-
- std::array<res_t_cb, switch_user_fail::action_items> results {
- res_t_cb{ switch_user_wrap<ud_switch_user_fail, switch_user_fail::switch_user_0>(TestUser::user_0, test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if switching to user 0 returns no error" ,
- std::get<switch_user_fail::switch_user_0>(ud.t),
- SUBSESSION_ERROR_NONE, "Check if switching to user 0 returns no error in callback"},
-
- res_t_cb{ switch_user_wrap<ud_switch_user_fail, switch_user_fail::switch_non_existing_user_1>(TestUser::user_1, test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if switching non existing user 1 returns no error",
- std::get<switch_user_fail::switch_non_existing_user_1>(ud.t),
- SUBSESSION_ERROR_NOT_AVAILABLE, "Check if switching non existing user 1 returns error in callback"},
-
- res_t_cb{ switch_user_wrap<ud_switch_user_fail, switch_user_fail::switch_user_minus_1>( -(TestUser::user_1), test_reply_callback_default, ud),
- SUBSESSION_ERROR_INVALID_PARAMETER, "Check if switching to user -1 returns error",
- std::get<switch_user_fail::switch_user_minus_1>(ud.t),
- SUBSESSION_ERROR_INVALID_PARAMETER, "Check if switching user -1 returns error in callback"},
-
- res_t_cb{ add_user_wrap<ud_switch_user_fail, switch_user_fail::add_user_1>( TestUser::user_1, test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if adding user 1 returns no error",
- std::get<switch_user_fail::add_user_1>(ud.t),
- SUBSESSION_ERROR_NONE, "Check if adding user 1 returns no error in callback"},
-
- res_t_cb{ add_user_wrap<ud_switch_user_fail, switch_user_fail::add_user_2>( TestUser::user_2, test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if adding user 2 returns no error" ,
- std::get<switch_user_fail::add_user_2>(ud.t),
- SUBSESSION_ERROR_NONE, "Check if adding user 2 returns no error in callback"},
-
- res_t_cb{ switch_user_wrap<ud_switch_user_fail, switch_user_fail::switch_to_user_2>( TestUser::user_2, test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if switching to user 2 returns no error" ,
- std::get<switch_user_fail::switch_to_user_2>(ud.t),
- SUBSESSION_ERROR_NONE, "Check if switching to user 2 returns no error in callback"},
-
- res_t_cb{ remove_user_wrap<ud_switch_user_fail, switch_user_fail::remove_switched_user_2>( TestUser::user_2, test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if removing user 2 returns no error",
- std::get<switch_user_fail::remove_switched_user_2>(ud.t),
- SUBSESSION_ERROR_RESOURCE_BUSY, "Check if removing user 2 returns error in callback"},
-
- res_t_cb{ switch_user_wrap<ud_switch_user_fail, switch_user_fail::switch_to_user_0_again>( TestUser::user_0, test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if switching to user 0 returns no error",
- std::get<switch_user_fail::switch_to_user_0_again>(ud.t),
- SUBSESSION_ERROR_NONE, "Check if switching to user 0 returns no error in callback"},
-
- res_t_cb{ remove_user_wrap<ud_switch_user_fail, switch_user_fail::remove_user_1>( TestUser::user_1, test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if removing user 1 returns no error" ,
- std::get<switch_user_fail::remove_user_1>(ud.t),
- SUBSESSION_ERROR_NONE, "Check if removing user 1 returns no error in callback"},
-
- res_t_cb{ remove_user_wrap<ud_switch_user_fail, switch_user_fail::remove_user_2>( TestUser::user_2, test_reply_callback_default, ud),
- SUBSESSION_ERROR_NONE, "Check if removing user 2 returns no error",
- std::get<switch_user_fail::remove_user_2>(ud.t),
- SUBSESSION_ERROR_NONE, "Check if removing user 2 returns no error in callback"},
- };
-
- loop_run_for_test(callback_pending_ud<ud_switch_user_fail>,(gpointer*)&ud, ud.loop);
- summarize_results_cb<switch_user_fail::action_items>(results);
+ loop_run_for_test(callback_pending<ud_t, api_call_res_t>, &ud_data, ud_data.loop);
+ summarize<action_items>(ud_data.results);
}
#pragma once
#include <iostream>
+#include <memory>
#include <gio/gio.h>
#include <pthread.h>
};
};
+struct TestUserString {
+ static subsession_user_t constexpr user_0 = SUBSESSION_INITIAL_SID;
+ static subsession_user_t constexpr user_1 = "user_1";
+ static subsession_user_t constexpr user_2 = "user_2";
+};
+
+namespace TestUserStr {
+ [[maybe_unused]] static subsession_user_t user_0 = SUBSESSION_INITIAL_SID;
+ [[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";
+};
+
+namespace TestBadUserStr {
+ [[maybe_unused]] static subsession_user_t bad_user_0 = "/user_0";
+ [[maybe_unused]] static subsession_user_t bad_user_1 = "/bad_user_1";
+ [[maybe_unused]] static subsession_user_t bad_user_2 = "./user_2";
+ [[maybe_unused]] static subsession_user_t bad_user_3 = "user_3/user_3";
+ [[maybe_unused]] static subsession_user_t bad_user_empty = "";
+ [[maybe_unused]] static char bad_user_long[] = "too_long_user_name___";
+};
+
+
+static constexpr int MAGIC_ADD = 111;
+static constexpr int MAGIC_REMOVE = 222;
+static constexpr int MAGIC_SWITCH = 333;
+static constexpr int MAGIC_DEFAULT = 444;
+static constexpr int MAGIC_GET_CURRENT_USER = 444;
+static constexpr int MAGIC_EVENT_ADD = 555;
+static constexpr int MAGIC_EVENT_REMOVE = 777;
+static constexpr int MAGIC_EVENT_SWITCH = 888;
+static constexpr int MAGIC_EVENT_SWITCH_COMPLETION = 999;
+
const int got = 0;
const int expected = 1;
the_tuple t;
};
-typedef struct {
- int session_uid;
- int user_id;
- uint64_t switch_id;
- int callback_result;
- int callback_reference;
- int prev_user_id;
- subsession_event_type_e event;
- } test_user_data_cb_t;
+struct test_user_data_cb_t {
+ int session_uid{0};
+ char *user_id{nullptr};
+ uint64_t switch_id{0};
+ int callback_result{0};
+ int callback_reference{0};
+ char *prev_user_id{nullptr};
+ subsession_event_type_e event{ SUBSESSION_EVENT_ALL};
+ int magic{MAGIC_DEFAULT};
+};
+
typedef struct {
int session_uid;
int callback_reference{1};
- int *user_list{NULL};
+ subsession_user_t *user_list{NULL};
int user_count{0};
} test_get_user_list_res_t;
return;
}
+template<typename S>
+constexpr test_user_data_cb_t init_user_tud() {
+ test_user_data_cb_t tud{0};
+ tud.session_uid = S::subsession_uid();
+ tud.user_id = nullptr;
+ tud.callback_result = SUBSESSION_ERROR_INVALID_PARAMETER;
+ tud.event = SUBSESSION_EVENT_ALL;
+ tud.prev_user_id = nullptr;
+ tud.switch_id = -1;
+ tud.magic = 0;
+ _set_0(&tud.callback_reference);
+ return tud;
+}
+/*
template<typename T>
void init_user(T arg);
arg.switch_id = -1;
_set_0(&arg.callback_reference);
}
-
+*/
struct subsession_5001 {
static int constexpr subsession_uid() { return 5001; };
};
template<typename T = test_user_data_cb_t& , typename S>
void init_user_s(test_user_data_cb_t& arg) {
arg.session_uid = S::subsession_uid();
- arg.user_id = -1;
+ arg.user_id =nullptr;
arg.callback_result = TIZEN_ERROR_INVALID_PARAMETER;
arg.event = SUBSESSION_EVENT_ALL;
- arg.prev_user_id = -1;
+ arg.prev_user_id = nullptr;
arg.switch_id = -1;
_set_0(&arg.callback_reference);
+ arg.magic=MAGIC_DEFAULT;
}
+
+
template<typename T = test_get_user_list_res_t& , typename S>
void init_user_s(test_get_user_list_res_t& arg) {
arg.session_uid = S::subsession_uid();
arg.user_list = NULL;
}
+
+
/*
template<typename T = test_user_data_cb_t, typename S>
void init_user_s(test_user_data_cb_t& arg) {
_set_0(&arg.callback_reference);
}
*/
-/*
+
template<typename T, typename... V>
void atomic_set_0(T arg, V... args) {
_set_0(arg);
atomic_set_0(args...);
return;
}
-*/
+
/* Magic constants set by various callbacks
* to verify whether they were called. */
-static constexpr int MAGIC_ADD = 111;
-static constexpr int MAGIC_REMOVE = 222;
-static constexpr int MAGIC_SWITCH = 333;
-static constexpr int MAGIC_DEFAULT = 444;
+
void test_reply_callback_default (int result, void *cb_data) {
+ //std::cout << "call callback default" << std::endl;
test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
user_data->callback_result = result;
+
+ //std::cout << "call_callback_default for magic: " << user_data->magic << " get ref :" << g_atomic_int_get(&user_data->callback_reference) <<std::endl;
g_atomic_int_inc(&user_data->callback_reference);
}
test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
- if (cb_data == NULL)
+ if (cb_data == NULL) {
+ std::cout << "test_event_add_user_callback == null";
return;
+ }
user_data->session_uid = info.session_uid;
+ //std::cout << "on callback: user_data->session_uid: " << user_data->session_uid << std::endl;
user_data->event = info.event;
+ //std::cout << "on callback: user_data->event: " << user_data->event << std::endl;
user_data->user_id = info.add_user.user;
-
+ //std::cout << "on callback:user_data->user_id: " << user_data->user_id << std::endl;
+ //std::cout << "go to subsession_event_wait_done(info)" << std::endl;
user_data->callback_result = subsession_event_wait_done(info);
+ //std::cout << "on callback: user_data->callback_result: " << user_data->callback_result << std::endl;
g_atomic_int_inc(&user_data->callback_reference);
}
+
void test_event_remove_user_callback(subsession_event_info info, void *cb_data) {
test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
g_atomic_int_inc(&user_data->callback_reference);
}
+
+void test_event_switch_user_completion_callback(subsession_event_info info, void *cb_data) {
+
+ test_user_data_cb_t *user_data = (test_user_data_cb_t *)cb_data;
+
+ if (cb_data == NULL)
+ return;
+
+ user_data->session_uid = info.session_uid;
+ user_data->event = info.event;
+ user_data->user_id = info.switch_user.next_user;
+ user_data->switch_id = info.switch_user.switch_id;
+ user_data->callback_result = SUBSESSION_ERROR_NONE;
+ g_atomic_int_inc(&user_data->callback_reference);
+}
+
+
+using expected_error = int;
+using api_result = int;
+using tud_ = test_user_data_cb_t;
+
+
+//using api_call_res = std::tuple<tud_, api_result>; //, expected_error, std::string, int, std::string>;
+//using res_t_cbx = std::tuple<api_call_res, int>; //, expected_error, std::string, int, std::string>;
+
+using res_t_cb = std::tuple<int, int, std::string, test_user_data_cb_t&, int, std::string>;
+
+using res_t = std::tuple<int, int, std::string>;
+
+struct api_call_res_t {
+ std::shared_ptr<std::pair<tud_, int>> call_result;
+ int expected{0};
+ std::string desc{};
+ int cb_expected{0};
+ std::string cb_desc{};
+};
+
+struct api_register_only_res_t {
+ std::shared_ptr<std::pair<tud_, int>> call_result;
+ int expected{0};
+ std::string desc{};
+};
+
template<typename T>
+struct ud_data_t {
+ GMainLoop * loop;
+ T results;
+};
+
+template<typename T>
+auto callback_reference_value = [] (T& t) -> int {
+ return 0;
+};
+
+template<>
+auto callback_reference_value<api_call_res_t> = [](api_call_res_t& t) -> int {
+ return g_atomic_int_get(&t.call_result->first.callback_reference);
+};
+
+template<>
+auto callback_reference_value<api_register_only_res_t> = [](api_register_only_res_t& t) -> int {
+ return g_atomic_int_get(&t.call_result->first.callback_reference);
+};
+
+template<typename T, typename S>
gboolean callback_pending(gpointer data) {
T *ud = static_cast<T *>(data);
- gboolean is_pending = g_main_context_pending(NULL);
+ auto results = ud->results;
+ gboolean is_pending = g_main_context_pending(NULL);
if(is_pending == TRUE) {
return TRUE;
}
- auto loop_quit_ready = std::apply([](auto... args){
- return ( ( _atomic_int_get(args)>=1 ) && ... );
- }, ud->t);
-
- if(loop_quit_ready) {
- g_main_loop_quit((GMainLoop*)ud->loop);
+ if ( std::all_of(results.begin(), results.end(), callback_reference_value<S>) ) {
+ g_main_loop_quit(ud->loop);
}
return TRUE;
}
+int pass_cb_if_err(int res, int *cb_reference){
+ if(res != SUBSESSION_ERROR_NONE) { g_atomic_int_inc(cb_reference); }
+ return res;
+}
+
+template<typename S>
+auto subsession_add_user_l = [](char * user_id) {
+
+ std::shared_ptr<std::pair<tud_, int>> p = std::make_shared<std::pair<tud_, int>>(init_user_tud<S>(), 0);
+ p->first.magic = MAGIC_ADD;
+ int res = subsession_add_user(p->first.session_uid, user_id, test_reply_callback_default, (void *)&p->first);
+ p->second = pass_cb_if_err(res, &p->first.callback_reference);
+ return p;
+};
+
+template<typename S>
+auto subsession_remove_user_l = [](char * user_id){
+ std::shared_ptr<std::pair<tud_, int>> p = std::make_shared<std::pair<tud_, int>>(init_user_tud<S>(), 0);
+ p->first.magic = MAGIC_REMOVE;
+ int res = subsession_remove_user(p->first.session_uid, user_id, test_reply_callback_default, (void *)&p->first);
+ p->second = pass_cb_if_err(res, &p->first.callback_reference);
+ return p;
+};
+
+template<typename S>
+auto subsession_switch_user_l = [](char * user_id){
+ std::shared_ptr<std::pair<tud_, int>> p = std::make_shared<std::pair<tud_, int>>(init_user_tud<S>(), 0);
+ p->first.magic = MAGIC_SWITCH;
+ int res = subsession_switch_user(p->first.session_uid, user_id, test_reply_callback_default, (void *)&p->first);
+ p->second = pass_cb_if_err(res, &p->first.callback_reference);
+ return p;
+};
+
+template<typename S, bool cb_pass = false>
+auto subsession_register_event_add_user_l = [](){
+ std::shared_ptr<std::pair<tud_, int>> p = std::make_shared<std::pair<tud_, int>>(init_user_tud<S>(), 0);
+ p->first.magic = MAGIC_EVENT_ADD;
+ int res = subsession_register_event_callback(p->first.session_uid, SUBSESSION_ADD_USER_WAIT, test_event_add_user_callback, (void *)&p->first);
+ if(res != SUBSESSION_ERROR_NONE || cb_pass) { g_atomic_int_inc( &p->first.callback_reference); }
+ p->second = res;
+ return p;
+};
+
+template<typename S, bool cb_pass = false>
+auto subsession_unregister_event_add_user_l = [](){
+ std::shared_ptr<std::pair<tud_, int>> p = std::make_shared<std::pair<tud_, int>>(init_user_tud<S>(), 0);
+ p->first.magic = MAGIC_EVENT_ADD;
+ int res = subsession_unregister_event_callback(p->first.session_uid, SUBSESSION_ADD_USER_WAIT);
+ if(res != SUBSESSION_ERROR_NONE || cb_pass) { g_atomic_int_inc( &p->first.callback_reference); }
+ p->second = res;
+ return p;
+};
+
+template<typename S, bool cb_pass = false>
+auto subsession_register_event_remove_user_l = [](){
+ std::shared_ptr<std::pair<tud_, int>> p = std::make_shared<std::pair<tud_, int>>(init_user_tud<S>(), 0);
+ p->first.magic = MAGIC_EVENT_REMOVE;
+ int res = subsession_register_event_callback(p->first.session_uid, SUBSESSION_REMOVE_USER_WAIT, test_event_remove_user_callback, (void *)&p->first);
+ if(res != SUBSESSION_ERROR_NONE || cb_pass) { g_atomic_int_inc( &p->first.callback_reference); }
+ p->second = res;
+ return p;
+};
+
+template<typename S, bool cb_pass = false>
+auto subsession_register_event_switch_user_l = [](){
+ std::shared_ptr<std::pair<tud_, int>> p = std::make_shared<std::pair<tud_, int>>(init_user_tud<S>(), 0);
+ p->first.magic = MAGIC_EVENT_SWITCH;
+ int res = subsession_register_event_callback(p->first.session_uid, SUBSESSION_SWITCH_USER_WAIT, test_event_switch_user_callback, (void *)&p->first);
+ if(res != SUBSESSION_ERROR_NONE || cb_pass) { g_atomic_int_inc( &p->first.callback_reference); }
+ p->second = res;
+ return p;
+};
+
+
+template<typename S, bool cb_pass = false>
+auto subsession_register_event_switch_user_completion_l = [](){
+ std::shared_ptr<std::pair<tud_, int>> p = std::make_shared<std::pair<tud_, int>>(init_user_tud<S>(), 0);
+ p->first.magic = MAGIC_EVENT_SWITCH_COMPLETION;
+ int res = subsession_register_event_callback(p->first.session_uid, SUBSESSION_SWITCH_USER_COMPLETION, test_event_switch_user_completion_callback, (void *)&p->first);
+ if(res != SUBSESSION_ERROR_NONE || cb_pass) { g_atomic_int_inc( &p->first.callback_reference); }
+ p->second = res;
+ return p;
+};
+
+
+template<typename S>
+auto subsession_get_current_user_l = [](char * user_id){
+ std::shared_ptr<std::pair<tud_, int>> p = std::make_shared<std::pair<tud_, int>>(init_user_tud<S>(), 0);
+ p->first.magic = MAGIC_EVENT_SWITCH_COMPLETION;
+ subsession_user_t got_test_user{0};
+ int func_res = subsession_get_current_user(p->first.session_uid, got_test_user);
+ int res = SUBSESSION_ERROR_INVALID_PARAMETER;
+ int compare = std::string(user_id).compare(std::string(got_test_user));
+ if(func_res == SUBSESSION_ERROR_NONE && compare == 0) {
+ res = SUBSESSION_ERROR_NONE;
+ }
+ g_atomic_int_inc(&p->first.callback_reference);
+ p->second = res;
+ return p;
+};
+
template<typename T>
gboolean callback_pending_ud (gpointer data) {
}
template<typename T, int N>
-int add_user_wrap(int user_id, subsession_reply_callback cb, T &ud) {
+int add_user_wrap(char * user_id, subsession_reply_callback cb, T &ud) {
std::get<N>(ud.t).user_id = user_id;
int res = subsession_add_user(test_subsession_uid, std::get<N>(ud.t).user_id,
}
template<typename T, int N>
-int remove_user_wrap(int user_id, subsession_reply_callback cb, T &ud) {
+int remove_user_wrap(char* user_id, subsession_reply_callback cb, T &ud) {
std::get<N>(ud.t).user_id = user_id;
int res = subsession_remove_user(test_subsession_uid, std::get<N>(ud.t).user_id,
}
template<typename T, int N>
-int switch_user_wrap(int user_id, subsession_reply_callback cb, T &ud) {
+int switch_user_wrap(char* user_id, subsession_reply_callback cb, T &ud) {
std::get<N>(ud.t).user_id = user_id;
int res = subsession_switch_user(test_subsession_uid, std::get<N>(ud.t).user_id,
return res;
}
-
template<typename T, int N, bool cb_pass = false>
int unregister_event_wrap(subsession_event_type_e event_bits, subsession_event_callback cb, T &ud) {
g_main_loop_unref(loop);
}
-using res_t = std::tuple<int, int, std::string>;
+//using res_t = std::tuple<int, int, std::string>;
-using res_t_cb = std::tuple<int, int, std::string, test_user_data_cb_t&, int, std::string>;
template<int N>
void summarize_results(std::array<res_t, N> &results) {
EXPECT_EQ(std::get<cb_expected>(res), std::get<cb_got>(res).callback_result);
});
}
+
+template<int N>
+void summarize(std::array<api_call_res_t, N> &results) {
+ std::for_each(results.begin(), results.end(), [=](api_call_res_t &res) {
+ std::cout << head_ << res.desc << std::endl;
+ EXPECT_EQ(res.expected, res.call_result->second);
+ std::cout << head_ << res.cb_desc << std::endl;
+ EXPECT_EQ(res.cb_expected, res.call_result->first.callback_result);
+ });
+}
+
+template<int N>
+void summarize_no_cb(std::array<api_register_only_res_t, N> &results) {
+ std::for_each(results.begin(), results.end(), [=](api_register_only_res_t &res) {
+ std::cout << head_ << res.desc << std::endl;
+ EXPECT_EQ(res.expected, res.call_result->second);
+ });
+}
Group: Development/Libraries
%description -n libsessiond-tests
-%package -n subsession-client-example
-Summary: Example program using libsessiond API
-Group: Development/Libraries
-%description -n subsession-client-example
+#%package -n subsession-client-example
+#Summary: Example program using libsessiond API
+#Group: Development/Libraries
+#%description -n subsession-client-example
%prep
%setup -q
%license LICENSE.MIT
%{_bindir}/test_*
-%files -n subsession-client-example
-%manifest sessiond.manifest
-%license LICENSE.MIT
-%{_bindir}/subsession-client-example
+#%files -n subsession-client-example
+#%manifest sessiond.manifest
+#%license LICENSE.MIT
+#%{_bindir}/subsession-client-example
projects / platform / core / system / sessiond.git / commitdiff