devs/cproof
1
2
Fork 1
Code Issues 43 Pull Requests 6 Actions Packages Projects 1 Releases Wiki Activity

Revert "Apply coding style"

Browse Source 
This reverts commit 9b55f2dec0.

Sorting the includes creates some problems.
This commit is contained in:
Michael Vetter
2020-07-07 13:53:30 +02:00
parent 28fde3cd01
commit a4cadf78fa
214 changed files with 17576 additions and 19566 deletions
Download Patch File Download Diff File Expand all files Collapse all files

227
tests/unittests/config/stub_accounts.c
View File

@@ -1,314 +1,207 @@
#include <cmocka.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include "common.h"
#include "config/account.h"
void
accounts_load(void)
{
}
void
accounts_close(void)
{
}
void accounts_load(void) {}
void accounts_close(void) {}
char*
accounts_find_all(char* prefix)
char * accounts_find_all(char *prefix)
{
return NULL;
}
char*
accounts_find_enabled(char* prefix, void* context)
char * accounts_find_enabled(char *prefix, void *context)
{
return NULL;
}
void
accounts_reset_all_search(void)
{
}
void
accounts_reset_enabled_search(void)
{
}
void accounts_reset_all_search(void) {}
void accounts_reset_enabled_search(void) {}
void
accounts_add(const char* jid, const char* altdomain, const int port)
void accounts_add(const char *jid, const char *altdomain, const int port)
{
check_expected(jid);
check_expected(altdomain);
check_expected(port);
}
int
accounts_remove(const char* jid)
int accounts_remove(const char *jid)
{
return 0;
}
gchar**
accounts_get_list(void)
gchar** accounts_get_list(void)
{
return mock_ptr_type(gchar**);
return mock_ptr_type(gchar **);
}
ProfAccount*
accounts_get_account(const char* const name)
ProfAccount* accounts_get_account(const char * const name)
{
check_expected(name);
return mock_ptr_type(ProfAccount*);
}
gboolean
accounts_enable(const char* const name)
gboolean accounts_enable(const char * const name)
{
check_expected(name);
return mock_type(gboolean);
}
gboolean
accounts_disable(const char* const name)
gboolean accounts_disable(const char * const name)
{
check_expected(name);
return mock_type(gboolean);
}
gboolean
accounts_rename(const char* const account_name,
const char* const new_name)
gboolean accounts_rename(const char * const account_name,
const char * const new_name)
{
check_expected(account_name);
check_expected(new_name);
return mock_type(gboolean);
}
gboolean
accounts_account_exists(const char* const account_name)
gboolean accounts_account_exists(const char * const account_name)
{
check_expected(account_name);
return mock_type(gboolean);
}
void
accounts_set_jid(const char* const account_name, const char* const value)
void accounts_set_jid(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_server(const char* const account_name, const char* const value)
void accounts_set_server(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_port(const char* const account_name, const int value)
{
}
void accounts_set_port(const char * const account_name, const int value) {}
void
accounts_set_resource(const char* const account_name, const char* const value)
void accounts_set_resource(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_password(const char* const account_name, const char* const value)
void accounts_set_password(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_eval_password(const char* const account_name, const char* const value)
void accounts_set_eval_password(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_muc_service(const char* const account_name, const char* const value)
void accounts_set_muc_service(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_muc_nick(const char* const account_name, const char* const value)
void accounts_set_muc_nick(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_otr_policy(const char* const account_name, const char* const value)
void accounts_set_otr_policy(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_last_presence(const char* const account_name, const char* const value)
{
}
void
accounts_set_last_status(const char* const account_name, const char* const value)
{
}
void
accounts_set_last_activity(const char* const account_name)
{
}
void
accounts_set_pgp_keyid(const char* const account_name, const char* const value)
{
}
void
accounts_set_script_start(const char* const account_name, const char* const value)
{
}
void
accounts_set_theme(const char* const account_name, const char* const value)
{
}
void
accounts_set_tls_policy(const char* const account_name, const char* const value)
{
}
void
accounts_set_auth_policy(const char* const account_name, const char* const value)
{
}
void accounts_set_last_presence(const char * const account_name, const char * const value) {}
void accounts_set_last_status(const char * const account_name, const char * const value) {}
void accounts_set_last_activity(const char * const account_name) {}
void accounts_set_pgp_keyid(const char * const account_name, const char * const value) {}
void accounts_set_script_start(const char * const account_name, const char * const value) {}
void accounts_set_theme(const char * const account_name, const char * const value) {}
void accounts_set_tls_policy(const char * const account_name, const char * const value) {}
void accounts_set_auth_policy(const char * const account_name, const char * const value) {}
void
accounts_set_login_presence(const char* const account_name, const char* const value)
void accounts_set_login_presence(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
resource_presence_t
accounts_get_login_presence(const char* const account_name)
resource_presence_t accounts_get_login_presence(const char * const account_name)
{
return RESOURCE_ONLINE;
}
char*
accounts_get_last_status(const char* const account_name)
char * accounts_get_last_status(const char * const account_name)
{
return NULL;
}
resource_presence_t
accounts_get_last_presence(const char* const account_name)
resource_presence_t accounts_get_last_presence(const char * const account_name)
{
check_expected(account_name);
return mock_type(resource_presence_t);
}
void
accounts_set_priority_online(const char* const account_name, const gint value)
void accounts_set_priority_online(const char * const account_name, const gint value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_priority_chat(const char* const account_name, const gint value)
void accounts_set_priority_chat(const char * const account_name, const gint value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_priority_away(const char* const account_name, const gint value)
void accounts_set_priority_away(const char * const account_name, const gint value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_priority_xa(const char* const account_name, const gint value)
void accounts_set_priority_xa(const char * const account_name, const gint value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_priority_dnd(const char* const account_name, const gint value)
void accounts_set_priority_dnd(const char * const account_name, const gint value)
{
check_expected(account_name);
check_expected(value);
}
void
accounts_set_priority_all(const char* const account_name, const gint value)
{
}
gint
accounts_get_priority_for_presence_type(const char* const account_name,
resource_presence_t presence_type)
void accounts_set_priority_all(const char * const account_name, const gint value) {}
gint accounts_get_priority_for_presence_type(const char * const account_name,
resource_presence_t presence_type)
{
return 0;
}
void
accounts_clear_password(const char* const account_name)
{
}
void
accounts_clear_eval_password(const char* const account_name)
{
}
void
accounts_clear_server(const char* const account_name)
{
}
void
accounts_clear_port(const char* const account_name)
{
}
void
accounts_clear_otr(const char* const account_name)
{
}
void
accounts_clear_pgp_keyid(const char* const account_name)
{
}
void
accounts_clear_script_start(const char* const account_name)
{
}
void
accounts_clear_theme(const char* const account_name)
{
}
void
accounts_clear_muc(const char* const account_name)
{
}
void
accounts_clear_resource(const char* const account_name)
{
}
void
accounts_add_otr_policy(const char* const account_name, const char* const contact_jid, const char* const policy)
{
}
char*
accounts_get_last_activity(const char* const account_name)
void accounts_clear_password(const char * const account_name) {}
void accounts_clear_eval_password(const char * const account_name) {}
void accounts_clear_server(const char * const account_name) {}
void accounts_clear_port(const char * const account_name) {}
void accounts_clear_otr(const char * const account_name) {}
void accounts_clear_pgp_keyid(const char * const account_name) {}
void accounts_clear_script_start(const char * const account_name) {}
void accounts_clear_theme(const char * const account_name) {}
void accounts_clear_muc(const char * const account_name) {}
void accounts_clear_resource(const char * const account_name) {}
void accounts_add_otr_policy(const char * const account_name, const char * const contact_jid, const char * const policy) {}
char* accounts_get_last_activity(const char *const account_name)
{
return NULL;
}
void
accounts_add_omemo_state(const char* const account_name, const char* const contact_jid, gboolean enabled)
{
}
void accounts_add_omemo_state(const char *const account_name, const char *const contact_jid, gboolean enabled) {}

33
tests/unittests/database/stub_database.c
View File

@@ -20,34 +20,15 @@
*
*/
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <cmocka.h>
#include "database.h"
gboolean
log_database_init(ProfAccount* account)
{
return TRUE;
}
void
log_database_add_incoming(ProfMessage* message)
{
}
void
log_database_add_outgoing_chat(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc)
{
}
void
log_database_add_outgoing_muc(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc)
{
}
void
log_database_add_outgoing_muc_pm(const char* const id, const char* const barejid, const char* const message, const char* const replace_id, prof_enc_t enc)
{
}
void
log_database_close(void)
{
}
gboolean log_database_init(ProfAccount *account) { return TRUE; }
void log_database_add_incoming(ProfMessage *message) {}
void log_database_add_outgoing_chat(const char * const id, const char * const barejid, const char * const message, const char *const replace_id, prof_enc_t enc) {}
void log_database_add_outgoing_muc(const char * const id, const char * const barejid, const char * const message, const char *const replace_id, prof_enc_t enc) {}
void log_database_add_outgoing_muc_pm(const char * const id, const char * const barejid, const char * const message, const char *const replace_id, prof_enc_t enc) {}
void log_database_close(void) {}

56
tests/unittests/helpers.c
View File

@@ -1,19 +1,18 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <cmocka.h>
#include <glib.h>
#include <stdio.h>
#include <unistd.h>
#include "common.h"
#include "config/preferences.h"
#include "helpers.h"
#include "config/preferences.h"
#include "xmpp/chat_session.h"
void
create_config_dir(void** state)
void create_config_dir(void **state)
{
setenv("XDG_CONFIG_HOME", "./tests/files/xdg_config_home", 1);
if (!mkdir_recursive("./tests/files/xdg_config_home/profanity")) {
@@ -21,15 +20,13 @@ create_config_dir(void** state)
}
}
void
remove_config_dir(void** state)
void remove_config_dir(void **state)
{
rmdir("./tests/files/xdg_config_home/profanity");
rmdir("./tests/files/xdg_config_home");
}
void
create_data_dir(void** state)
void create_data_dir(void **state)
{
setenv("XDG_DATA_HOME", "./tests/files/xdg_data_home", 1);
if (!mkdir_recursive("./tests/files/xdg_data_home/profanity")) {
@@ -37,26 +34,23 @@ create_data_dir(void** state)
}
}
void
remove_data_dir(void** state)
void remove_data_dir(void **state)
{
rmdir("./tests/files/xdg_data_home/profanity");
rmdir("./tests/files/xdg_data_home");
}
void
load_preferences(void** state)
void load_preferences(void **state)
{
create_config_dir(state);
FILE* f = fopen("./tests/files/xdg_config_home/profanity/profrc", "ab+");
FILE *f = fopen("./tests/files/xdg_config_home/profanity/profrc", "ab+");
if (f) {
prefs_load(NULL);
}
fclose(f);
}
void
close_preferences(void** state)
void close_preferences(void **state)
{
prefs_close();
remove("./tests/files/xdg_config_home/profanity/profrc");
@@ -64,29 +58,27 @@ close_preferences(void** state)
rmdir("./tests/files");
}
void
init_chat_sessions(void** state)
void init_chat_sessions(void **state)
{
load_preferences(NULL);
chat_sessions_init();
}
void
close_chat_sessions(void** state)
void close_chat_sessions(void **state)
{
chat_sessions_clear();
close_preferences(NULL);
}
int
utf8_pos_to_col(char* str, int utf8_pos)
utf8_pos_to_col(char *str, int utf8_pos)
{
int col = 0;
int i = 0;
for (i = 0; i < utf8_pos; i++) {
for (i = 0; i<utf8_pos; i++) {
col++;
gchar* ch = g_utf8_offset_to_pointer(str, i);
gchar *ch = g_utf8_offset_to_pointer(str, i);
gunichar uni = g_utf8_get_char(ch);
if (g_unichar_iswide(uni)) {
col++;
@@ -105,22 +97,22 @@ glist_set_cmp(GCompareFunc func)
}
int
glist_contents_equal(const void* actual, const void* expected)
glist_contents_equal(const void *actual, const void *expected)
{
GList* ac = (GList*)actual;
GList* ex = (GList*)expected;
GList *ac = (GList *)actual;
GList *ex = (GList *)expected;
GList* p = ex;
GList *p = ex;
printf("\nExpected\n");
while (ex) {
while(ex) {
printf("\n\n%s\n", (char*)p->data);
ex = g_list_next(ex);
}
printf("\n\n");
p = ac;
printf("\nActual\n");
while (ac) {
printf("\n\n%s\n", (char*)p->data);
while(ac) {
printf("\n\n%s\n", (char *)p->data);
ac = g_list_next(ac);
}
printf("\n\n");
@@ -129,7 +121,7 @@ glist_contents_equal(const void* actual, const void* expected)
return 0;
}
GList* ex_curr = ex;
GList *ex_curr = ex;
while (ex_curr != NULL) {
if (g_list_find_custom(ac, ex_curr->data, cmp_func) == NULL) {
return 0;

12
tests/unittests/helpers.h
View File

@@ -1,12 +1,12 @@
#include "glib.h"
void load_preferences(void** state);
void close_preferences(void** state);
void load_preferences(void **state);
void close_preferences(void **state);
void init_chat_sessions(void** state);
void close_chat_sessions(void** state);
void init_chat_sessions(void **state);
void close_chat_sessions(void **state);
int utf8_pos_to_col(char* str, int utf8_pos);
int utf8_pos_to_col(char *str, int utf8_pos);
void glist_set_cmp(GCompareFunc func);
int glist_contents_equal(const void* actual, const void* expected);
int glist_contents_equal(const void *actual, const void *expected);

145
tests/unittests/log/stub_log.c
View File

@@ -20,137 +20,56 @@
*
*/
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <cmocka.h>
#include "log.h"
void
log_init(log_level_t filter, char* log_file)
{
}
log_level_t
log_get_filter(void)
void log_init(log_level_t filter, char *log_file) {}
log_level_t log_get_filter(void)
{
return mock_type(log_level_t);
}
void
log_reinit(void)
{
}
void
log_close(void)
{
}
void
log_debug(const char* const msg, ...)
{
}
void
log_info(const char* const msg, ...)
{
}
void
log_warning(const char* const msg, ...)
{
}
void
log_error(const char* const msg, ...)
{
}
void
log_msg(log_level_t level, const char* const area, const char* const msg)
void log_reinit(void) {}
void log_close(void) {}
void log_debug(const char * const msg, ...) {}
void log_info(const char * const msg, ...) {}
void log_warning(const char * const msg, ...) {}
void log_error(const char * const msg, ...) {}
void log_msg(log_level_t level, const char * const area, const char * const msg) {}
const char * get_log_file_location(void)
{
return mock_ptr_type(char *);
}
const char*
get_log_file_location(void)
{
return mock_ptr_type(char*);
}
log_level_t
log_level_from_string(char* log_level)
log_level_t log_level_from_string(char *log_level)
{
return mock_type(log_level_t);
}
void
log_stderr_init(log_level_t level)
{
}
void
log_stderr_close(void)
{
}
void
log_stderr_handler(void)
{
}
void log_stderr_init(log_level_t level) {}
void log_stderr_close(void) {}
void log_stderr_handler(void) {}
void
chat_log_init(void)
{
}
void chat_log_init(void) {}
void
chat_log_msg_out(const char* const barejid, const char* const msg, const char* const resource)
{
}
void
chat_log_otr_msg_out(const char* const barejid, const char* const msg, const char* const resource)
{
}
void
chat_log_pgp_msg_out(const char* const barejid, const char* const msg, const char* const resource)
{
}
void
chat_log_omemo_msg_out(const char* const barejid, const char* const msg, const char* const resource)
{
}
void chat_log_msg_out(const char * const barejid, const char * const msg, const char *const resource) {}
void chat_log_otr_msg_out(const char * const barejid, const char * const msg, const char *const resource) {}
void chat_log_pgp_msg_out(const char * const barejid, const char * const msg, const char *const resource) {}
void chat_log_omemo_msg_out(const char *const barejid, const char *const msg, const char *const resource) {}
void
chat_log_msg_in(ProfMessage* message)
{
}
void
chat_log_otr_msg_in(ProfMessage* message)
{
}
void
chat_log_pgp_msg_in(ProfMessage* message)
{
}
void
chat_log_omemo_msg_in(ProfMessage* message)
{
}
void chat_log_msg_in(ProfMessage *message) {}
void chat_log_otr_msg_in(ProfMessage *message) {}
void chat_log_pgp_msg_in(ProfMessage *message) {}
void chat_log_omemo_msg_in(ProfMessage *message) {}
void
chat_log_close(void)
{
}
void chat_log_close(void) {}
void
groupchat_log_init(void)
{
}
void
groupchat_log_msg_in(const gchar* const room, const gchar* const nick, const gchar* const msg)
{
}
void
groupchat_log_msg_out(const gchar* const room, const gchar* const msg)
{
}
void
groupchat_log_omemo_msg_in(const gchar* const room, const gchar* const nick, const gchar* const msg)
{
}
void
groupchat_log_omemo_msg_out(const gchar* const room, const gchar* const msg)
{
}
void groupchat_log_init(void) {}
void groupchat_log_msg_in(const gchar *const room, const gchar *const nick, const gchar *const msg) {}
void groupchat_log_msg_out(const gchar *const room, const gchar *const msg) {}
void groupchat_log_omemo_msg_in(const gchar *const room, const gchar *const nick, const gchar *const msg) {}
void groupchat_log_omemo_msg_out(const gchar *const room, const gchar *const msg) {}

85
tests/unittests/omemo/stub_omemo.c
View File

@@ -3,51 +3,39 @@
#include "config/account.h"
#include "ui/ui.h"
void
omemo_init(void)
{
}
void
omemo_close(void)
{
}
void omemo_init(void) {}
void omemo_close(void) {}
char*
omemo_fingerprint_autocomplete(const char* const search_str, gboolean previous)
omemo_fingerprint_autocomplete(const char *const search_str, gboolean previous)
{
return NULL;
}
void
omemo_fingerprint_autocomplete_reset(void)
{
}
void omemo_fingerprint_autocomplete_reset(void) {}
char*
omemo_format_fingerprint(const char* const fingerprint)
char *
omemo_format_fingerprint(const char *const fingerprint)
{
return NULL;
}
void
omemo_generate_crypto_materials(ProfAccount* account)
{
}
void omemo_generate_crypto_materials(ProfAccount *account) {}
gboolean
omemo_automatic_start(const char* const jid)
omemo_automatic_start(const char *const jid)
{
return TRUE;
}
gboolean
omemo_is_trusted_identity(const char* const jid, const char* const fingerprint)
omemo_is_trusted_identity(const char *const jid, const char *const fingerprint)
{
return TRUE;
}
GList*
omemo_known_device_identities(const char* const jid)
GList *
omemo_known_device_identities(const char *const jid)
{
return NULL;
}
@@ -58,52 +46,25 @@ omemo_loaded(void)
return TRUE;
}
void
omemo_on_connect(ProfAccount* account)
{
}
void
omemo_on_disconnect(void)
{
}
void omemo_on_connect(ProfAccount *account) {}
void omemo_on_disconnect(void) {}
char*
omemo_on_message_send(ProfWin* win, const char* const message, gboolean request_receipt, gboolean muc)
char *
omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_receipt, gboolean muc)
{
return NULL;
}
char*
char *
omemo_own_fingerprint(gboolean formatted)
{
return NULL;
}
void
omemo_start_muc_sessions(const char* const roomjid)
{
}
void
omemo_start_session(const char* const barejid)
{
}
void
omemo_trust(const char* const jid, const char* const fingerprint_formatted)
{
}
void
omemo_untrust(const char* const jid, const char* const fingerprint_formatted)
{
}
void
omemo_devicelist_publish(GList* device_list)
{
}
void
omemo_publish_crypto_materials(void)
{
}
void
omemo_start_sessions(void)
{
}
void omemo_start_muc_sessions(const char *const roomjid) {}
void omemo_start_session(const char *const barejid) {}
void omemo_trust(const char *const jid, const char *const fingerprint_formatted) {}
void omemo_untrust(const char *const jid, const char *const fingerprint_formatted) {}
void omemo_devicelist_publish(GList *device_list) {}
void omemo_publish_crypto_materials(void) {}
void omemo_start_sessions(void) {}

126
tests/unittests/otr/stub_otr.c
View File

@@ -1,164 +1,114 @@
#include <glib.h>
#include <libotr/message.h>
#include <libotr/proto.h>
#include <libotr/message.h>
#include <glib.h>
#include <cmocka.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include "config/account.h"
#include "otr/otr.h"
OtrlUserState
otr_userstate(void)
OtrlUserState otr_userstate(void)
{
return NULL;
}
OtrlMessageAppOps*
otr_messageops(void)
OtrlMessageAppOps* otr_messageops(void)
{
return NULL;
}
GHashTable*
otr_smpinitators(void)
GHashTable* otr_smpinitators(void)
{
return NULL;
}
void
otr_init(void)
{
}
void
otr_shutdown(void)
{
}
void otr_init(void) {}
void otr_shutdown(void) {}
char*
otr_libotr_version(void)
char* otr_libotr_version(void)
{
return mock_ptr_type(char*);
}
char*
otr_start_query(void)
char* otr_start_query(void)
{
return mock_ptr_type(char*);
}
void
otr_poll(void)
{
}
void
otr_on_connect(ProfAccount* account)
{
}
char*
otr_on_message_recv(const char* const barejid, const char* const resource, const char* const message, gboolean* was_decrypted)
void otr_poll(void) {}
void otr_on_connect(ProfAccount *account) {}
char* otr_on_message_recv(const char * const barejid, const char * const resource, const char * const message, gboolean *was_decrypted)
{
return NULL;
}
gboolean
otr_on_message_send(ProfChatWin* chatwin, const char* const message, gboolean request_receipt, const char* const replace_id)
gboolean otr_on_message_send(ProfChatWin *chatwin, const char * const message, gboolean request_receipt, const char *const replace_id)
{
return FALSE;
}
void
otr_keygen(ProfAccount* account)
void otr_keygen(ProfAccount *account)
{
check_expected(account);
}
gboolean
otr_key_loaded(void)
gboolean otr_key_loaded(void)
{
return mock_type(gboolean);
}
char*
otr_tag_message(const char* const msg)
char* otr_tag_message(const char * const msg)
{
return NULL;
}
gboolean
otr_is_secure(const char* const recipient)
gboolean otr_is_secure(const char * const recipient)
{
return FALSE;
}
gboolean
otr_is_trusted(const char* const recipient)
gboolean otr_is_trusted(const char * const recipient)
{
return FALSE;
}
void
otr_trust(const char* const recipient)
{
}
void
otr_untrust(const char* const recipient)
void otr_trust(const char * const recipient) {}
void otr_untrust(const char * const recipient) {}
void otr_smp_secret(const char * const recipient, const char *secret) {}
void otr_smp_question(const char * const recipient, const char *question, const char *answer) {}
void otr_smp_answer(const char * const recipient, const char *answer) {}
void otr_end_session(const char * const recipient) {}
char * otr_get_my_fingerprint(void)
{
return mock_ptr_type(char *);
}
void
otr_smp_secret(const char* const recipient, const char* secret)
{
}
void
otr_smp_question(const char* const recipient, const char* question, const char* answer)
{
}
void
otr_smp_answer(const char* const recipient, const char* answer)
{
}
void
otr_end_session(const char* const recipient)
{
}
char*
otr_get_my_fingerprint(void)
{
return mock_ptr_type(char*);
}
char*
otr_get_their_fingerprint(const char* const recipient)
char * otr_get_their_fingerprint(const char * const recipient)
{
check_expected(recipient);
return mock_ptr_type(char*);
return mock_ptr_type(char *);
}
char*
otr_encrypt_message(const char* const to, const char* const message)
char * otr_encrypt_message(const char * const to, const char * const message)
{
return NULL;
}
char*
otr_decrypt_message(const char* const from, const char* const message,
gboolean* was_decrypted)
char * otr_decrypt_message(const char * const from, const char * const message,
gboolean *was_decrypted)
{
return NULL;
}
void
otr_free_message(char* message)
{
}
void otr_free_message(char *message) {}
prof_otrpolicy_t
otr_get_policy(const char* const recipient)
prof_otrpolicy_t otr_get_policy(const char * const recipient)
{
return PROF_OTRPOLICY_MANUAL;
}

80
tests/unittests/pgp/stub_gpg.c
View File

@@ -2,17 +2,10 @@
#include "pgp/gpg.h"
void
p_gpg_init(void)
{
}
void
p_gpg_close(void)
{
}
void p_gpg_init(void) {}
void p_gpg_close(void) {}
GHashTable*
p_gpg_list_keys(void)
GHashTable* p_gpg_list_keys(void)
{
return NULL;
}
@@ -23,96 +16,65 @@ p_gpg_pubkeys(void)
return NULL;
}
const char*
p_gpg_libver(void)
const char* p_gpg_libver(void)
{
return NULL;
}
void
p_gpg_verify(const char* const barejid, const char* const sign)
{
}
void p_gpg_verify(const char * const barejid, const char *const sign) {}
char*
p_gpg_sign(const char* const str, const char* const fp)
char* p_gpg_sign(const char * const str, const char * const fp)
{
return NULL;
}
gboolean
p_gpg_valid_key(const char* const keyid, char** err_str)
gboolean p_gpg_valid_key(const char * const keyid, char **err_str)
{
return FALSE;
}
gboolean
p_gpg_available(const char* const barejid)
gboolean p_gpg_available(const char * const barejid)
{
return FALSE;
}
char*
p_gpg_decrypt(const char* const cipher)
char * p_gpg_decrypt(const char * const cipher)
{
return NULL;
}
void
p_gpg_on_connect(const char* const barejid)
{
}
void
p_gpg_on_disconnect(void)
{
}
void p_gpg_on_connect(const char * const barejid) {}
void p_gpg_on_disconnect(void) {}
gboolean
p_gpg_addkey(const char* const jid, const char* const keyid)
gboolean p_gpg_addkey(const char * const jid, const char * const keyid)
{
return TRUE;
}
void
p_gpg_free_decrypted(char* decrypted)
{
}
void p_gpg_free_decrypted(char *decrypted) {}
void
p_gpg_free_keys(GHashTable* keys)
{
}
void p_gpg_free_keys(GHashTable *keys) {}
void
p_gpg_autocomplete_key_reset(void)
{
}
void p_gpg_autocomplete_key_reset(void) {}
char*
p_gpg_autocomplete_key(const char* const search_str, gboolean previous, void* context)
char * p_gpg_autocomplete_key(const char * const search_str, gboolean previous, void *context)
{
return NULL;
}
char*
p_gpg_format_fp_str(char* fp)
char *
p_gpg_format_fp_str(char *fp)
{
return NULL;
}
gboolean
ox_is_private_key_available(const char* const barejid)
{
gboolean ox_is_private_key_available(const char *const barejid) {
return FALSE;
}
gboolean
ox_is_public_key_available(const char* const barejid)
{
gboolean ox_is_public_key_available(const char *const barejid) {
return FALSE;
}
GHashTable*
ox_gpg_public_keys(void)
{
GHashTable* ox_gpg_public_keys(void) {
return NULL;
}

98
tests/unittests/test_autocomplete.c
View File

@@ -1,42 +1,38 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include "tools/autocomplete.h"
#include "xmpp/contact.h"
#include "tools/autocomplete.h"
void
clear_empty(void** state)
void clear_empty(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_free(ac);
}
void
reset_after_create(void** state)
void reset_after_create(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_reset(ac);
autocomplete_free(ac);
}
void
find_after_create(void** state)
void find_after_create(void **state)
{
Autocomplete ac = autocomplete_new();
char* result = autocomplete_complete(ac, "hello", TRUE, FALSE);
char *result = autocomplete_complete(ac, "hello", TRUE, FALSE);
autocomplete_free(ac);
free(result);
}
void
get_after_create_returns_null(void** state)
void get_after_create_returns_null(void **state)
{
Autocomplete ac = autocomplete_new();
GList* result = autocomplete_create_list(ac);
GList *result = autocomplete_create_list(ac);
assert_null(result);
@@ -44,12 +40,11 @@ get_after_create_returns_null(void** state)
g_list_free_full(result, free);
}
void
add_one_and_complete(void** state)
void add_one_and_complete(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_add(ac, "Hello");
char* result = autocomplete_complete(ac, "Hel", TRUE, FALSE);
char *result = autocomplete_complete(ac, "Hel", TRUE, FALSE);
assert_string_equal("Hello", result);
@@ -57,13 +52,12 @@ add_one_and_complete(void** state)
free(result);
}
void
add_two_and_complete_returns_first(void** state)
void add_two_and_complete_returns_first(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_add(ac, "Hello");
autocomplete_add(ac, "Help");
char* result = autocomplete_complete(ac, "Hel", TRUE, FALSE);
char *result = autocomplete_complete(ac, "Hel", TRUE, FALSE);
assert_string_equal("Hello", result);
@@ -71,14 +65,13 @@ add_two_and_complete_returns_first(void** state)
free(result);
}
void
add_two_and_complete_returns_second(void** state)
void add_two_and_complete_returns_second(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_add(ac, "Hello");
autocomplete_add(ac, "Help");
char* result1 = autocomplete_complete(ac, "Hel", TRUE, FALSE);
char* result2 = autocomplete_complete(ac, result1, TRUE, FALSE);
char *result1 = autocomplete_complete(ac, "Hel", TRUE, FALSE);
char *result2 = autocomplete_complete(ac, result1, TRUE, FALSE);
assert_string_equal("Help", result2);
@@ -87,13 +80,12 @@ add_two_and_complete_returns_second(void** state)
free(result2);
}
void
add_two_adds_two(void** state)
void add_two_adds_two(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_add(ac, "Hello");
autocomplete_add(ac, "Help");
GList* result = autocomplete_create_list(ac);
GList *result = autocomplete_create_list(ac);
assert_int_equal(2, g_list_length(result));
@@ -101,13 +93,12 @@ add_two_adds_two(void** state)
g_list_free_full(result, free);
}
void
add_two_same_adds_one(void** state)
void add_two_same_adds_one(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_add(ac, "Hello");
autocomplete_add(ac, "Hello");
GList* result = autocomplete_create_list(ac);
GList *result = autocomplete_create_list(ac);
assert_int_equal(1, g_list_length(result));
@@ -115,17 +106,16 @@ add_two_same_adds_one(void** state)
g_list_free_full(result, free);
}
void
add_two_same_updates(void** state)
void add_two_same_updates(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_add(ac, "Hello");
autocomplete_add(ac, "Hello");
GList* result = autocomplete_create_list(ac);
GList *result = autocomplete_create_list(ac);
GList* first = g_list_nth(result, 0);
GList *first = g_list_nth(result, 0);
char* str = first->data;
char *str = first->data;
assert_string_equal("Hello", str);
@@ -133,13 +123,12 @@ add_two_same_updates(void** state)
g_list_free_full(result, free);
}
void
complete_accented_with_accented(void** state)
void complete_accented_with_accented(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_add(ac, "èâîô");
char* result = autocomplete_complete(ac, "èâ", TRUE, FALSE);
char *result = autocomplete_complete(ac, "èâ", TRUE, FALSE);
assert_string_equal("èâîô", result);
@@ -147,13 +136,12 @@ complete_accented_with_accented(void** state)
free(result);
}
void
complete_accented_with_base(void** state)
void complete_accented_with_base(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_add(ac, "èâîô");
char* result = autocomplete_complete(ac, "ea", TRUE, FALSE);
char *result = autocomplete_complete(ac, "ea", TRUE, FALSE);
assert_string_equal("èâîô", result);
@@ -161,15 +149,14 @@ complete_accented_with_base(void** state)
free(result);
}
void
complete_both_with_accented(void** state)
void complete_both_with_accented(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_add(ac, "eaooooo");
autocomplete_add(ac, "èâîô");
char* result1 = autocomplete_complete(ac, "èâ", TRUE, FALSE);
char* result2 = autocomplete_complete(ac, result1, TRUE, FALSE);
char *result1 = autocomplete_complete(ac, "èâ", TRUE, FALSE);
char *result2 = autocomplete_complete(ac, result1, TRUE, FALSE);
assert_string_equal("èâîô", result2);
@@ -178,15 +165,14 @@ complete_both_with_accented(void** state)
free(result2);
}
void
complete_both_with_base(void** state)
void complete_both_with_base(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_add(ac, "eaooooo");
autocomplete_add(ac, "èâîô");
char* result1 = autocomplete_complete(ac, "ea", TRUE, FALSE);
char* result2 = autocomplete_complete(ac, result1, TRUE, FALSE);
char *result1 = autocomplete_complete(ac, "ea", TRUE, FALSE);
char *result2 = autocomplete_complete(ac, result1, TRUE, FALSE);
assert_string_equal("èâîô", result2);
@@ -196,13 +182,12 @@ complete_both_with_base(void** state)
free(result2);
}
void
complete_ignores_case(void** state)
void complete_ignores_case(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_add(ac, "MyBuddy");
char* result = autocomplete_complete(ac, "myb", TRUE, FALSE);
char *result = autocomplete_complete(ac, "myb", TRUE, FALSE);
assert_string_equal("MyBuddy", result);
@@ -210,18 +195,17 @@ complete_ignores_case(void** state)
free(result);
}
void
complete_previous(void** state)
void complete_previous(void **state)
{
Autocomplete ac = autocomplete_new();
autocomplete_add(ac, "MyBuddy1");
autocomplete_add(ac, "MyBuddy2");
autocomplete_add(ac, "MyBuddy3");
char* result1 = autocomplete_complete(ac, "myb", TRUE, FALSE);
char* result2 = autocomplete_complete(ac, result1, TRUE, FALSE);
char* result3 = autocomplete_complete(ac, result2, TRUE, FALSE);
char* result4 = autocomplete_complete(ac, result3, TRUE, TRUE);
char *result1 = autocomplete_complete(ac, "myb", TRUE, FALSE);
char *result2 = autocomplete_complete(ac, result1, TRUE, FALSE);
char *result3 = autocomplete_complete(ac, result2, TRUE, FALSE);
char *result4 = autocomplete_complete(ac, result3, TRUE, TRUE);
assert_string_equal("MyBuddy2", result4);

32
tests/unittests/test_autocomplete.h
View File

@@ -1,16 +1,16 @@
void clear_empty(void** state);
void reset_after_create(void** state);
void find_after_create(void** state);
void get_after_create_returns_null(void** state);
void add_one_and_complete(void** state);
void add_two_and_complete_returns_first(void** state);
void add_two_and_complete_returns_second(void** state);
void add_two_adds_two(void** state);
void add_two_same_adds_one(void** state);
void add_two_same_updates(void** state);
void complete_accented_with_accented(void** state);
void complete_accented_with_base(void** state);
void complete_both_with_accented(void** state);
void complete_both_with_base(void** state);
void complete_ignores_case(void** state);
void complete_previous(void** state);
void clear_empty(void **state);
void reset_after_create(void **state);
void find_after_create(void **state);
void get_after_create_returns_null(void **state);
void add_one_and_complete(void **state);
void add_two_and_complete_returns_first(void **state);
void add_two_and_complete_returns_second(void **state);
void add_two_adds_two(void **state);
void add_two_same_adds_one(void **state);
void add_two_same_updates(void **state);
void complete_accented_with_accented(void **state);
void complete_accented_with_base(void **state);
void complete_both_with_accented(void **state);
void complete_both_with_base(void **state);
void complete_ignores_case(void **state);
void complete_previous(void **state);

24
tests/unittests/test_callbacks.c
View File

@@ -1,19 +1,18 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "plugins/callbacks.h"
#include "plugins/plugins.h"
void
returns_no_commands(void** state)
void returns_no_commands(void **state)
{
callbacks_init();
GList* commands = plugins_get_command_names();
GList *commands = plugins_get_command_names();
assert_true(commands == NULL);
@@ -21,30 +20,29 @@ returns_no_commands(void** state)
g_list_free(commands);
}
void
returns_commands(void** state)
void returns_commands(void **state)
{
callbacks_init();
PluginCommand* command1 = malloc(sizeof(PluginCommand));
PluginCommand *command1 = malloc(sizeof(PluginCommand));
command1->command_name = strdup("command1");
callbacks_add_command("plugin1", command1);
PluginCommand* command2 = malloc(sizeof(PluginCommand));
PluginCommand *command2 = malloc(sizeof(PluginCommand));
command2->command_name = strdup("command2");
callbacks_add_command("plugin1", command2);
PluginCommand* command3 = malloc(sizeof(PluginCommand));
PluginCommand *command3 = malloc(sizeof(PluginCommand));
command3->command_name = strdup("command3");
callbacks_add_command("plugin2", command3);
GList* names = plugins_get_command_names();
GList *names = plugins_get_command_names();
assert_true(g_list_length(names) == 3);
gboolean foundCommand1 = FALSE;
gboolean foundCommand2 = FALSE;
gboolean foundCommand3 = FALSE;
GList* curr = names;
GList *curr = names;
while (curr) {
if (g_strcmp0(curr->data, "command1") == 0) {
foundCommand1 = TRUE;

4
tests/unittests/test_callbacks.h
View File

@@ -1,2 +1,2 @@
void returns_no_commands(void** state);
void returns_commands(void** state);
void returns_no_commands(void **state);
void returns_commands(void **state);

42
tests/unittests/test_chat_session.c
View File

@@ -1,55 +1,51 @@
#include <cmocka.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include "xmpp/chat_session.h"
void
returns_false_when_chat_session_does_not_exist(void** state)
void returns_false_when_chat_session_does_not_exist(void **state)
{
ChatSession* session = chat_session_get("somejid@server.org");
ChatSession *session = chat_session_get("somejid@server.org");
assert_null(session);
}
void
creates_chat_session_on_recipient_activity(void** state)
void creates_chat_session_on_recipient_activity(void **state)
{
char* barejid = "myjid@server.org";
char* resource = "tablet";
char *barejid = "myjid@server.org";
char *resource = "tablet";
chat_session_recipient_active(barejid, resource, FALSE);
ChatSession* session = chat_session_get(barejid);
ChatSession *session = chat_session_get(barejid);
assert_non_null(session);
assert_string_equal(session->resource, resource);
}
void
replaces_chat_session_on_recipient_activity_with_different_resource(void** state)
void replaces_chat_session_on_recipient_activity_with_different_resource(void **state)
{
char* barejid = "myjid@server.org";
char* resource1 = "tablet";
char* resource2 = "mobile";
char *barejid = "myjid@server.org";
char *resource1 = "tablet";
char *resource2 = "mobile";
chat_session_recipient_active(barejid, resource1, FALSE);
chat_session_recipient_active(barejid, resource2, FALSE);
ChatSession* session = chat_session_get(barejid);
ChatSession *session = chat_session_get(barejid);
assert_string_equal(session->resource, resource2);
}
void
removes_chat_session(void** state)
void removes_chat_session(void **state)
{
char* barejid = "myjid@server.org";
char* resource1 = "laptop";
char *barejid = "myjid@server.org";
char *resource1 = "laptop";
chat_session_recipient_active(barejid, resource1, FALSE);
chat_session_remove(barejid);
ChatSession* session = chat_session_get(barejid);
ChatSession *session = chat_session_get(barejid);
assert_null(session);
}

8
tests/unittests/test_chat_session.h
View File

@@ -1,4 +1,4 @@
void returns_false_when_chat_session_does_not_exist(void** state);
void creates_chat_session_on_recipient_activity(void** state);
void replaces_chat_session_on_recipient_activity_with_different_resource(void** state);
void removes_chat_session(void** state);
void returns_false_when_chat_session_does_not_exist(void **state);
void creates_chat_session_on_recipient_activity(void **state);
void replaces_chat_session_on_recipient_activity_with_different_resource(void **state);
void removes_chat_session(void **state);

323
tests/unittests/test_cmd_account.c
View File

@@ -1,15 +1,15 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "xmpp/xmpp.h"
#include "ui/stub_ui.h"
#include "ui/ui.h"
#include "ui/stub_ui.h"
#include "config/accounts.h"
@@ -17,10 +17,9 @@
#define CMD_ACCOUNT "/account"
void
cmd_account_shows_usage_when_not_connected_and_no_args(void** state)
void cmd_account_shows_usage_when_not_connected_and_no_args(void **state)
{
gchar* args[] = { NULL };
gchar *args[] = { NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -30,12 +29,12 @@ cmd_account_shows_usage_when_not_connected_and_no_args(void** state)
assert_true(result);
}
void
cmd_account_shows_account_when_connected_and_no_args(void** state)
void cmd_account_shows_account_when_connected_and_no_args(void **state)
{
ProfAccount* account = account_new("jabber_org", "me@jabber.org", NULL, NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
gchar* args[] = { NULL };
ProfAccount *account = account_new("jabber_org", "me@jabber.org", NULL, NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
gchar *args[] = { NULL };
will_return(connection_get_status, JABBER_CONNECTED);
will_return(session_get_account_name, "account_name");
@@ -48,12 +47,11 @@ cmd_account_shows_account_when_connected_and_no_args(void** state)
assert_true(result);
}
void
cmd_account_list_shows_accounts(void** state)
void cmd_account_list_shows_accounts(void **state)
{
gchar* args[] = { "list", NULL };
gchar *args[] = { "list", NULL };
gchar** accounts = malloc(sizeof(gchar*) * 4);
gchar **accounts = malloc(sizeof(gchar *) * 4);
accounts[0] = strdup("account1");
accounts[1] = strdup("account2");
accounts[2] = strdup("account3");
@@ -67,10 +65,9 @@ cmd_account_list_shows_accounts(void** state)
assert_true(result);
}
void
cmd_account_show_shows_usage_when_no_arg(void** state)
void cmd_account_show_shows_usage_when_no_arg(void **state)
{
gchar* args[] = { "show", NULL };
gchar *args[] = { "show", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ACCOUNT);
@@ -78,10 +75,9 @@ cmd_account_show_shows_usage_when_no_arg(void** state)
assert_true(result);
}
void
cmd_account_show_shows_message_when_account_does_not_exist(void** state)
void cmd_account_show_shows_message_when_account_does_not_exist(void **state)
{
gchar* args[] = { "show", "account_name", NULL };
gchar *args[] = { "show", "account_name", NULL };
expect_any(accounts_get_account, name);
will_return(accounts_get_account, NULL);
@@ -93,12 +89,11 @@ cmd_account_show_shows_message_when_account_does_not_exist(void** state)
assert_true(result);
}
void
cmd_account_show_shows_account_when_exists(void** state)
void cmd_account_show_shows_account_when_exists(void **state)
{
gchar* args[] = { "show", "account_name", NULL };
ProfAccount* account = account_new("jabber_org", "me@jabber.org", NULL, NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
gchar *args[] = { "show", "account_name", NULL };
ProfAccount *account = account_new("jabber_org", "me@jabber.org", NULL, NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
expect_any(accounts_get_account, name);
will_return(accounts_get_account, account);
@@ -109,10 +104,9 @@ cmd_account_show_shows_account_when_exists(void** state)
assert_true(result);
}
void
cmd_account_add_shows_usage_when_no_arg(void** state)
void cmd_account_add_shows_usage_when_no_arg(void **state)
{
gchar* args[] = { "add", NULL };
gchar *args[] = { "add", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ACCOUNT);
@@ -120,10 +114,9 @@ cmd_account_add_shows_usage_when_no_arg(void** state)
assert_true(result);
}
void
cmd_account_add_adds_account(void** state)
void cmd_account_add_adds_account(void **state)
{
gchar* args[] = { "add", "new_account", NULL };
gchar *args[] = { "add", "new_account", NULL };
expect_string(accounts_add, jid, "new_account");
expect_value(accounts_add, altdomain, NULL);
@@ -135,10 +128,9 @@ cmd_account_add_adds_account(void** state)
assert_true(result);
}
void
cmd_account_enable_shows_usage_when_no_arg(void** state)
void cmd_account_enable_shows_usage_when_no_arg(void **state)
{
gchar* args[] = { "enable", NULL };
gchar *args[] = { "enable", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ACCOUNT);
@@ -146,10 +138,9 @@ cmd_account_enable_shows_usage_when_no_arg(void** state)
assert_true(result);
}
void
cmd_account_enable_enables_account(void** state)
void cmd_account_enable_enables_account(void **state)
{
gchar* args[] = { "enable", "account_name", NULL };
gchar *args[] = { "enable", "account_name", NULL };
expect_string(accounts_enable, name, "account_name");
will_return(accounts_enable, TRUE);
@@ -161,10 +152,9 @@ cmd_account_enable_enables_account(void** state)
assert_true(result);
}
void
cmd_account_enable_shows_message_when_account_doesnt_exist(void** state)
void cmd_account_enable_shows_message_when_account_doesnt_exist(void **state)
{
gchar* args[] = { "enable", "account_name", NULL };
gchar *args[] = { "enable", "account_name", NULL };
expect_any(accounts_enable, name);
will_return(accounts_enable, FALSE);
@@ -176,10 +166,9 @@ cmd_account_enable_shows_message_when_account_doesnt_exist(void** state)
assert_true(result);
}
void
cmd_account_disable_shows_usage_when_no_arg(void** state)
void cmd_account_disable_shows_usage_when_no_arg(void **state)
{
gchar* args[] = { "disable", NULL };
gchar *args[] = { "disable", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ACCOUNT);
@@ -187,10 +176,9 @@ cmd_account_disable_shows_usage_when_no_arg(void** state)
assert_true(result);
}
void
cmd_account_disable_disables_account(void** state)
void cmd_account_disable_disables_account(void **state)
{
gchar* args[] = { "disable", "account_name", NULL };
gchar *args[] = { "disable", "account_name", NULL };
expect_string(accounts_disable, name, "account_name");
will_return(accounts_disable, TRUE);
@@ -202,10 +190,9 @@ cmd_account_disable_disables_account(void** state)
assert_true(result);
}
void
cmd_account_disable_shows_message_when_account_doesnt_exist(void** state)
void cmd_account_disable_shows_message_when_account_doesnt_exist(void **state)
{
gchar* args[] = { "disable", "account_name", NULL };
gchar *args[] = { "disable", "account_name", NULL };
expect_any(accounts_disable, name);
will_return(accounts_disable, FALSE);
@@ -217,10 +204,9 @@ cmd_account_disable_shows_message_when_account_doesnt_exist(void** state)
assert_true(result);
}
void
cmd_account_rename_shows_usage_when_no_args(void** state)
void cmd_account_rename_shows_usage_when_no_args(void **state)
{
gchar* args[] = { "rename", NULL };
gchar *args[] = { "rename", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ACCOUNT);
@@ -228,10 +214,9 @@ cmd_account_rename_shows_usage_when_no_args(void** state)
assert_true(result);
}
void
cmd_account_rename_shows_usage_when_one_arg(void** state)
void cmd_account_rename_shows_usage_when_one_arg(void **state)
{
gchar* args[] = { "rename", "original_name", NULL };
gchar *args[] = { "rename", "original_name", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ACCOUNT);
@@ -239,10 +224,9 @@ cmd_account_rename_shows_usage_when_one_arg(void** state)
assert_true(result);
}
void
cmd_account_rename_renames_account(void** state)
void cmd_account_rename_renames_account(void **state)
{
gchar* args[] = { "rename", "original_name", "new_name", NULL };
gchar *args[] = { "rename", "original_name", "new_name", NULL };
expect_string(accounts_rename, account_name, "original_name");
expect_string(accounts_rename, new_name, "new_name");
@@ -255,10 +239,9 @@ cmd_account_rename_renames_account(void** state)
assert_true(result);
}
void
cmd_account_rename_shows_message_when_not_renamed(void** state)
void cmd_account_rename_shows_message_when_not_renamed(void **state)
{
gchar* args[] = { "rename", "original_name", "new_name", NULL };
gchar *args[] = { "rename", "original_name", "new_name", NULL };
expect_any(accounts_rename, account_name);
expect_any(accounts_rename, new_name);
@@ -271,10 +254,9 @@ cmd_account_rename_shows_message_when_not_renamed(void** state)
assert_true(result);
}
void
cmd_account_set_shows_usage_when_no_args(void** state)
void cmd_account_set_shows_usage_when_no_args(void **state)
{
gchar* args[] = { "set", NULL };
gchar *args[] = { "set", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ACCOUNT);
@@ -282,10 +264,9 @@ cmd_account_set_shows_usage_when_no_args(void** state)
assert_true(result);
}
void
cmd_account_set_shows_usage_when_one_arg(void** state)
void cmd_account_set_shows_usage_when_one_arg(void **state)
{
gchar* args[] = { "set", "a_account", NULL };
gchar *args[] = { "set", "a_account", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ACCOUNT);
@@ -293,10 +274,9 @@ cmd_account_set_shows_usage_when_one_arg(void** state)
assert_true(result);
}
void
cmd_account_set_shows_usage_when_two_args(void** state)
void cmd_account_set_shows_usage_when_two_args(void **state)
{
gchar* args[] = { "set", "a_account", "a_property", NULL };
gchar *args[] = { "set", "a_account", "a_property", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ACCOUNT);
@@ -304,10 +284,9 @@ cmd_account_set_shows_usage_when_two_args(void** state)
assert_true(result);
}
void
cmd_account_set_shows_message_when_account_doesnt_exist(void** state)
void cmd_account_set_shows_message_when_account_doesnt_exist(void **state)
{
gchar* args[] = { "set", "a_account", "a_property", "a_value", NULL };
gchar *args[] = { "set", "a_account", "a_property", "a_value", NULL };
expect_string(accounts_account_exists, account_name, "a_account");
will_return(accounts_account_exists, FALSE);
@@ -319,10 +298,9 @@ cmd_account_set_shows_message_when_account_doesnt_exist(void** state)
assert_true(result);
}
void
cmd_account_set_jid_shows_message_for_malformed_jid(void** state)
void cmd_account_set_jid_shows_message_for_malformed_jid(void **state)
{
gchar* args[] = { "set", "a_account", "jid", "@malformed", NULL };
gchar *args[] = { "set", "a_account", "jid", "@malformed", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -333,10 +311,9 @@ cmd_account_set_jid_shows_message_for_malformed_jid(void** state)
assert_true(result);
}
void
cmd_account_set_jid_sets_barejid(void** state)
void cmd_account_set_jid_sets_barejid(void **state)
{
gchar* args[] = { "set", "a_account", "jid", "a_local@a_domain", NULL };
gchar *args[] = { "set", "a_account", "jid", "a_local@a_domain", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -351,10 +328,9 @@ cmd_account_set_jid_sets_barejid(void** state)
assert_true(result);
}
void
cmd_account_set_jid_sets_resource(void** state)
void cmd_account_set_jid_sets_resource(void **state)
{
gchar* args[] = { "set", "a_account", "jid", "a_local@a_domain/a_resource", NULL };
gchar *args[] = { "set", "a_account", "jid", "a_local@a_domain/a_resource", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -374,10 +350,9 @@ cmd_account_set_jid_sets_resource(void** state)
assert_true(result);
}
void
cmd_account_set_server_sets_server(void** state)
void cmd_account_set_server_sets_server(void **state)
{
gchar* args[] = { "set", "a_account", "server", "a_server", NULL };
gchar *args[] = { "set", "a_account", "server", "a_server", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -392,10 +367,9 @@ cmd_account_set_server_sets_server(void** state)
assert_true(result);
}
void
cmd_account_set_resource_sets_resource(void** state)
void cmd_account_set_resource_sets_resource(void **state)
{
gchar* args[] = { "set", "a_account", "resource", "a_resource", NULL };
gchar *args[] = { "set", "a_account", "resource", "a_resource", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -412,10 +386,9 @@ cmd_account_set_resource_sets_resource(void** state)
assert_true(result);
}
void
cmd_account_set_resource_sets_resource_with_online_message(void** state)
void cmd_account_set_resource_sets_resource_with_online_message(void **state)
{
gchar* args[] = { "set", "a_account", "resource", "a_resource", NULL };
gchar *args[] = { "set", "a_account", "resource", "a_resource", NULL };
will_return(connection_get_status, JABBER_CONNECTED);
@@ -432,12 +405,12 @@ cmd_account_set_resource_sets_resource_with_online_message(void** state)
assert_true(result);
}
void
cmd_account_set_password_sets_password(void** state)
void cmd_account_set_password_sets_password(void **state)
{
gchar* args[] = { "set", "a_account", "password", "a_password", NULL };
ProfAccount* account = account_new("a_account", NULL, NULL, NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
gchar *args[] = { "set", "a_account", "password", "a_password", NULL };
ProfAccount *account = account_new("a_account", NULL, NULL, NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -455,12 +428,11 @@ cmd_account_set_password_sets_password(void** state)
assert_true(result);
}
void
cmd_account_set_eval_password_sets_eval_password(void** state)
void cmd_account_set_eval_password_sets_eval_password(void **state)
{
gchar* args[] = { "set", "a_account", "eval_password", "a_password", NULL };
ProfAccount* account = account_new("a_account", NULL, NULL, NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
gchar *args[] = { "set", "a_account", "eval_password", "a_password", NULL };
ProfAccount *account = account_new("a_account", NULL, NULL, NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -478,12 +450,10 @@ cmd_account_set_eval_password_sets_eval_password(void** state)
assert_true(result);
}
void
cmd_account_set_password_when_eval_password_set(void** state)
{
gchar* args[] = { "set", "a_account", "password", "a_password", NULL };
ProfAccount* account = account_new("a_account", NULL, NULL, "a_password",
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
void cmd_account_set_password_when_eval_password_set(void **state) {
gchar *args[] = { "set", "a_account", "password", "a_password", NULL };
ProfAccount *account = account_new("a_account", NULL, NULL, "a_password",
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -497,12 +467,10 @@ cmd_account_set_password_when_eval_password_set(void** state)
assert_true(result);
}
void
cmd_account_set_eval_password_when_password_set(void** state)
{
gchar* args[] = { "set", "a_account", "eval_password", "a_password", NULL };
ProfAccount* account = account_new("a_account", NULL, "a_password", NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
void cmd_account_set_eval_password_when_password_set(void **state) {
gchar *args[] = { "set", "a_account", "eval_password", "a_password", NULL };
ProfAccount *account = account_new("a_account", NULL, "a_password", NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -516,10 +484,9 @@ cmd_account_set_eval_password_when_password_set(void** state)
assert_true(result);
}
void
cmd_account_set_muc_sets_muc(void** state)
void cmd_account_set_muc_sets_muc(void **state)
{
gchar* args[] = { "set", "a_account", "muc", "a_muc", NULL };
gchar *args[] = { "set", "a_account", "muc", "a_muc", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -534,10 +501,9 @@ cmd_account_set_muc_sets_muc(void** state)
assert_true(result);
}
void
cmd_account_set_nick_sets_nick(void** state)
void cmd_account_set_nick_sets_nick(void **state)
{
gchar* args[] = { "set", "a_account", "nick", "a_nick", NULL };
gchar *args[] = { "set", "a_account", "nick", "a_nick", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -552,10 +518,9 @@ cmd_account_set_nick_sets_nick(void** state)
assert_true(result);
}
void
cmd_account_show_message_for_missing_otr_policy(void** state)
void cmd_account_show_message_for_missing_otr_policy(void **state)
{
gchar* args[] = { "set", "a_account", "otr", NULL };
gchar *args[] = { "set", "a_account", "otr", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ACCOUNT);
@@ -563,10 +528,9 @@ cmd_account_show_message_for_missing_otr_policy(void** state)
assert_true(result);
}
void
cmd_account_show_message_for_invalid_otr_policy(void** state)
void cmd_account_show_message_for_invalid_otr_policy(void **state)
{
gchar* args[] = { "set", "a_account", "otr", "bad_otr_policy", NULL };
gchar *args[] = { "set", "a_account", "otr", "bad_otr_policy", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -577,10 +541,9 @@ cmd_account_show_message_for_invalid_otr_policy(void** state)
assert_true(result);
}
void
cmd_account_set_otr_sets_otr(void** state)
void cmd_account_set_otr_sets_otr(void **state)
{
gchar* args[] = { "set", "a_account", "otr", "opportunistic", NULL };
gchar *args[] = { "set", "a_account", "otr", "opportunistic", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -595,10 +558,9 @@ cmd_account_set_otr_sets_otr(void** state)
assert_true(result);
}
void
cmd_account_set_status_shows_message_when_invalid_status(void** state)
void cmd_account_set_status_shows_message_when_invalid_status(void **state)
{
gchar* args[] = { "set", "a_account", "status", "bad_status", NULL };
gchar *args[] = { "set", "a_account", "status", "bad_status", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -610,10 +572,9 @@ cmd_account_set_status_shows_message_when_invalid_status(void** state)
assert_true(result);
}
void
cmd_account_set_status_sets_status_when_valid(void** state)
void cmd_account_set_status_sets_status_when_valid(void **state)
{
gchar* args[] = { "set", "a_account", "status", "away", NULL };
gchar *args[] = { "set", "a_account", "status", "away", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -628,10 +589,9 @@ cmd_account_set_status_sets_status_when_valid(void** state)
assert_true(result);
}
void
cmd_account_set_status_sets_status_when_last(void** state)
void cmd_account_set_status_sets_status_when_last(void **state)
{
gchar* args[] = { "set", "a_account", "status", "last", NULL };
gchar *args[] = { "set", "a_account", "status", "last", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -646,10 +606,9 @@ cmd_account_set_status_sets_status_when_last(void** state)
assert_true(result);
}
void
cmd_account_set_invalid_presence_string_priority_shows_message(void** state)
void cmd_account_set_invalid_presence_string_priority_shows_message(void **state)
{
gchar* args[] = { "set", "a_account", "blah", "10", NULL };
gchar *args[] = { "set", "a_account", "blah", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -661,10 +620,9 @@ cmd_account_set_invalid_presence_string_priority_shows_message(void** state)
assert_true(result);
}
void
cmd_account_set_last_priority_shows_message(void** state)
void cmd_account_set_last_priority_shows_message(void **state)
{
gchar* args[] = { "set", "a_account", "last", "10", NULL };
gchar *args[] = { "set", "a_account", "last", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -676,10 +634,9 @@ cmd_account_set_last_priority_shows_message(void** state)
assert_true(result);
}
void
cmd_account_set_online_priority_sets_preference(void** state)
void cmd_account_set_online_priority_sets_preference(void **state)
{
gchar* args[] = { "set", "a_account", "online", "10", NULL };
gchar *args[] = { "set", "a_account", "online", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -696,10 +653,9 @@ cmd_account_set_online_priority_sets_preference(void** state)
assert_true(result);
}
void
cmd_account_set_chat_priority_sets_preference(void** state)
void cmd_account_set_chat_priority_sets_preference(void **state)
{
gchar* args[] = { "set", "a_account", "chat", "10", NULL };
gchar *args[] = { "set", "a_account", "chat", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -716,10 +672,9 @@ cmd_account_set_chat_priority_sets_preference(void** state)
assert_true(result);
}
void
cmd_account_set_away_priority_sets_preference(void** state)
void cmd_account_set_away_priority_sets_preference(void **state)
{
gchar* args[] = { "set", "a_account", "away", "10", NULL };
gchar *args[] = { "set", "a_account", "away", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -736,10 +691,9 @@ cmd_account_set_away_priority_sets_preference(void** state)
assert_true(result);
}
void
cmd_account_set_xa_priority_sets_preference(void** state)
void cmd_account_set_xa_priority_sets_preference(void **state)
{
gchar* args[] = { "set", "a_account", "xa", "10", NULL };
gchar *args[] = { "set", "a_account", "xa", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -756,10 +710,9 @@ cmd_account_set_xa_priority_sets_preference(void** state)
assert_true(result);
}
void
cmd_account_set_dnd_priority_sets_preference(void** state)
void cmd_account_set_dnd_priority_sets_preference(void **state)
{
gchar* args[] = { "set", "a_account", "dnd", "10", NULL };
gchar *args[] = { "set", "a_account", "dnd", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -776,10 +729,9 @@ cmd_account_set_dnd_priority_sets_preference(void** state)
assert_true(result);
}
void
cmd_account_set_priority_too_low_shows_message(void** state)
void cmd_account_set_priority_too_low_shows_message(void **state)
{
gchar* args[] = { "set", "a_account", "online", "-150", NULL };
gchar *args[] = { "set", "a_account", "online", "-150", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -790,10 +742,9 @@ cmd_account_set_priority_too_low_shows_message(void** state)
assert_true(result);
}
void
cmd_account_set_priority_too_high_shows_message(void** state)
void cmd_account_set_priority_too_high_shows_message(void **state)
{
gchar* args[] = { "set", "a_account", "online", "150", NULL };
gchar *args[] = { "set", "a_account", "online", "150", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -804,10 +755,9 @@ cmd_account_set_priority_too_high_shows_message(void** state)
assert_true(result);
}
void
cmd_account_set_priority_when_not_number_shows_message(void** state)
void cmd_account_set_priority_when_not_number_shows_message(void **state)
{
gchar* args[] = { "set", "a_account", "online", "abc", NULL };
gchar *args[] = { "set", "a_account", "online", "abc", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -818,10 +768,9 @@ cmd_account_set_priority_when_not_number_shows_message(void** state)
assert_true(result);
}
void
cmd_account_set_priority_when_empty_shows_message(void** state)
void cmd_account_set_priority_when_empty_shows_message(void **state)
{
gchar* args[] = { "set", "a_account", "online", "", NULL };
gchar *args[] = { "set", "a_account", "online", "", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -832,10 +781,9 @@ cmd_account_set_priority_when_empty_shows_message(void** state)
assert_true(result);
}
void
cmd_account_set_priority_updates_presence_when_account_connected_with_presence(void** state)
void cmd_account_set_priority_updates_presence_when_account_connected_with_presence(void **state)
{
gchar* args[] = { "set", "a_account", "online", "10", NULL };
gchar *args[] = { "set", "a_account", "online", "10", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);
@@ -851,8 +799,8 @@ cmd_account_set_priority_updates_presence_when_account_connected_with_presence(v
will_return(session_get_account_name, "a_account");
#ifdef HAVE_LIBGPGME
ProfAccount* account = account_new("a_account", "a_jid", NULL, NULL, TRUE, NULL, 5222, "a_resource",
NULL, NULL, 10, 10, 10, 10, 10, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
ProfAccount *account = account_new("a_account", "a_jid", NULL, NULL, TRUE, NULL, 5222, "a_resource",
NULL, NULL, 10, 10, 10, 10, 10, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
will_return(session_get_account_name, "a_account");
expect_any(accounts_get_account, name);
@@ -865,14 +813,14 @@ cmd_account_set_priority_updates_presence_when_account_connected_with_presence(v
expect_cons_show("Updated online priority for account a_account: 10");
expect_cons_show("");
gboolean result = cmd_account_set(NULL, CMD_ACCOUNT, args);
assert_true(result);
}
void
cmd_account_clear_shows_usage_when_no_args(void** state)
void cmd_account_clear_shows_usage_when_no_args(void **state)
{
gchar* args[] = { "clear", NULL };
gchar *args[] = { "clear", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ACCOUNT);
@@ -880,10 +828,9 @@ cmd_account_clear_shows_usage_when_no_args(void** state)
assert_true(result);
}
void
cmd_account_clear_shows_usage_when_one_arg(void** state)
void cmd_account_clear_shows_usage_when_one_arg(void **state)
{
gchar* args[] = { "clear", "a_account", NULL };
gchar *args[] = { "clear", "a_account", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ACCOUNT);
@@ -891,10 +838,9 @@ cmd_account_clear_shows_usage_when_one_arg(void** state)
assert_true(result);
}
void
cmd_account_clear_shows_message_when_account_doesnt_exist(void** state)
void cmd_account_clear_shows_message_when_account_doesnt_exist(void **state)
{
gchar* args[] = { "clear", "a_account", "a_property", NULL };
gchar *args[] = { "clear", "a_account", "a_property", NULL };
expect_string(accounts_account_exists, account_name, "a_account");
will_return(accounts_account_exists, FALSE);
@@ -906,10 +852,9 @@ cmd_account_clear_shows_message_when_account_doesnt_exist(void** state)
assert_true(result);
}
void
cmd_account_clear_shows_message_when_invalid_property(void** state)
void cmd_account_clear_shows_message_when_invalid_property(void **state)
{
gchar* args[] = { "clear", "a_account", "badproperty", NULL };
gchar *args[] = { "clear", "a_account", "badproperty", NULL };
expect_any(accounts_account_exists, account_name);
will_return(accounts_account_exists, TRUE);

112
tests/unittests/test_cmd_account.h
View File

@@ -1,56 +1,56 @@
void cmd_account_shows_usage_when_not_connected_and_no_args(void** state);
void cmd_account_shows_account_when_connected_and_no_args(void** state);
void cmd_account_list_shows_accounts(void** state);
void cmd_account_show_shows_usage_when_no_arg(void** state);
void cmd_account_show_shows_message_when_account_does_not_exist(void** state);
void cmd_account_show_shows_account_when_exists(void** state);
void cmd_account_add_shows_usage_when_no_arg(void** state);
void cmd_account_add_adds_account(void** state);
void cmd_account_enable_shows_usage_when_no_arg(void** state);
void cmd_account_enable_enables_account(void** state);
void cmd_account_enable_shows_message_when_account_doesnt_exist(void** state);
void cmd_account_disable_shows_usage_when_no_arg(void** state);
void cmd_account_disable_disables_account(void** state);
void cmd_account_disable_shows_message_when_account_doesnt_exist(void** state);
void cmd_account_rename_shows_usage_when_no_args(void** state);
void cmd_account_rename_shows_usage_when_one_arg(void** state);
void cmd_account_rename_renames_account(void** state);
void cmd_account_rename_shows_message_when_not_renamed(void** state);
void cmd_account_set_shows_usage_when_no_args(void** state);
void cmd_account_set_shows_usage_when_one_arg(void** state);
void cmd_account_set_shows_usage_when_two_args(void** state);
void cmd_account_set_shows_message_when_account_doesnt_exist(void** state);
void cmd_account_set_jid_shows_message_for_malformed_jid(void** state);
void cmd_account_set_jid_sets_barejid(void** state);
void cmd_account_set_jid_sets_resource(void** state);
void cmd_account_set_server_sets_server(void** state);
void cmd_account_set_resource_sets_resource(void** state);
void cmd_account_set_resource_sets_resource_with_online_message(void** state);
void cmd_account_set_password_sets_password(void** state);
void cmd_account_set_eval_password_sets_eval_password(void** state);
void cmd_account_set_password_when_eval_password_set(void** state);
void cmd_account_set_eval_password_when_password_set(void** state);
void cmd_account_set_muc_sets_muc(void** state);
void cmd_account_set_nick_sets_nick(void** state);
void cmd_account_show_message_for_missing_otr_policy(void** state);
void cmd_account_show_message_for_invalid_otr_policy(void** state);
void cmd_account_set_otr_sets_otr(void** state);
void cmd_account_set_status_shows_message_when_invalid_status(void** state);
void cmd_account_set_status_sets_status_when_valid(void** state);
void cmd_account_set_status_sets_status_when_last(void** state);
void cmd_account_set_invalid_presence_string_priority_shows_message(void** state);
void cmd_account_set_last_priority_shows_message(void** state);
void cmd_account_set_online_priority_sets_preference(void** state);
void cmd_account_set_chat_priority_sets_preference(void** state);
void cmd_account_set_away_priority_sets_preference(void** state);
void cmd_account_set_xa_priority_sets_preference(void** state);
void cmd_account_set_dnd_priority_sets_preference(void** state);
void cmd_account_set_priority_too_low_shows_message(void** state);
void cmd_account_set_priority_too_high_shows_message(void** state);
void cmd_account_set_priority_when_not_number_shows_message(void** state);
void cmd_account_set_priority_when_empty_shows_message(void** state);
void cmd_account_set_priority_updates_presence_when_account_connected_with_presence(void** state);
void cmd_account_clear_shows_usage_when_no_args(void** state);
void cmd_account_clear_shows_usage_when_one_arg(void** state);
void cmd_account_clear_shows_message_when_account_doesnt_exist(void** state);
void cmd_account_clear_shows_message_when_invalid_property(void** state);
void cmd_account_shows_usage_when_not_connected_and_no_args(void **state);
void cmd_account_shows_account_when_connected_and_no_args(void **state);
void cmd_account_list_shows_accounts(void **state);
void cmd_account_show_shows_usage_when_no_arg(void **state);
void cmd_account_show_shows_message_when_account_does_not_exist(void **state);
void cmd_account_show_shows_account_when_exists(void **state);
void cmd_account_add_shows_usage_when_no_arg(void **state);
void cmd_account_add_adds_account(void **state);
void cmd_account_enable_shows_usage_when_no_arg(void **state);
void cmd_account_enable_enables_account(void **state);
void cmd_account_enable_shows_message_when_account_doesnt_exist(void **state);
void cmd_account_disable_shows_usage_when_no_arg(void **state);
void cmd_account_disable_disables_account(void **state);
void cmd_account_disable_shows_message_when_account_doesnt_exist(void **state);
void cmd_account_rename_shows_usage_when_no_args(void **state);
void cmd_account_rename_shows_usage_when_one_arg(void **state);
void cmd_account_rename_renames_account(void **state);
void cmd_account_rename_shows_message_when_not_renamed(void **state);
void cmd_account_set_shows_usage_when_no_args(void **state);
void cmd_account_set_shows_usage_when_one_arg(void **state);
void cmd_account_set_shows_usage_when_two_args(void **state);
void cmd_account_set_shows_message_when_account_doesnt_exist(void **state);
void cmd_account_set_jid_shows_message_for_malformed_jid(void **state);
void cmd_account_set_jid_sets_barejid(void **state);
void cmd_account_set_jid_sets_resource(void **state);
void cmd_account_set_server_sets_server(void **state);
void cmd_account_set_resource_sets_resource(void **state);
void cmd_account_set_resource_sets_resource_with_online_message(void **state);
void cmd_account_set_password_sets_password(void **state);
void cmd_account_set_eval_password_sets_eval_password(void **state);
void cmd_account_set_password_when_eval_password_set(void **state);
void cmd_account_set_eval_password_when_password_set(void **state);
void cmd_account_set_muc_sets_muc(void **state);
void cmd_account_set_nick_sets_nick(void **state);
void cmd_account_show_message_for_missing_otr_policy(void **state);
void cmd_account_show_message_for_invalid_otr_policy(void **state);
void cmd_account_set_otr_sets_otr(void **state);
void cmd_account_set_status_shows_message_when_invalid_status(void **state);
void cmd_account_set_status_sets_status_when_valid(void **state);
void cmd_account_set_status_sets_status_when_last(void **state);
void cmd_account_set_invalid_presence_string_priority_shows_message(void **state);
void cmd_account_set_last_priority_shows_message(void **state);
void cmd_account_set_online_priority_sets_preference(void **state);
void cmd_account_set_chat_priority_sets_preference(void **state);
void cmd_account_set_away_priority_sets_preference(void **state);
void cmd_account_set_xa_priority_sets_preference(void **state);
void cmd_account_set_dnd_priority_sets_preference(void **state);
void cmd_account_set_priority_too_low_shows_message(void **state);
void cmd_account_set_priority_too_high_shows_message(void **state);
void cmd_account_set_priority_when_not_number_shows_message(void **state);
void cmd_account_set_priority_when_empty_shows_message(void **state);
void cmd_account_set_priority_updates_presence_when_account_connected_with_presence(void **state);
void cmd_account_clear_shows_usage_when_no_args(void **state);
void cmd_account_clear_shows_usage_when_one_arg(void **state);
void cmd_account_clear_shows_message_when_account_doesnt_exist(void **state);
void cmd_account_clear_shows_message_when_invalid_property(void **state);

61
tests/unittests/test_cmd_alias.c
View File

@@ -1,28 +1,27 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "xmpp/xmpp.h"
#include "ui/stub_ui.h"
#include "ui/ui.h"
#include "ui/stub_ui.h"
#include "config/preferences.h"
#include "command/cmd_ac.h"
#include "command/cmd_defs.h"
#include "command/cmd_funcs.h"
#include "command/cmd_ac.h"
#define CMD_ALIAS "/alias"
void
cmd_alias_add_shows_usage_when_no_args(void** state)
void cmd_alias_add_shows_usage_when_no_args(void **state)
{
gchar* args[] = { "add", NULL };
gchar *args[] = { "add", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ALIAS);
@@ -30,10 +29,9 @@ cmd_alias_add_shows_usage_when_no_args(void** state)
assert_true(result);
}
void
cmd_alias_add_shows_usage_when_no_value(void** state)
void cmd_alias_add_shows_usage_when_no_value(void **state)
{
gchar* args[] = { "add", "alias", NULL };
gchar *args[] = { "add", "alias", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ALIAS);
@@ -41,10 +39,9 @@ cmd_alias_add_shows_usage_when_no_value(void** state)
assert_true(result);
}
void
cmd_alias_remove_shows_usage_when_no_args(void** state)
void cmd_alias_remove_shows_usage_when_no_args(void **state)
{
gchar* args[] = { "remove", NULL };
gchar *args[] = { "remove", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ALIAS);
@@ -52,10 +49,9 @@ cmd_alias_remove_shows_usage_when_no_args(void** state)
assert_true(result);
}
void
cmd_alias_show_usage_when_invalid_subcmd(void** state)
void cmd_alias_show_usage_when_invalid_subcmd(void **state)
{
gchar* args[] = { "blah", NULL };
gchar *args[] = { "blah", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_ALIAS);
@@ -63,26 +59,24 @@ cmd_alias_show_usage_when_invalid_subcmd(void** state)
assert_true(result);
}
void
cmd_alias_add_adds_alias(void** state)
void cmd_alias_add_adds_alias(void **state)
{
gchar* args[] = { "add", "hc", "/help commands", NULL };
gchar *args[] = { "add", "hc", "/help commands", NULL };
expect_cons_show("Command alias added /hc -> /help commands");
gboolean result = cmd_alias(NULL, CMD_ALIAS, args);
assert_true(result);
char* returned_val = prefs_get_alias("hc");
char *returned_val = prefs_get_alias("hc");
assert_string_equal("/help commands", returned_val);
free(returned_val);
}
void
cmd_alias_add_shows_message_when_exists(void** state)
void cmd_alias_add_shows_message_when_exists(void **state)
{
gchar* args[] = { "add", "hc", "/help commands", NULL };
gchar *args[] = { "add", "hc", "/help commands", NULL };
cmd_init();
prefs_add_alias("hc", "/help commands");
@@ -94,10 +88,9 @@ cmd_alias_add_shows_message_when_exists(void** state)
assert_true(result);
}
void
cmd_alias_remove_removes_alias(void** state)
void cmd_alias_remove_removes_alias(void **state)
{
gchar* args[] = { "remove", "hn", NULL };
gchar *args[] = { "remove", "hn", NULL };
prefs_add_alias("hn", "/help navigation");
@@ -106,16 +99,15 @@ cmd_alias_remove_removes_alias(void** state)
gboolean result = cmd_alias(NULL, CMD_ALIAS, args);
assert_true(result);
char* returned_val = prefs_get_alias("hn");
char *returned_val = prefs_get_alias("hn");
assert_null(returned_val);
free(returned_val);
}
void
cmd_alias_remove_shows_message_when_no_alias(void** state)
void cmd_alias_remove_shows_message_when_no_alias(void **state)
{
gchar* args[] = { "remove", "hn", NULL };
gchar *args[] = { "remove", "hn", NULL };
expect_cons_show("No such command alias /hn");
@@ -123,10 +115,9 @@ cmd_alias_remove_shows_message_when_no_alias(void** state)
assert_true(result);
}
void
cmd_alias_list_shows_all_aliases(void** state)
void cmd_alias_list_shows_all_aliases(void **state)
{
gchar* args[] = { "list", NULL };
gchar *args[] = { "list", NULL };
prefs_add_alias("vy", "/vercheck on");
prefs_add_alias("q", "/quit");

18
tests/unittests/test_cmd_alias.h
View File

@@ -1,9 +1,9 @@
void cmd_alias_add_shows_usage_when_no_args(void** state);
void cmd_alias_add_shows_usage_when_no_value(void** state);
void cmd_alias_remove_shows_usage_when_no_args(void** state);
void cmd_alias_show_usage_when_invalid_subcmd(void** state);
void cmd_alias_add_adds_alias(void** state);
void cmd_alias_add_shows_message_when_exists(void** state);
void cmd_alias_remove_removes_alias(void** state);
void cmd_alias_remove_shows_message_when_no_alias(void** state);
void cmd_alias_list_shows_all_aliases(void** state);
void cmd_alias_add_shows_usage_when_no_args(void **state);
void cmd_alias_add_shows_usage_when_no_value(void **state);
void cmd_alias_remove_shows_usage_when_no_args(void **state);
void cmd_alias_show_usage_when_invalid_subcmd(void **state);
void cmd_alias_add_adds_alias(void **state);
void cmd_alias_add_shows_message_when_exists(void **state);
void cmd_alias_remove_removes_alias(void **state);
void cmd_alias_remove_shows_message_when_no_alias(void **state);
void cmd_alias_list_shows_all_aliases(void **state);

128
tests/unittests/test_cmd_bookmark.c
View File

@@ -1,18 +1,18 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "xmpp/xmpp.h"
#include "ui/stub_ui.h"
#include "ui/ui.h"
#include "ui/stub_ui.h"
#include "common.h"
#include "xmpp/muc.h"
#include "common.h"
#include "command/cmd_funcs.h"
@@ -22,8 +22,7 @@
#define CMD_BOOKMARK "/bookmark"
static void
test_with_connection_status(jabber_conn_status_t status)
static void test_with_connection_status(jabber_conn_status_t status)
{
ProfWin window;
window.type = WIN_CONSOLE;
@@ -34,28 +33,24 @@ test_with_connection_status(jabber_conn_status_t status)
assert_true(result);
}
void
cmd_bookmark_shows_message_when_disconnected(void** state)
void cmd_bookmark_shows_message_when_disconnected(void **state)
{
test_with_connection_status(JABBER_DISCONNECTED);
}
void
cmd_bookmark_shows_message_when_disconnecting(void** state)
void cmd_bookmark_shows_message_when_disconnecting(void **state)
{
test_with_connection_status(JABBER_DISCONNECTING);
}
void
cmd_bookmark_shows_message_when_connecting(void** state)
void cmd_bookmark_shows_message_when_connecting(void **state)
{
test_with_connection_status(JABBER_CONNECTING);
}
void
cmd_bookmark_shows_usage_when_no_args(void** state)
void cmd_bookmark_shows_usage_when_no_args(void **state)
{
gchar* args[] = { NULL };
gchar *args[] = { NULL };
ProfWin window;
window.type = WIN_CONSOLE;
@@ -77,7 +72,7 @@ static void _free_bookmark(Bookmark *bookmark)
*/
static gboolean
_cmp_bookmark(Bookmark* bm1, Bookmark* bm2)
_cmp_bookmark(Bookmark *bm1, Bookmark *bm2)
{
if (strcmp(bm1->barejid, bm2->barejid) != 0) {
return FALSE;
@@ -92,31 +87,30 @@ _cmp_bookmark(Bookmark* bm1, Bookmark* bm2)
return TRUE;
}
void
cmd_bookmark_list_shows_bookmarks(void** state)
void cmd_bookmark_list_shows_bookmarks(void **state)
{
gchar* args[] = { "list", NULL };
GList* bookmarks = NULL;
gchar *args[] = { "list", NULL };
GList *bookmarks = NULL;
ProfWin window;
window.type = WIN_CONSOLE;
Bookmark* bm1 = malloc(sizeof(Bookmark));
Bookmark *bm1 = malloc(sizeof(Bookmark));
bm1->barejid = strdup("room1@conf.org");
bm1->nick = strdup("bob");
bm1->autojoin = FALSE;
Bookmark* bm2 = malloc(sizeof(Bookmark));
Bookmark *bm2 = malloc(sizeof(Bookmark));
bm2->barejid = strdup("room2@conf.org");
bm2->nick = strdup("steve");
bm2->autojoin = TRUE;
Bookmark* bm3 = malloc(sizeof(Bookmark));
Bookmark *bm3 = malloc(sizeof(Bookmark));
bm3->barejid = strdup("room3@conf.org");
bm3->nick = strdup("dave");
bm3->autojoin = TRUE;
Bookmark* bm4 = malloc(sizeof(Bookmark));
Bookmark *bm4 = malloc(sizeof(Bookmark));
bm4->barejid = strdup("room4@conf.org");
bm4->nick = strdup("james");
bm4->autojoin = FALSE;
Bookmark* bm5 = malloc(sizeof(Bookmark));
Bookmark *bm5 = malloc(sizeof(Bookmark));
bm5->barejid = strdup("room5@conf.org");
bm5->nick = strdup("mike");
bm5->autojoin = FALSE;
@@ -154,11 +148,10 @@ cmd_bookmark_list_shows_bookmarks(void** state)
free(bm5);
}
void
cmd_bookmark_add_shows_message_when_invalid_jid(void** state)
void cmd_bookmark_add_shows_message_when_invalid_jid(void **state)
{
char* jid = "room";
gchar* args[] = { "add", jid, NULL };
char *jid = "room";
gchar *args[] = { "add", jid, NULL };
ProfWin window;
window.type = WIN_CONSOLE;
@@ -171,11 +164,10 @@ cmd_bookmark_add_shows_message_when_invalid_jid(void** state)
assert_true(result);
}
void
cmd_bookmark_add_adds_bookmark_with_jid(void** state)
void cmd_bookmark_add_adds_bookmark_with_jid(void **state)
{
char* jid = "room@conf.server";
gchar* args[] = { "add", jid, NULL };
char *jid = "room@conf.server";
gchar *args[] = { "add", jid, NULL };
ProfWin window;
window.type = WIN_CONSOLE;
@@ -193,12 +185,11 @@ cmd_bookmark_add_adds_bookmark_with_jid(void** state)
assert_true(result);
}
void
cmd_bookmark_uses_roomjid_in_room(void** state)
void cmd_bookmark_uses_roomjid_in_room(void **state)
{
muc_init();
gchar* args[] = { NULL };
gchar *args[] = { NULL };
ProfMucWin muc_win;
muc_win.window.type = WIN_MUC;
muc_win.memcheck = PROFMUCWIN_MEMCHECK;
@@ -220,12 +211,11 @@ cmd_bookmark_uses_roomjid_in_room(void** state)
muc_close();
}
void
cmd_bookmark_add_uses_roomjid_in_room(void** state)
void cmd_bookmark_add_uses_roomjid_in_room(void **state)
{
muc_init();
gchar* args[] = { "add", NULL };
gchar *args[] = { "add", NULL };
ProfMucWin muc_win;
muc_win.window.type = WIN_MUC;
muc_win.memcheck = PROFMUCWIN_MEMCHECK;
@@ -247,13 +237,12 @@ cmd_bookmark_add_uses_roomjid_in_room(void** state)
muc_close();
}
void
cmd_bookmark_add_uses_supplied_jid_in_room(void** state)
void cmd_bookmark_add_uses_supplied_jid_in_room(void **state)
{
muc_init();
char* jid = "room1@conf.server";
gchar* args[] = { "add", jid, NULL };
char *jid = "room1@conf.server";
gchar *args[] = { "add", jid, NULL };
ProfMucWin muc_win;
muc_win.window.type = WIN_MUC;
muc_win.memcheck = PROFMUCWIN_MEMCHECK;
@@ -275,12 +264,11 @@ cmd_bookmark_add_uses_supplied_jid_in_room(void** state)
muc_close();
}
void
cmd_bookmark_add_adds_bookmark_with_jid_nick(void** state)
void cmd_bookmark_add_adds_bookmark_with_jid_nick(void **state)
{
char* jid = "room@conf.server";
char* nick = "bob";
gchar* args[] = { "add", jid, "nick", nick, NULL };
char *jid = "room@conf.server";
char *nick = "bob";
gchar *args[] = { "add", jid, "nick", nick, NULL };
ProfWin window;
window.type = WIN_CONSOLE;
@@ -298,11 +286,10 @@ cmd_bookmark_add_adds_bookmark_with_jid_nick(void** state)
assert_true(result);
}
void
cmd_bookmark_add_adds_bookmark_with_jid_autojoin(void** state)
void cmd_bookmark_add_adds_bookmark_with_jid_autojoin(void **state)
{
char* jid = "room@conf.server";
gchar* args[] = { "add", jid, "autojoin", "on", NULL };
char *jid = "room@conf.server";
gchar *args[] = { "add", jid, "autojoin", "on", NULL };
ProfWin window;
window.type = WIN_CONSOLE;
@@ -320,12 +307,11 @@ cmd_bookmark_add_adds_bookmark_with_jid_autojoin(void** state)
assert_true(result);
}
void
cmd_bookmark_add_adds_bookmark_with_jid_nick_autojoin(void** state)
void cmd_bookmark_add_adds_bookmark_with_jid_nick_autojoin(void **state)
{
char* jid = "room@conf.server";
char* nick = "bob";
gchar* args[] = { "add", jid, "nick", nick, "autojoin", "on", NULL };
char *jid = "room@conf.server";
char *nick = "bob";
gchar *args[] = { "add", jid, "nick", nick, "autojoin", "on", NULL };
ProfWin window;
window.type = WIN_CONSOLE;
@@ -343,11 +329,10 @@ cmd_bookmark_add_adds_bookmark_with_jid_nick_autojoin(void** state)
assert_true(result);
}
void
cmd_bookmark_remove_removes_bookmark(void** state)
void cmd_bookmark_remove_removes_bookmark(void **state)
{
char* jid = "room@conf.server";
gchar* args[] = { "remove", jid, NULL };
char *jid = "room@conf.server";
gchar *args[] = { "remove", jid, NULL };
ProfWin window;
window.type = WIN_CONSOLE;
@@ -362,11 +347,10 @@ cmd_bookmark_remove_removes_bookmark(void** state)
assert_true(result);
}
void
cmd_bookmark_remove_shows_message_when_no_bookmark(void** state)
void cmd_bookmark_remove_shows_message_when_no_bookmark(void **state)
{
char* jid = "room@conf.server";
gchar* args[] = { "remove", jid, NULL };
char *jid = "room@conf.server";
gchar *args[] = { "remove", jid, NULL };
ProfWin window;
window.type = WIN_CONSOLE;
@@ -381,12 +365,11 @@ cmd_bookmark_remove_shows_message_when_no_bookmark(void** state)
assert_true(result);
}
void
cmd_bookmark_remove_uses_roomjid_in_room(void** state)
void cmd_bookmark_remove_uses_roomjid_in_room(void **state)
{
muc_init();
gchar* args[] = { "remove", NULL };
gchar *args[] = { "remove", NULL };
ProfMucWin muc_win;
muc_win.window.type = WIN_MUC;
muc_win.memcheck = PROFMUCWIN_MEMCHECK;
@@ -405,13 +388,12 @@ cmd_bookmark_remove_uses_roomjid_in_room(void** state)
muc_close();
}
void
cmd_bookmark_remove_uses_supplied_jid_in_room(void** state)
void cmd_bookmark_remove_uses_supplied_jid_in_room(void **state)
{
muc_init();
char* jid = "room1@conf.server";
gchar* args[] = { "remove", jid, NULL };
char *jid = "room1@conf.server";
gchar *args[] = { "remove", jid, NULL };
ProfMucWin muc_win;
muc_win.window.type = WIN_MUC;
muc_win.memcheck = PROFMUCWIN_MEMCHECK;

36
tests/unittests/test_cmd_bookmark.h
View File

@@ -1,18 +1,18 @@
void cmd_bookmark_shows_message_when_disconnected(void** state);
void cmd_bookmark_shows_message_when_disconnecting(void** state);
void cmd_bookmark_shows_message_when_connecting(void** state);
void cmd_bookmark_shows_message_when_undefined(void** state);
void cmd_bookmark_shows_usage_when_no_args(void** state);
void cmd_bookmark_list_shows_bookmarks(void** state);
void cmd_bookmark_add_shows_message_when_invalid_jid(void** state);
void cmd_bookmark_add_adds_bookmark_with_jid(void** state);
void cmd_bookmark_uses_roomjid_in_room(void** state);
void cmd_bookmark_add_uses_roomjid_in_room(void** state);
void cmd_bookmark_add_uses_supplied_jid_in_room(void** state);
void cmd_bookmark_remove_uses_roomjid_in_room(void** state);
void cmd_bookmark_remove_uses_supplied_jid_in_room(void** state);
void cmd_bookmark_add_adds_bookmark_with_jid_nick(void** state);
void cmd_bookmark_add_adds_bookmark_with_jid_autojoin(void** state);
void cmd_bookmark_add_adds_bookmark_with_jid_nick_autojoin(void** state);
void cmd_bookmark_remove_removes_bookmark(void** state);
void cmd_bookmark_remove_shows_message_when_no_bookmark(void** state);
void cmd_bookmark_shows_message_when_disconnected(void **state);
void cmd_bookmark_shows_message_when_disconnecting(void **state);
void cmd_bookmark_shows_message_when_connecting(void **state);
void cmd_bookmark_shows_message_when_undefined(void **state);
void cmd_bookmark_shows_usage_when_no_args(void **state);
void cmd_bookmark_list_shows_bookmarks(void **state);
void cmd_bookmark_add_shows_message_when_invalid_jid(void **state);
void cmd_bookmark_add_adds_bookmark_with_jid(void **state);
void cmd_bookmark_uses_roomjid_in_room(void **state);
void cmd_bookmark_add_uses_roomjid_in_room(void **state);
void cmd_bookmark_add_uses_supplied_jid_in_room(void **state);
void cmd_bookmark_remove_uses_roomjid_in_room(void **state);
void cmd_bookmark_remove_uses_supplied_jid_in_room(void **state);
void cmd_bookmark_add_adds_bookmark_with_jid_nick(void **state);
void cmd_bookmark_add_adds_bookmark_with_jid_autojoin(void **state);
void cmd_bookmark_add_adds_bookmark_with_jid_nick_autojoin(void **state);
void cmd_bookmark_remove_removes_bookmark(void **state);
void cmd_bookmark_remove_shows_message_when_no_bookmark(void **state);

146
tests/unittests/test_cmd_connect.c
View File

@@ -1,23 +1,22 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "xmpp/xmpp.h"
#include "ui/stub_ui.h"
#include "ui/ui.h"
#include "ui/stub_ui.h"
#include "command/cmd_funcs.h"
#include "config/accounts.h"
#define CMD_CONNECT "/connect"
static void
test_with_connection_status(jabber_conn_status_t status)
static void test_with_connection_status(jabber_conn_status_t status)
{
will_return(connection_get_status, status);
@@ -27,28 +26,24 @@ test_with_connection_status(jabber_conn_status_t status)
assert_true(result);
}
void
cmd_connect_shows_message_when_disconnecting(void** state)
void cmd_connect_shows_message_when_disconnecting(void **state)
{
test_with_connection_status(JABBER_DISCONNECTING);
}
void
cmd_connect_shows_message_when_connecting(void** state)
void cmd_connect_shows_message_when_connecting(void **state)
{
test_with_connection_status(JABBER_CONNECTING);
}
void
cmd_connect_shows_message_when_connected(void** state)
void cmd_connect_shows_message_when_connected(void **state)
{
test_with_connection_status(JABBER_CONNECTED);
}
void
cmd_connect_when_no_account(void** state)
void cmd_connect_when_no_account(void **state)
{
gchar* args[] = { "user@server.org", NULL };
gchar *args[] = { "user@server.org", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -69,10 +64,9 @@ cmd_connect_when_no_account(void** state)
assert_true(result);
}
void
cmd_connect_fail_message(void** state)
void cmd_connect_fail_message(void **state)
{
gchar* args[] = { "user@server.org", NULL };
gchar *args[] = { "user@server.org", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -95,10 +89,9 @@ cmd_connect_fail_message(void** state)
assert_true(result);
}
void
cmd_connect_lowercases_argument_with_no_account(void** state)
void cmd_connect_lowercases_argument_with_no_account(void **state)
{
gchar* args[] = { "USER@server.ORG", NULL };
gchar *args[] = { "USER@server.ORG", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -119,12 +112,11 @@ cmd_connect_lowercases_argument_with_no_account(void** state)
assert_true(result);
}
void
cmd_connect_lowercases_argument_with_account(void** state)
void cmd_connect_lowercases_argument_with_account(void **state)
{
gchar* args[] = { "Jabber_org", NULL };
ProfAccount* account = account_new("Jabber_org", "me@jabber.org", "password", NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
gchar *args[] = { "Jabber_org", NULL };
ProfAccount *account = account_new("Jabber_org", "me@jabber.org", "password", NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -140,12 +132,11 @@ cmd_connect_lowercases_argument_with_account(void** state)
assert_true(result);
}
void
cmd_connect_asks_password_when_not_in_account(void** state)
void cmd_connect_asks_password_when_not_in_account(void **state)
{
gchar* args[] = { "jabber_org", NULL };
ProfAccount* account = account_new("jabber_org", "me@jabber.org", NULL, NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
gchar *args[] = { "jabber_org", NULL };
ProfAccount *account = account_new("jabber_org", "me@jabber.org", NULL, NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -163,10 +154,9 @@ cmd_connect_asks_password_when_not_in_account(void** state)
assert_true(result);
}
void
cmd_connect_shows_usage_when_no_server_value(void** state)
void cmd_connect_shows_usage_when_no_server_value(void **state)
{
gchar* args[] = { "user@server.org", "server", NULL };
gchar *args[] = { "user@server.org", "server", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -177,10 +167,9 @@ cmd_connect_shows_usage_when_no_server_value(void** state)
assert_true(result);
}
void
cmd_connect_shows_usage_when_server_no_port_value(void** state)
void cmd_connect_shows_usage_when_server_no_port_value(void **state)
{
gchar* args[] = { "user@server.org", "server", "aserver", "port", NULL };
gchar *args[] = { "user@server.org", "server", "aserver", "port", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -191,10 +180,9 @@ cmd_connect_shows_usage_when_server_no_port_value(void** state)
assert_true(result);
}
void
cmd_connect_shows_usage_when_no_port_value(void** state)
void cmd_connect_shows_usage_when_no_port_value(void **state)
{
gchar* args[] = { "user@server.org", "port", NULL };
gchar *args[] = { "user@server.org", "port", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -205,10 +193,9 @@ cmd_connect_shows_usage_when_no_port_value(void** state)
assert_true(result);
}
void
cmd_connect_shows_usage_when_port_no_server_value(void** state)
void cmd_connect_shows_usage_when_port_no_server_value(void **state)
{
gchar* args[] = { "user@server.org", "port", "5678", "server", NULL };
gchar *args[] = { "user@server.org", "port", "5678", "server", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -219,10 +206,9 @@ cmd_connect_shows_usage_when_port_no_server_value(void** state)
assert_true(result);
}
void
cmd_connect_shows_message_when_port_0(void** state)
void cmd_connect_shows_message_when_port_0(void **state)
{
gchar* args[] = { "user@server.org", "port", "0", NULL };
gchar *args[] = { "user@server.org", "port", "0", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -233,10 +219,9 @@ cmd_connect_shows_message_when_port_0(void** state)
assert_true(result);
}
void
cmd_connect_shows_message_when_port_minus1(void** state)
void cmd_connect_shows_message_when_port_minus1(void **state)
{
gchar* args[] = { "user@server.org", "port", "-1", NULL };
gchar *args[] = { "user@server.org", "port", "-1", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -247,10 +232,9 @@ cmd_connect_shows_message_when_port_minus1(void** state)
assert_true(result);
}
void
cmd_connect_shows_message_when_port_65536(void** state)
void cmd_connect_shows_message_when_port_65536(void **state)
{
gchar* args[] = { "user@server.org", "port", "65536", NULL };
gchar *args[] = { "user@server.org", "port", "65536", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -261,10 +245,9 @@ cmd_connect_shows_message_when_port_65536(void** state)
assert_true(result);
}
void
cmd_connect_shows_message_when_port_contains_chars(void** state)
void cmd_connect_shows_message_when_port_contains_chars(void **state)
{
gchar* args[] = { "user@server.org", "port", "52f66", NULL };
gchar *args[] = { "user@server.org", "port", "52f66", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -275,10 +258,9 @@ cmd_connect_shows_message_when_port_contains_chars(void** state)
assert_true(result);
}
void
cmd_connect_shows_usage_when_server_provided_twice(void** state)
void cmd_connect_shows_usage_when_server_provided_twice(void **state)
{
gchar* args[] = { "user@server.org", "server", "server1", "server", "server2", NULL };
gchar *args[] = { "user@server.org", "server", "server1", "server", "server2", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -289,10 +271,9 @@ cmd_connect_shows_usage_when_server_provided_twice(void** state)
assert_true(result);
}
void
cmd_connect_shows_usage_when_port_provided_twice(void** state)
void cmd_connect_shows_usage_when_port_provided_twice(void **state)
{
gchar* args[] = { "user@server.org", "port", "1111", "port", "1111", NULL };
gchar *args[] = { "user@server.org", "port", "1111", "port", "1111", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -303,10 +284,9 @@ cmd_connect_shows_usage_when_port_provided_twice(void** state)
assert_true(result);
}
void
cmd_connect_shows_usage_when_invalid_first_property(void** state)
void cmd_connect_shows_usage_when_invalid_first_property(void **state)
{
gchar* args[] = { "user@server.org", "wrong", "server", NULL };
gchar *args[] = { "user@server.org", "wrong", "server", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -317,10 +297,9 @@ cmd_connect_shows_usage_when_invalid_first_property(void** state)
assert_true(result);
}
void
cmd_connect_shows_usage_when_invalid_second_property(void** state)
void cmd_connect_shows_usage_when_invalid_second_property(void **state)
{
gchar* args[] = { "user@server.org", "server", "aserver", "wrong", "1234", NULL };
gchar *args[] = { "user@server.org", "server", "aserver", "wrong", "1234", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -331,10 +310,9 @@ cmd_connect_shows_usage_when_invalid_second_property(void** state)
assert_true(result);
}
void
cmd_connect_with_server_when_provided(void** state)
void cmd_connect_with_server_when_provided(void **state)
{
gchar* args[] = { "user@server.org", "server", "aserver", NULL };
gchar *args[] = { "user@server.org", "server", "aserver", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -355,10 +333,9 @@ cmd_connect_with_server_when_provided(void** state)
assert_true(result);
}
void
cmd_connect_with_port_when_provided(void** state)
void cmd_connect_with_port_when_provided(void **state)
{
gchar* args[] = { "user@server.org", "port", "5432", NULL };
gchar *args[] = { "user@server.org", "port", "5432", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -379,10 +356,9 @@ cmd_connect_with_port_when_provided(void** state)
assert_true(result);
}
void
cmd_connect_with_server_and_port_when_provided(void** state)
void cmd_connect_with_server_and_port_when_provided(void **state)
{
gchar* args[] = { "user@server.org", "port", "5432", "server", "aserver", NULL };
gchar *args[] = { "user@server.org", "port", "5432", "server", "aserver", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -403,12 +379,11 @@ cmd_connect_with_server_and_port_when_provided(void** state)
assert_true(result);
}
void
cmd_connect_shows_message_when_connecting_with_account(void** state)
void cmd_connect_shows_message_when_connecting_with_account(void **state)
{
gchar* args[] = { "jabber_org", NULL };
ProfAccount* account = account_new("jabber_org", "user@jabber.org", "password", NULL,
TRUE, NULL, 0, "laptop", NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
gchar *args[] = { "jabber_org", NULL };
ProfAccount *account = account_new("jabber_org", "user@jabber.org", "password", NULL,
TRUE, NULL, 0, "laptop", NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -424,12 +399,11 @@ cmd_connect_shows_message_when_connecting_with_account(void** state)
assert_true(result);
}
void
cmd_connect_connects_with_account(void** state)
void cmd_connect_connects_with_account(void **state)
{
gchar* args[] = { "jabber_org", NULL };
ProfAccount* account = account_new("jabber_org", "me@jabber.org", "password", NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
gchar *args[] = { "jabber_org", NULL };
ProfAccount *account = account_new("jabber_org", "me@jabber.org", "password", NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
will_return(connection_get_status, JABBER_DISCONNECTED);

54
tests/unittests/test_cmd_connect.h
View File

@@ -1,27 +1,27 @@
void cmd_connect_shows_message_when_disconnecting(void** state);
void cmd_connect_shows_message_when_connecting(void** state);
void cmd_connect_shows_message_when_connected(void** state);
void cmd_connect_shows_message_when_undefined(void** state);
void cmd_connect_when_no_account(void** state);
void cmd_connect_with_altdomain_when_provided(void** state);
void cmd_connect_fail_message(void** state);
void cmd_connect_lowercases_argument_with_no_account(void** state);
void cmd_connect_lowercases_argument_with_account(void** state);
void cmd_connect_asks_password_when_not_in_account(void** state);
void cmd_connect_shows_message_when_connecting_with_account(void** state);
void cmd_connect_connects_with_account(void** state);
void cmd_connect_shows_usage_when_no_server_value(void** state);
void cmd_connect_shows_usage_when_server_no_port_value(void** state);
void cmd_connect_shows_usage_when_no_port_value(void** state);
void cmd_connect_shows_usage_when_port_no_server_value(void** state);
void cmd_connect_shows_message_when_port_0(void** state);
void cmd_connect_shows_message_when_port_minus1(void** state);
void cmd_connect_shows_message_when_port_65536(void** state);
void cmd_connect_shows_message_when_port_contains_chars(void** state);
void cmd_connect_with_server_when_provided(void** state);
void cmd_connect_with_port_when_provided(void** state);
void cmd_connect_with_server_and_port_when_provided(void** state);
void cmd_connect_shows_usage_when_server_provided_twice(void** state);
void cmd_connect_shows_usage_when_port_provided_twice(void** state);
void cmd_connect_shows_usage_when_invalid_first_property(void** state);
void cmd_connect_shows_usage_when_invalid_second_property(void** state);
void cmd_connect_shows_message_when_disconnecting(void **state);
void cmd_connect_shows_message_when_connecting(void **state);
void cmd_connect_shows_message_when_connected(void **state);
void cmd_connect_shows_message_when_undefined(void **state);
void cmd_connect_when_no_account(void **state);
void cmd_connect_with_altdomain_when_provided(void **state);
void cmd_connect_fail_message(void **state);
void cmd_connect_lowercases_argument_with_no_account(void **state);
void cmd_connect_lowercases_argument_with_account(void **state);
void cmd_connect_asks_password_when_not_in_account(void **state);
void cmd_connect_shows_message_when_connecting_with_account(void **state);
void cmd_connect_connects_with_account(void **state);
void cmd_connect_shows_usage_when_no_server_value(void **state);
void cmd_connect_shows_usage_when_server_no_port_value(void **state);
void cmd_connect_shows_usage_when_no_port_value(void **state);
void cmd_connect_shows_usage_when_port_no_server_value(void **state);
void cmd_connect_shows_message_when_port_0(void **state);
void cmd_connect_shows_message_when_port_minus1(void **state);
void cmd_connect_shows_message_when_port_65536(void **state);
void cmd_connect_shows_message_when_port_contains_chars(void **state);
void cmd_connect_with_server_when_provided(void **state);
void cmd_connect_with_port_when_provided(void **state);
void cmd_connect_with_server_and_port_when_provided(void **state);
void cmd_connect_shows_usage_when_server_provided_twice(void **state);
void cmd_connect_shows_usage_when_port_provided_twice(void **state);
void cmd_connect_shows_usage_when_invalid_first_property(void **state);
void cmd_connect_shows_usage_when_invalid_second_property(void **state);

15
tests/unittests/test_cmd_disconnect.c
View File

@@ -1,21 +1,20 @@
#include <cmocka.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include "command/cmd_funcs.h"
#include "xmpp/chat_session.h"
#include "xmpp/roster_list.h"
#include "command/cmd_funcs.h"
#include "xmpp/xmpp.h"
#include "xmpp/roster_list.h"
#include "ui/stub_ui.h"
#define CMD_DISCONNECT "/disconnect"
void
clears_chat_sessions(void** state)
void clears_chat_sessions(void **state)
{
chat_sessions_init();
roster_create();
@@ -30,8 +29,8 @@ clears_chat_sessions(void** state)
assert_true(result);
ChatSession* session1 = chat_session_get("bob@server.org");
ChatSession* session2 = chat_session_get("mike@server.org");
ChatSession *session1 = chat_session_get("bob@server.org");
ChatSession *session2 = chat_session_get("mike@server.org");
assert_null(session1);
assert_null(session2);
}

2
tests/unittests/test_cmd_disconnect.h
View File

@@ -1 +1 @@
void clears_chat_sessions(void** state);
void clears_chat_sessions(void **state);

95
tests/unittests/test_cmd_join.c
View File

@@ -1,15 +1,15 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "xmpp/xmpp.h"
#include "ui/stub_ui.h"
#include "ui/ui.h"
#include "ui/stub_ui.h"
#include "config/accounts.h"
@@ -18,8 +18,7 @@
#define CMD_JOIN "/join"
static void
test_with_connection_status(jabber_conn_status_t status)
static void test_with_connection_status(jabber_conn_status_t status)
{
will_return(connection_get_status, status);
@@ -29,28 +28,24 @@ test_with_connection_status(jabber_conn_status_t status)
assert_true(result);
}
void
cmd_join_shows_message_when_disconnecting(void** state)
void cmd_join_shows_message_when_disconnecting(void **state)
{
test_with_connection_status(JABBER_DISCONNECTING);
}
void
cmd_join_shows_message_when_connecting(void** state)
void cmd_join_shows_message_when_connecting(void **state)
{
test_with_connection_status(JABBER_CONNECTING);
}
void
cmd_join_shows_message_when_disconnected(void** state)
void cmd_join_shows_message_when_disconnected(void **state)
{
test_with_connection_status(JABBER_DISCONNECTED);
}
void
cmd_join_shows_error_message_when_invalid_room_jid(void** state)
void cmd_join_shows_error_message_when_invalid_room_jid(void **state)
{
gchar* args[] = { "//@@/", NULL };
gchar *args[] = { "//@@/", NULL };
will_return(connection_get_status, JABBER_CONNECTED);
@@ -61,17 +56,16 @@ cmd_join_shows_error_message_when_invalid_room_jid(void** state)
assert_true(result);
}
void
cmd_join_uses_account_mucservice_when_no_service_specified(void** state)
void cmd_join_uses_account_mucservice_when_no_service_specified(void **state)
{
char* account_name = "an_account";
char* room = "room";
char* nick = "bob";
char* account_service = "conference.server.org";
char* expected_room = "room@conference.server.org";
gchar* args[] = { room, "nick", nick, NULL };
ProfAccount* account = account_new(account_name, "user@server.org", NULL, NULL,
TRUE, NULL, 0, "laptop", NULL, NULL, 0, 0, 0, 0, 0, account_service, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
char *account_name = "an_account";
char *room = "room";
char *nick = "bob";
char *account_service = "conference.server.org";
char *expected_room = "room@conference.server.org";
gchar *args[] = { room, "nick", nick, NULL };
ProfAccount *account = account_new(account_name, "user@server.org", NULL, NULL,
TRUE, NULL, 0, "laptop", NULL, NULL, 0, 0, 0, 0, 0, account_service, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
muc_init();
@@ -91,15 +85,14 @@ cmd_join_uses_account_mucservice_when_no_service_specified(void** state)
muc_close();
}
void
cmd_join_uses_supplied_nick(void** state)
void cmd_join_uses_supplied_nick(void **state)
{
char* account_name = "an_account";
char* room = "room@conf.server.org";
char* nick = "bob";
gchar* args[] = { room, "nick", nick, NULL };
ProfAccount* account = account_new(account_name, "user@server.org", NULL, NULL,
TRUE, NULL, 0, "laptop", NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
char *account_name = "an_account";
char *room = "room@conf.server.org";
char *nick = "bob";
gchar *args[] = { room, "nick", nick, NULL };
ProfAccount *account = account_new(account_name, "user@server.org", NULL, NULL,
TRUE, NULL, 0, "laptop", NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
muc_init();
@@ -119,15 +112,14 @@ cmd_join_uses_supplied_nick(void** state)
muc_close();
}
void
cmd_join_uses_account_nick_when_not_supplied(void** state)
void cmd_join_uses_account_nick_when_not_supplied(void **state)
{
char* account_name = "an_account";
char* room = "room2@conf.server.org";
char* account_nick = "a_nick";
gchar* args[] = { room, NULL };
ProfAccount* account = account_new(account_name, "user@server.org", NULL, NULL,
TRUE, NULL, 0, "laptop", NULL, NULL, 0, 0, 0, 0, 0, NULL, account_nick, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
char *account_name = "an_account";
char *room = "room2@conf.server.org";
char *account_nick = "a_nick";
gchar *args[] = { room, NULL };
ProfAccount *account = account_new(account_name, "user@server.org", NULL, NULL,
TRUE, NULL, 0, "laptop", NULL, NULL, 0, 0, 0, 0, 0, NULL, account_nick, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
muc_init();
@@ -147,18 +139,17 @@ cmd_join_uses_account_nick_when_not_supplied(void** state)
muc_close();
}
void
cmd_join_uses_password_when_supplied(void** state)
void cmd_join_uses_password_when_supplied(void **state)
{
char* account_name = "an_account";
char* room = "room";
char* password = "a_password";
char* account_nick = "a_nick";
char* account_service = "a_service";
char* expected_room = "room@a_service";
gchar* args[] = { room, "password", password, NULL };
ProfAccount* account = account_new(account_name, "user@server.org", NULL, NULL,
TRUE, NULL, 0, "laptop", NULL, NULL, 0, 0, 0, 0, 0, account_service, account_nick, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
char *account_name = "an_account";
char *room = "room";
char *password = "a_password";
char *account_nick = "a_nick";
char *account_service = "a_service";
char *expected_room = "room@a_service";
gchar *args[] = { room, "password", password, NULL };
ProfAccount *account = account_new(account_name, "user@server.org", NULL, NULL,
TRUE, NULL, 0, "laptop", NULL, NULL, 0, 0, 0, 0, 0, account_service, account_nick, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
muc_init();

18
tests/unittests/test_cmd_join.h
View File

@@ -1,9 +1,9 @@
void cmd_join_shows_message_when_disconnecting(void** state);
void cmd_join_shows_message_when_connecting(void** state);
void cmd_join_shows_message_when_disconnected(void** state);
void cmd_join_shows_message_when_undefined(void** state);
void cmd_join_shows_error_message_when_invalid_room_jid(void** state);
void cmd_join_uses_account_mucservice_when_no_service_specified(void** state);
void cmd_join_uses_supplied_nick(void** state);
void cmd_join_uses_account_nick_when_not_supplied(void** state);
void cmd_join_uses_password_when_supplied(void** state);
void cmd_join_shows_message_when_disconnecting(void **state);
void cmd_join_shows_message_when_connecting(void **state);
void cmd_join_shows_message_when_disconnected(void **state);
void cmd_join_shows_message_when_undefined(void **state);
void cmd_join_shows_error_message_when_invalid_room_jid(void **state);
void cmd_join_uses_account_mucservice_when_no_service_specified(void **state);
void cmd_join_uses_supplied_nick(void **state);
void cmd_join_uses_account_nick_when_not_supplied(void **state);
void cmd_join_uses_password_when_supplied(void **state);

180
tests/unittests/test_cmd_otr.c
View File

@@ -1,16 +1,16 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "config.h"
#ifdef HAVE_LIBOTR
#include "otr/otr.h"
#include <libotr/proto.h>
#include "otr/otr.h"
#endif
#include "config/preferences.h"
@@ -20,16 +20,15 @@
#include "ui/window_list.h"
#include "xmpp/xmpp.h"
#include "ui/stub_ui.h"
#include "ui/ui.h"
#include "ui/stub_ui.h"
#define CMD_OTR "/otr"
#ifdef HAVE_LIBOTR
void
cmd_otr_log_shows_usage_when_no_args(void** state)
void cmd_otr_log_shows_usage_when_no_args(void **state)
{
gchar* args[] = { "log", NULL };
gchar *args[] = { "log", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_OTR);
@@ -37,10 +36,9 @@ cmd_otr_log_shows_usage_when_no_args(void** state)
assert_true(result);
}
void
cmd_otr_log_shows_usage_when_invalid_subcommand(void** state)
void cmd_otr_log_shows_usage_when_invalid_subcommand(void **state)
{
gchar* args[] = { "log", "wrong", NULL };
gchar *args[] = { "log", "wrong", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_OTR);
@@ -48,27 +46,25 @@ cmd_otr_log_shows_usage_when_invalid_subcommand(void** state)
assert_true(result);
}
void
cmd_otr_log_on_enables_logging(void** state)
void cmd_otr_log_on_enables_logging(void **state)
{
gchar* args[] = { "log", "on", NULL };
gchar *args[] = { "log", "on", NULL };
prefs_set_string(PREF_OTR_LOG, "off");
prefs_set_boolean(PREF_CHLOG, TRUE);
expect_cons_show("OTR messages will be logged as plaintext.");
gboolean result = cmd_otr_log(NULL, CMD_OTR, args);
char* pref_otr_log = prefs_get_string(PREF_OTR_LOG);
char *pref_otr_log = prefs_get_string(PREF_OTR_LOG);
assert_true(result);
assert_string_equal("on", pref_otr_log);
g_free(pref_otr_log);
}
void
cmd_otr_log_on_shows_warning_when_chlog_disabled(void** state)
void cmd_otr_log_on_shows_warning_when_chlog_disabled(void **state)
{
gchar* args[] = { "log", "on", NULL };
gchar *args[] = { "log", "on", NULL };
prefs_set_string(PREF_OTR_LOG, "off");
prefs_set_boolean(PREF_CHLOG, FALSE);
@@ -79,44 +75,41 @@ cmd_otr_log_on_shows_warning_when_chlog_disabled(void** state)
assert_true(result);
}
void
cmd_otr_log_off_disables_logging(void** state)
void cmd_otr_log_off_disables_logging(void **state)
{
gchar* args[] = { "log", "off", NULL };
gchar *args[] = { "log", "off", NULL };
prefs_set_string(PREF_OTR_LOG, "on");
prefs_set_boolean(PREF_CHLOG, TRUE);
expect_cons_show("OTR message logging disabled.");
gboolean result = cmd_otr_log(NULL, CMD_OTR, args);
char* pref_otr_log = prefs_get_string(PREF_OTR_LOG);
char *pref_otr_log = prefs_get_string(PREF_OTR_LOG);
assert_true(result);
assert_string_equal("off", pref_otr_log);
g_free(pref_otr_log);
}
void
cmd_otr_redact_redacts_logging(void** state)
void cmd_otr_redact_redacts_logging(void **state)
{
gchar* args[] = { "log", "redact", NULL };
gchar *args[] = { "log", "redact", NULL };
prefs_set_string(PREF_OTR_LOG, "on");
prefs_set_boolean(PREF_CHLOG, TRUE);
expect_cons_show("OTR messages will be logged as '[redacted]'.");
gboolean result = cmd_otr_log(NULL, CMD_OTR, args);
char* pref_otr_log = prefs_get_string(PREF_OTR_LOG);
char *pref_otr_log = prefs_get_string(PREF_OTR_LOG);
assert_true(result);
assert_string_equal("redact", pref_otr_log);
g_free(pref_otr_log);
}
void
cmd_otr_log_redact_shows_warning_when_chlog_disabled(void** state)
void cmd_otr_log_redact_shows_warning_when_chlog_disabled(void **state)
{
gchar* args[] = { "log", "redact", NULL };
gchar *args[] = { "log", "redact", NULL };
prefs_set_string(PREF_OTR_LOG, "off");
prefs_set_boolean(PREF_CHLOG, FALSE);
@@ -127,12 +120,11 @@ cmd_otr_log_redact_shows_warning_when_chlog_disabled(void** state)
assert_true(result);
}
void
cmd_otr_libver_shows_libotr_version(void** state)
void cmd_otr_libver_shows_libotr_version(void **state)
{
gchar* args[] = { "libver", NULL };
char* version = "9.9.9";
GString* message = g_string_new("Using libotr version ");
gchar *args[] = { "libver", NULL };
char *version = "9.9.9";
GString *message = g_string_new("Using libotr version ");
g_string_append(message, version);
will_return(otr_libotr_version, version);
@@ -145,10 +137,9 @@ cmd_otr_libver_shows_libotr_version(void** state)
g_string_free(message, TRUE);
}
void
cmd_otr_gen_shows_message_when_not_connected(void** state)
void cmd_otr_gen_shows_message_when_not_connected(void **state)
{
gchar* args[] = { "gen", NULL };
gchar *args[] = { "gen", NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -158,45 +149,40 @@ cmd_otr_gen_shows_message_when_not_connected(void** state)
assert_true(result);
}
static void
test_with_command_and_connection_status(char* command, void* cmd_func, jabber_conn_status_t status)
static void test_with_command_and_connection_status(char *command, void *cmd_func, jabber_conn_status_t status)
{
gchar* args[] = { command, NULL };
gchar *args[] = { command, NULL };
will_return(connection_get_status, status);
expect_cons_show("You must be connected with an account to load OTR information.");
gboolean (*func)(ProfWin * window, const char* const command, gchar** args) = cmd_func;
gboolean (*func)(ProfWin *window, const char *const command, gchar **args) = cmd_func;
gboolean result = func(NULL, CMD_OTR, args);
assert_true(result);
}
void
cmd_otr_gen_shows_message_when_disconnected(void** state)
void cmd_otr_gen_shows_message_when_disconnected(void **state)
{
test_with_command_and_connection_status("gen", cmd_otr_gen, JABBER_DISCONNECTED);
}
void
cmd_otr_gen_shows_message_when_connecting(void** state)
void cmd_otr_gen_shows_message_when_connecting(void **state)
{
test_with_command_and_connection_status("gen", cmd_otr_gen, JABBER_CONNECTING);
}
void
cmd_otr_gen_shows_message_when_disconnecting(void** state)
void cmd_otr_gen_shows_message_when_disconnecting(void **state)
{
test_with_command_and_connection_status("gen", cmd_otr_gen, JABBER_DISCONNECTING);
}
void
cmd_otr_gen_generates_key_for_connected_account(void** state)
void cmd_otr_gen_generates_key_for_connected_account(void **state)
{
gchar* args[] = { "gen", NULL };
char* account_name = "myaccount";
ProfAccount* account = account_new(account_name, "me@jabber.org", NULL, NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
gchar *args[] = { "gen", NULL };
char *account_name = "myaccount";
ProfAccount *account = account_new(account_name, "me@jabber.org", NULL, NULL,
TRUE, NULL, 0, NULL, NULL, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
will_return(connection_get_status, JABBER_CONNECTED);
will_return(session_get_account_name, account_name);
@@ -211,28 +197,24 @@ cmd_otr_gen_generates_key_for_connected_account(void** state)
assert_true(result);
}
void
cmd_otr_myfp_shows_message_when_disconnected(void** state)
void cmd_otr_myfp_shows_message_when_disconnected(void **state)
{
test_with_command_and_connection_status("myfp", cmd_otr_myfp, JABBER_DISCONNECTED);
}
void
cmd_otr_myfp_shows_message_when_connecting(void** state)
void cmd_otr_myfp_shows_message_when_connecting(void **state)
{
test_with_command_and_connection_status("myfp", cmd_otr_myfp, JABBER_CONNECTING);
}
void
cmd_otr_myfp_shows_message_when_disconnecting(void** state)
void cmd_otr_myfp_shows_message_when_disconnecting(void **state)
{
test_with_command_and_connection_status("myfp", cmd_otr_myfp, JABBER_DISCONNECTING);
}
void
cmd_otr_myfp_shows_message_when_no_key(void** state)
void cmd_otr_myfp_shows_message_when_no_key(void **state)
{
gchar* args[] = { "myfp", NULL };
gchar *args[] = { "myfp", NULL };
will_return(connection_get_status, JABBER_CONNECTED);
will_return(otr_key_loaded, FALSE);
@@ -243,12 +225,11 @@ cmd_otr_myfp_shows_message_when_no_key(void** state)
assert_true(result);
}
void
cmd_otr_myfp_shows_my_fingerprint(void** state)
void cmd_otr_myfp_shows_my_fingerprint(void **state)
{
char* fingerprint = "AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD EEEEEEEE";
gchar* args[] = { "myfp", NULL };
GString* message = g_string_new("Your OTR fingerprint: ");
char *fingerprint = "AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD EEEEEEEE";
gchar *args[] = { "myfp", NULL };
GString *message = g_string_new("Your OTR fingerprint: ");
g_string_append(message, fingerprint);
will_return(connection_get_status, JABBER_CONNECTED);
@@ -266,7 +247,7 @@ cmd_otr_myfp_shows_my_fingerprint(void** state)
static void
test_cmd_otr_theirfp_from_wintype(win_type_t wintype)
{
gchar* args[] = { "theirfp", NULL };
gchar *args[] = { "theirfp", NULL };
ProfWin window;
window.type = wintype;
window.layout = NULL;
@@ -281,28 +262,24 @@ test_cmd_otr_theirfp_from_wintype(win_type_t wintype)
assert_true(result);
}
void
cmd_otr_theirfp_shows_message_when_in_console(void** state)
void cmd_otr_theirfp_shows_message_when_in_console(void **state)
{
test_cmd_otr_theirfp_from_wintype(WIN_CONSOLE);
}
void
cmd_otr_theirfp_shows_message_when_in_muc(void** state)
void cmd_otr_theirfp_shows_message_when_in_muc(void **state)
{
test_cmd_otr_theirfp_from_wintype(WIN_MUC);
}
void
cmd_otr_theirfp_shows_message_when_in_private(void** state)
void cmd_otr_theirfp_shows_message_when_in_private(void **state)
{
test_cmd_otr_theirfp_from_wintype(WIN_PRIVATE);
}
void
cmd_otr_theirfp_shows_message_when_non_otr_chat_window(void** state)
void cmd_otr_theirfp_shows_message_when_non_otr_chat_window(void **state)
{
gchar* args[] = { "theirfp", NULL };
gchar *args[] = { "theirfp", NULL };
ProfWin window;
window.type = WIN_CHAT;
@@ -323,13 +300,12 @@ cmd_otr_theirfp_shows_message_when_non_otr_chat_window(void** state)
assert_true(result);
}
void
cmd_otr_theirfp_shows_fingerprint(void** state)
void cmd_otr_theirfp_shows_fingerprint(void **state)
{
char* recipient = "someone@chat.com";
char* fingerprint = "AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD EEEEEEEE";
gchar* args[] = { "theirfp", NULL };
GString* message = g_string_new(recipient);
char *recipient = "someone@chat.com";
char *fingerprint = "AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD EEEEEEEE";
gchar *args[] = { "theirfp", NULL };
GString *message = g_string_new(recipient);
g_string_append(message, "'s OTR fingerprint: ");
g_string_append(message, fingerprint);
@@ -360,7 +336,7 @@ cmd_otr_theirfp_shows_fingerprint(void** state)
static void
test_cmd_otr_start_from_wintype(win_type_t wintype)
{
gchar* args[] = { "start", NULL };
gchar *args[] = { "start", NULL };
ProfWin window;
window.type = wintype;
window.layout = NULL;
@@ -374,29 +350,25 @@ test_cmd_otr_start_from_wintype(win_type_t wintype)
assert_true(result);
}
void
cmd_otr_start_shows_message_when_in_console(void** state)
void cmd_otr_start_shows_message_when_in_console(void **state)
{
test_cmd_otr_start_from_wintype(WIN_CONSOLE);
}
void
cmd_otr_start_shows_message_when_in_muc(void** state)
void cmd_otr_start_shows_message_when_in_muc(void **state)
{
test_cmd_otr_start_from_wintype(WIN_MUC);
}
void
cmd_otr_start_shows_message_when_in_private(void** state)
void cmd_otr_start_shows_message_when_in_private(void **state)
{
test_cmd_otr_start_from_wintype(WIN_PRIVATE);
}
void
cmd_otr_start_shows_message_when_already_started(void** state)
void cmd_otr_start_shows_message_when_already_started(void **state)
{
char* recipient = "someone@server.org";
gchar* args[] = { "start", NULL };
char *recipient = "someone@server.org";
gchar *args[] = { "start", NULL };
will_return(connection_get_status, JABBER_CONNECTED);
@@ -417,11 +389,10 @@ cmd_otr_start_shows_message_when_already_started(void** state)
assert_true(result);
}
void
cmd_otr_start_shows_message_when_no_key(void** state)
void cmd_otr_start_shows_message_when_no_key(void **state)
{
char* recipient = "someone@server.org";
gchar* args[] = { "start", NULL };
char *recipient = "someone@server.org";
gchar *args[] = { "start", NULL };
will_return(connection_get_status, JABBER_CONNECTED);
will_return(otr_key_loaded, FALSE);
@@ -444,11 +415,11 @@ cmd_otr_start_shows_message_when_no_key(void** state)
}
void
cmd_otr_start_sends_otr_query_message_to_current_recipeint(void** state)
cmd_otr_start_sends_otr_query_message_to_current_recipeint(void **state)
{
char* recipient = "buddy@chat.com";
char* query_message = "?OTR?";
gchar* args[] = { "start", NULL };
char *recipient = "buddy@chat.com";
char *query_message = "?OTR?";
gchar *args[] = { "start", NULL };
ProfWin window;
window.type = WIN_CHAT;
@@ -473,10 +444,9 @@ cmd_otr_start_sends_otr_query_message_to_current_recipeint(void** state)
}
#else
void
cmd_otr_shows_message_when_otr_unsupported(void** state)
void cmd_otr_shows_message_when_otr_unsupported(void **state)
{
gchar* args[] = { "gen", NULL };
gchar *args[] = { "gen", NULL };
expect_cons_show("This version of Profanity has not been built with OTR support enabled");

64
tests/unittests/test_cmd_otr.h
View File

@@ -1,37 +1,37 @@
#include "config.h"
#ifdef HAVE_LIBOTR
void cmd_otr_log_shows_usage_when_no_args(void** state);
void cmd_otr_log_shows_usage_when_invalid_subcommand(void** state);
void cmd_otr_log_on_enables_logging(void** state);
void cmd_otr_log_off_disables_logging(void** state);
void cmd_otr_redact_redacts_logging(void** state);
void cmd_otr_log_on_shows_warning_when_chlog_disabled(void** state);
void cmd_otr_log_redact_shows_warning_when_chlog_disabled(void** state);
void cmd_otr_libver_shows_libotr_version(void** state);
void cmd_otr_gen_shows_message_when_not_connected(void** state);
void cmd_otr_gen_generates_key_for_connected_account(void** state);
void cmd_otr_gen_shows_message_when_disconnected(void** state);
void cmd_otr_gen_shows_message_when_undefined(void** state);
void cmd_otr_gen_shows_message_when_connecting(void** state);
void cmd_otr_gen_shows_message_when_disconnecting(void** state);
void cmd_otr_myfp_shows_message_when_disconnected(void** state);
void cmd_otr_myfp_shows_message_when_undefined(void** state);
void cmd_otr_myfp_shows_message_when_connecting(void** state);
void cmd_otr_myfp_shows_message_when_disconnecting(void** state);
void cmd_otr_myfp_shows_message_when_no_key(void** state);
void cmd_otr_myfp_shows_my_fingerprint(void** state);
void cmd_otr_theirfp_shows_message_when_in_console(void** state);
void cmd_otr_theirfp_shows_message_when_in_muc(void** state);
void cmd_otr_theirfp_shows_message_when_in_private(void** state);
void cmd_otr_theirfp_shows_message_when_non_otr_chat_window(void** state);
void cmd_otr_theirfp_shows_fingerprint(void** state);
void cmd_otr_start_shows_message_when_in_console(void** state);
void cmd_otr_start_shows_message_when_in_muc(void** state);
void cmd_otr_start_shows_message_when_in_private(void** state);
void cmd_otr_start_shows_message_when_already_started(void** state);
void cmd_otr_start_shows_message_when_no_key(void** state);
void cmd_otr_start_sends_otr_query_message_to_current_recipeint(void** state);
void cmd_otr_log_shows_usage_when_no_args(void **state);
void cmd_otr_log_shows_usage_when_invalid_subcommand(void **state);
void cmd_otr_log_on_enables_logging(void **state);
void cmd_otr_log_off_disables_logging(void **state);
void cmd_otr_redact_redacts_logging(void **state);
void cmd_otr_log_on_shows_warning_when_chlog_disabled(void **state);
void cmd_otr_log_redact_shows_warning_when_chlog_disabled(void **state);
void cmd_otr_libver_shows_libotr_version(void **state);
void cmd_otr_gen_shows_message_when_not_connected(void **state);
void cmd_otr_gen_generates_key_for_connected_account(void **state);
void cmd_otr_gen_shows_message_when_disconnected(void **state);
void cmd_otr_gen_shows_message_when_undefined(void **state);
void cmd_otr_gen_shows_message_when_connecting(void **state);
void cmd_otr_gen_shows_message_when_disconnecting(void **state);
void cmd_otr_myfp_shows_message_when_disconnected(void **state);
void cmd_otr_myfp_shows_message_when_undefined(void **state);
void cmd_otr_myfp_shows_message_when_connecting(void **state);
void cmd_otr_myfp_shows_message_when_disconnecting(void **state);
void cmd_otr_myfp_shows_message_when_no_key(void **state);
void cmd_otr_myfp_shows_my_fingerprint(void **state);
void cmd_otr_theirfp_shows_message_when_in_console(void **state);
void cmd_otr_theirfp_shows_message_when_in_muc(void **state);
void cmd_otr_theirfp_shows_message_when_in_private(void **state);
void cmd_otr_theirfp_shows_message_when_non_otr_chat_window(void **state);
void cmd_otr_theirfp_shows_fingerprint(void **state);
void cmd_otr_start_shows_message_when_in_console(void **state);
void cmd_otr_start_shows_message_when_in_muc(void **state);
void cmd_otr_start_shows_message_when_in_private(void **state);
void cmd_otr_start_shows_message_when_already_started(void **state);
void cmd_otr_start_shows_message_when_no_key(void **state);
void cmd_otr_start_sends_otr_query_message_to_current_recipeint(void **state);
#else
void cmd_otr_shows_message_when_otr_unsupported(void** state);
void cmd_otr_shows_message_when_otr_unsupported(void **state);
#endif

50
tests/unittests/test_cmd_pgp.c
View File

@@ -1,10 +1,10 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "config.h"
@@ -16,10 +16,9 @@
#define CMD_PGP "/pgp"
#ifdef HAVE_LIBGPGME
void
cmd_pgp_shows_usage_when_no_args(void** state)
void cmd_pgp_shows_usage_when_no_args(void **state)
{
gchar* args[] = { NULL };
gchar *args[] = { NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_PGP);
@@ -27,10 +26,9 @@ cmd_pgp_shows_usage_when_no_args(void** state)
assert_true(result);
}
void
cmd_pgp_start_shows_message_when_connection(jabber_conn_status_t conn_status)
void cmd_pgp_start_shows_message_when_connection(jabber_conn_status_t conn_status)
{
gchar* args[] = { "start", NULL };
gchar *args[] = { "start", NULL };
ProfWin window;
window.type = WIN_CHAT;
@@ -42,28 +40,24 @@ cmd_pgp_start_shows_message_when_connection(jabber_conn_status_t conn_status)
assert_true(result);
}
void
cmd_pgp_start_shows_message_when_disconnected(void** state)
void cmd_pgp_start_shows_message_when_disconnected(void **state)
{
cmd_pgp_start_shows_message_when_connection(JABBER_DISCONNECTED);
}
void
cmd_pgp_start_shows_message_when_disconnecting(void** state)
void cmd_pgp_start_shows_message_when_disconnecting(void **state)
{
cmd_pgp_start_shows_message_when_connection(JABBER_DISCONNECTING);
}
void
cmd_pgp_start_shows_message_when_connecting(void** state)
void cmd_pgp_start_shows_message_when_connecting(void **state)
{
cmd_pgp_start_shows_message_when_connection(JABBER_CONNECTING);
}
void
cmd_pgp_start_shows_message_when_no_arg_in_wintype(win_type_t wintype)
void cmd_pgp_start_shows_message_when_no_arg_in_wintype(win_type_t wintype)
{
gchar* args[] = { "start", NULL };
gchar *args[] = { "start", NULL };
ProfWin window;
window.type = wintype;
@@ -75,41 +69,35 @@ cmd_pgp_start_shows_message_when_no_arg_in_wintype(win_type_t wintype)
assert_true(result);
}
void
cmd_pgp_start_shows_message_when_no_arg_in_console(void** state)
void cmd_pgp_start_shows_message_when_no_arg_in_console(void **state)
{
cmd_pgp_start_shows_message_when_no_arg_in_wintype(WIN_CONSOLE);
}
void
cmd_pgp_start_shows_message_when_no_arg_in_muc(void** state)
void cmd_pgp_start_shows_message_when_no_arg_in_muc(void **state)
{
cmd_pgp_start_shows_message_when_no_arg_in_wintype(WIN_MUC);
}
void
cmd_pgp_start_shows_message_when_no_arg_in_conf(void** state)
void cmd_pgp_start_shows_message_when_no_arg_in_conf(void **state)
{
cmd_pgp_start_shows_message_when_no_arg_in_wintype(WIN_CONFIG);
}
void
cmd_pgp_start_shows_message_when_no_arg_in_private(void** state)
void cmd_pgp_start_shows_message_when_no_arg_in_private(void **state)
{
cmd_pgp_start_shows_message_when_no_arg_in_wintype(WIN_PRIVATE);
}
void
cmd_pgp_start_shows_message_when_no_arg_in_xmlconsole(void** state)
void cmd_pgp_start_shows_message_when_no_arg_in_xmlconsole(void **state)
{
cmd_pgp_start_shows_message_when_no_arg_in_wintype(WIN_XML);
}
#else
void
cmd_pgp_shows_message_when_pgp_unsupported(void** state)
void cmd_pgp_shows_message_when_pgp_unsupported(void **state)
{
gchar* args[] = { "gen", NULL };
gchar *args[] = { "gen", NULL };
expect_cons_show("This version of Profanity has not been built with PGP support enabled");

22
tests/unittests/test_cmd_pgp.h
View File

@@ -1,16 +1,16 @@
#include "config.h"
#ifdef HAVE_LIBGPGME
void cmd_pgp_shows_usage_when_no_args(void** state);
void cmd_pgp_start_shows_message_when_disconnected(void** state);
void cmd_pgp_start_shows_message_when_disconnecting(void** state);
void cmd_pgp_start_shows_message_when_connecting(void** state);
void cmd_pgp_start_shows_message_when_undefined(void** state);
void cmd_pgp_start_shows_message_when_no_arg_in_console(void** state);
void cmd_pgp_start_shows_message_when_no_arg_in_muc(void** state);
void cmd_pgp_start_shows_message_when_no_arg_in_conf(void** state);
void cmd_pgp_start_shows_message_when_no_arg_in_private(void** state);
void cmd_pgp_start_shows_message_when_no_arg_in_xmlconsole(void** state);
void cmd_pgp_shows_usage_when_no_args(void **state);
void cmd_pgp_start_shows_message_when_disconnected(void **state);
void cmd_pgp_start_shows_message_when_disconnecting(void **state);
void cmd_pgp_start_shows_message_when_connecting(void **state);
void cmd_pgp_start_shows_message_when_undefined(void **state);
void cmd_pgp_start_shows_message_when_no_arg_in_console(void **state);
void cmd_pgp_start_shows_message_when_no_arg_in_muc(void **state);
void cmd_pgp_start_shows_message_when_no_arg_in_conf(void **state);
void cmd_pgp_start_shows_message_when_no_arg_in_private(void **state);
void cmd_pgp_start_shows_message_when_no_arg_in_xmlconsole(void **state);
#else
void cmd_pgp_shows_message_when_pgp_unsupported(void** state);
void cmd_pgp_shows_message_when_pgp_unsupported(void **state);
#endif

91
tests/unittests/test_cmd_presence.c
View File

@@ -1,24 +1,23 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "config/preferences.h"
#include "ui/stub_ui.h"
#include "ui/ui.h"
#include "ui/stub_ui.h"
#include "command/cmd_funcs.h"
#define CMD_PRESENCE "/presence"
void
cmd_presence_shows_usage_when_bad_subcmd(void** state)
void cmd_presence_shows_usage_when_bad_subcmd(void **state)
{
gchar* args[] = { "badcmd", NULL };
gchar *args[] = { "badcmd", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_PRESENCE);
@@ -26,10 +25,9 @@ cmd_presence_shows_usage_when_bad_subcmd(void** state)
assert_true(result);
}
void
cmd_presence_shows_usage_when_bad_console_setting(void** state)
void cmd_presence_shows_usage_when_bad_console_setting(void **state)
{
gchar* args[] = { "console", "badsetting", NULL };
gchar *args[] = { "console", "badsetting", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_PRESENCE);
@@ -37,10 +35,9 @@ cmd_presence_shows_usage_when_bad_console_setting(void** state)
assert_true(result);
}
void
cmd_presence_shows_usage_when_bad_chat_setting(void** state)
void cmd_presence_shows_usage_when_bad_chat_setting(void **state)
{
gchar* args[] = { "chat", "badsetting", NULL };
gchar *args[] = { "chat", "badsetting", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_PRESENCE);
@@ -48,10 +45,9 @@ cmd_presence_shows_usage_when_bad_chat_setting(void** state)
assert_true(result);
}
void
cmd_presence_shows_usage_when_bad_muc_setting(void** state)
void cmd_presence_shows_usage_when_bad_muc_setting(void **state)
{
gchar* args[] = { "muc", "badsetting", NULL };
gchar *args[] = { "muc", "badsetting", NULL };
expect_string(cons_bad_cmd_usage, cmd, CMD_PRESENCE);
@@ -59,144 +55,135 @@ cmd_presence_shows_usage_when_bad_muc_setting(void** state)
assert_true(result);
}
void
cmd_presence_console_sets_all(void** state)
void cmd_presence_console_sets_all(void **state)
{
gchar* args[] = { "console", "all", NULL };
gchar *args[] = { "console", "all", NULL };
expect_cons_show("All presence updates will appear in the console.");
gboolean result = cmd_presence(NULL, CMD_PRESENCE, args);
char* setting = prefs_get_string(PREF_STATUSES_CONSOLE);
char *setting = prefs_get_string(PREF_STATUSES_CONSOLE);
assert_non_null(setting);
assert_string_equal("all", setting);
assert_true(result);
g_free(setting);
}
void
cmd_presence_console_sets_online(void** state)
void cmd_presence_console_sets_online(void **state)
{
gchar* args[] = { "console", "online", NULL };
gchar *args[] = { "console", "online", NULL };
expect_cons_show("Only online/offline presence updates will appear in the console.");
gboolean result = cmd_presence(NULL, CMD_PRESENCE, args);
char* setting = prefs_get_string(PREF_STATUSES_CONSOLE);
char *setting = prefs_get_string(PREF_STATUSES_CONSOLE);
assert_non_null(setting);
assert_string_equal("online", setting);
assert_true(result);
g_free(setting);
}
void
cmd_presence_console_sets_none(void** state)
void cmd_presence_console_sets_none(void **state)
{
gchar* args[] = { "console", "none", NULL };
gchar *args[] = { "console", "none", NULL };
expect_cons_show("Presence updates will not appear in the console.");
gboolean result = cmd_presence(NULL, CMD_PRESENCE, args);
char* setting = prefs_get_string(PREF_STATUSES_CONSOLE);
char *setting = prefs_get_string(PREF_STATUSES_CONSOLE);
assert_non_null(setting);
assert_string_equal("none", setting);
assert_true(result);
g_free(setting);
}
void
cmd_presence_chat_sets_all(void** state)
void cmd_presence_chat_sets_all(void **state)
{
gchar* args[] = { "chat", "all", NULL };
gchar *args[] = { "chat", "all", NULL };
expect_cons_show("All presence updates will appear in chat windows.");
gboolean result = cmd_presence(NULL, CMD_PRESENCE, args);
char* setting = prefs_get_string(PREF_STATUSES_CHAT);
char *setting = prefs_get_string(PREF_STATUSES_CHAT);
assert_non_null(setting);
assert_string_equal("all", setting);
assert_true(result);
g_free(setting);
}
void
cmd_presence_chat_sets_online(void** state)
void cmd_presence_chat_sets_online(void **state)
{
gchar* args[] = { "chat", "online", NULL };
gchar *args[] = { "chat", "online", NULL };
expect_cons_show("Only online/offline presence updates will appear in chat windows.");
gboolean result = cmd_presence(NULL, CMD_PRESENCE, args);
char* setting = prefs_get_string(PREF_STATUSES_CHAT);
char *setting = prefs_get_string(PREF_STATUSES_CHAT);
assert_non_null(setting);
assert_string_equal("online", setting);
assert_true(result);
g_free(setting);
}
void
cmd_presence_chat_sets_none(void** state)
void cmd_presence_chat_sets_none(void **state)
{
gchar* args[] = { "chat", "none", NULL };
gchar *args[] = { "chat", "none", NULL };
expect_cons_show("Presence updates will not appear in chat windows.");
gboolean result = cmd_presence(NULL, CMD_PRESENCE, args);
char* setting = prefs_get_string(PREF_STATUSES_CHAT);
char *setting = prefs_get_string(PREF_STATUSES_CHAT);
assert_non_null(setting);
assert_string_equal("none", setting);
assert_true(result);
g_free(setting);
}
void
cmd_presence_room_sets_all(void** state)
void cmd_presence_room_sets_all(void **state)
{
gchar* args[] = { "room", "all", NULL };
gchar *args[] = { "room", "all", NULL };
expect_cons_show("All presence updates will appear in chat room windows.");
gboolean result = cmd_presence(NULL, CMD_PRESENCE, args);
char* setting = prefs_get_string(PREF_STATUSES_MUC);
char *setting = prefs_get_string(PREF_STATUSES_MUC);
assert_non_null(setting);
assert_string_equal("all", setting);
assert_true(result);
g_free(setting);
}
void
cmd_presence_room_sets_online(void** state)
void cmd_presence_room_sets_online(void **state)
{
gchar* args[] = { "room", "online", NULL };
gchar *args[] = { "room", "online", NULL };
expect_cons_show("Only join/leave presence updates will appear in chat room windows.");
gboolean result = cmd_presence(NULL, CMD_PRESENCE, args);
char* setting = prefs_get_string(PREF_STATUSES_MUC);
char *setting = prefs_get_string(PREF_STATUSES_MUC);
assert_non_null(setting);
assert_string_equal("online", setting);
assert_true(result);
g_free(setting);
}
void
cmd_presence_room_sets_none(void** state)
void cmd_presence_room_sets_none(void **state)
{
gchar* args[] = { "room", "none", NULL };
gchar *args[] = { "room", "none", NULL };
expect_cons_show("Presence updates will not appear in chat room windows.");
gboolean result = cmd_presence(NULL, CMD_PRESENCE, args);
char* setting = prefs_get_string(PREF_STATUSES_MUC);
char *setting = prefs_get_string(PREF_STATUSES_MUC);
assert_non_null(setting);
assert_string_equal("none", setting);
assert_true(result);

26
tests/unittests/test_cmd_presence.h
View File

@@ -1,13 +1,13 @@
void cmd_presence_shows_usage_when_bad_subcmd(void** state);
void cmd_presence_shows_usage_when_bad_console_setting(void** state);
void cmd_presence_shows_usage_when_bad_chat_setting(void** state);
void cmd_presence_shows_usage_when_bad_muc_setting(void** state);
void cmd_presence_console_sets_all(void** state);
void cmd_presence_console_sets_online(void** state);
void cmd_presence_console_sets_none(void** state);
void cmd_presence_chat_sets_all(void** state);
void cmd_presence_chat_sets_online(void** state);
void cmd_presence_chat_sets_none(void** state);
void cmd_presence_room_sets_all(void** state);
void cmd_presence_room_sets_online(void** state);
void cmd_presence_room_sets_none(void** state);
void cmd_presence_shows_usage_when_bad_subcmd(void **state);
void cmd_presence_shows_usage_when_bad_console_setting(void **state);
void cmd_presence_shows_usage_when_bad_chat_setting(void **state);
void cmd_presence_shows_usage_when_bad_muc_setting(void **state);
void cmd_presence_console_sets_all(void **state);
void cmd_presence_console_sets_online(void **state);
void cmd_presence_console_sets_none(void **state);
void cmd_presence_chat_sets_all(void **state);
void cmd_presence_chat_sets_online(void **state);
void cmd_presence_chat_sets_none(void **state);
void cmd_presence_room_sets_all(void **state);
void cmd_presence_room_sets_online(void **state);
void cmd_presence_room_sets_none(void **state);

46
tests/unittests/test_cmd_rooms.c
View File

@@ -1,23 +1,22 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "xmpp/xmpp.h"
#include "ui/stub_ui.h"
#include "ui/ui.h"
#include "ui/stub_ui.h"
#include "command/cmd_funcs.h"
#include "config/accounts.h"
#include "command/cmd_funcs.h"
#define CMD_ROOMS "/rooms"
static void
test_with_connection_status(jabber_conn_status_t status)
static void test_with_connection_status(jabber_conn_status_t status)
{
will_return(connection_get_status, status);
@@ -27,31 +26,27 @@ test_with_connection_status(jabber_conn_status_t status)
assert_true(result);
}
void
cmd_rooms_shows_message_when_disconnected(void** state)
void cmd_rooms_shows_message_when_disconnected(void **state)
{
test_with_connection_status(JABBER_DISCONNECTED);
}
void
cmd_rooms_shows_message_when_disconnecting(void** state)
void cmd_rooms_shows_message_when_disconnecting(void **state)
{
test_with_connection_status(JABBER_DISCONNECTING);
}
void
cmd_rooms_shows_message_when_connecting(void** state)
void cmd_rooms_shows_message_when_connecting(void **state)
{
test_with_connection_status(JABBER_CONNECTING);
}
void
cmd_rooms_uses_account_default_when_no_arg(void** state)
void cmd_rooms_uses_account_default_when_no_arg(void **state)
{
gchar* args[] = { NULL };
gchar *args[] = { NULL };
ProfAccount* account = account_new("testaccount", NULL, NULL, NULL, TRUE, NULL, 0, NULL, NULL, NULL,
0, 0, 0, 0, 0, "default_conf_server", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
ProfAccount *account = account_new("testaccount", NULL, NULL, NULL, TRUE, NULL, 0, NULL, NULL, NULL,
0, 0, 0, 0, 0, "default_conf_server", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
will_return(connection_get_status, JABBER_CONNECTED);
will_return(session_get_account_name, "account_name");
@@ -68,10 +63,9 @@ cmd_rooms_uses_account_default_when_no_arg(void** state)
assert_true(result);
}
void
cmd_rooms_service_arg_used_when_passed(void** state)
void cmd_rooms_service_arg_used_when_passed(void **state)
{
gchar* args[] = { "service", "conf_server_arg", NULL };
gchar *args[] = { "service", "conf_server_arg", NULL };
will_return(connection_get_status, JABBER_CONNECTED);
@@ -85,13 +79,13 @@ cmd_rooms_service_arg_used_when_passed(void** state)
assert_true(result);
}
void
cmd_rooms_filter_arg_used_when_passed(void** state)
void cmd_rooms_filter_arg_used_when_passed(void **state)
{
gchar* args[] = { "filter", "text", NULL };
gchar *args[] = { "filter", "text", NULL };
ProfAccount* account = account_new("testaccount", NULL, NULL, NULL, TRUE, NULL, 0, NULL, NULL, NULL,
0, 0, 0, 0, 0, "default_conf_server", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
ProfAccount *account = account_new("testaccount", NULL, NULL, NULL, TRUE, NULL, 0, NULL, NULL, NULL,
0, 0, 0, 0, 0, "default_conf_server", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
will_return(connection_get_status, JABBER_CONNECTED);
will_return(session_get_account_name, "account_name");

14
tests/unittests/test_cmd_rooms.h
View File

@@ -1,7 +1,7 @@
void cmd_rooms_shows_message_when_disconnected(void** state);
void cmd_rooms_shows_message_when_disconnecting(void** state);
void cmd_rooms_shows_message_when_connecting(void** state);
void cmd_rooms_shows_message_when_undefined(void** state);
void cmd_rooms_uses_account_default_when_no_arg(void** state);
void cmd_rooms_service_arg_used_when_passed(void** state);
void cmd_rooms_filter_arg_used_when_passed(void** state);
void cmd_rooms_shows_message_when_disconnected(void **state);
void cmd_rooms_shows_message_when_disconnecting(void **state);
void cmd_rooms_shows_message_when_connecting(void **state);
void cmd_rooms_shows_message_when_undefined(void **state);
void cmd_rooms_uses_account_default_when_no_arg(void **state);
void cmd_rooms_service_arg_used_when_passed(void **state);
void cmd_rooms_filter_arg_used_when_passed(void **state);

104
tests/unittests/test_cmd_roster.c
View File

@@ -1,24 +1,23 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "ui/stub_ui.h"
#include "ui/ui.h"
#include "ui/stub_ui.h"
#include "command/cmd_funcs.h"
#include "xmpp/roster_list.h"
#include "xmpp/xmpp.h"
#include "xmpp/roster_list.h"
#include "command/cmd_funcs.h"
#define CMD_ROSTER "/roster"
static void
test_with_connection_status(jabber_conn_status_t status)
static void test_with_connection_status(jabber_conn_status_t status)
{
gchar* args[] = { NULL };
gchar *args[] = { NULL };
will_return(connection_get_status, status);
@@ -28,34 +27,30 @@ test_with_connection_status(jabber_conn_status_t status)
assert_true(result);
}
void
cmd_roster_shows_message_when_disconnecting(void** state)
void cmd_roster_shows_message_when_disconnecting(void **state)
{
test_with_connection_status(JABBER_DISCONNECTING);
}
void
cmd_roster_shows_message_when_connecting(void** state)
void cmd_roster_shows_message_when_connecting(void **state)
{
test_with_connection_status(JABBER_CONNECTING);
}
void
cmd_roster_shows_message_when_disconnected(void** state)
void cmd_roster_shows_message_when_disconnected(void **state)
{
test_with_connection_status(JABBER_DISCONNECTED);
}
void
cmd_roster_shows_roster_when_no_args(void** state)
void cmd_roster_shows_roster_when_no_args(void **state)
{
gchar* args[] = { NULL };
gchar *args[] = { NULL };
will_return(connection_get_status, JABBER_CONNECTED);
roster_create();
roster_add("bob@server.org", "bob", NULL, "both", FALSE);
GSList* roster = roster_get_contacts(ROSTER_ORD_NAME);
GSList *roster = roster_get_contacts(ROSTER_ORD_NAME);
expect_memory(cons_show_roster, list, roster, sizeof(roster));
@@ -66,10 +61,9 @@ cmd_roster_shows_roster_when_no_args(void** state)
roster_destroy();
}
void
cmd_roster_add_shows_message_when_no_jid(void** state)
void cmd_roster_add_shows_message_when_no_jid(void **state)
{
gchar* args[] = { "add", NULL };
gchar *args[] = { "add", NULL };
will_return(connection_get_status, JABBER_CONNECTED);
@@ -79,12 +73,11 @@ cmd_roster_add_shows_message_when_no_jid(void** state)
assert_true(result);
}
void
cmd_roster_add_sends_roster_add_request(void** state)
void cmd_roster_add_sends_roster_add_request(void **state)
{
char* jid = "bob@server.org";
char* nick = "bob";
gchar* args[] = { "add", jid, nick, NULL };
char *jid = "bob@server.org";
char *nick = "bob";
gchar *args[] = { "add", jid, nick, NULL };
will_return(connection_get_status, JABBER_CONNECTED);
@@ -95,10 +88,9 @@ cmd_roster_add_sends_roster_add_request(void** state)
assert_true(result);
}
void
cmd_roster_remove_shows_message_when_no_jid(void** state)
void cmd_roster_remove_shows_message_when_no_jid(void **state)
{
gchar* args[] = { "remove", NULL };
gchar *args[] = { "remove", NULL };
will_return(connection_get_status, JABBER_CONNECTED);
@@ -108,11 +100,10 @@ cmd_roster_remove_shows_message_when_no_jid(void** state)
assert_true(result);
}
void
cmd_roster_remove_sends_roster_remove_request(void** state)
void cmd_roster_remove_sends_roster_remove_request(void **state)
{
char* jid = "bob@server.org";
gchar* args[] = { "remove", jid, NULL };
char *jid = "bob@server.org";
gchar *args[] = { "remove", jid, NULL };
will_return(connection_get_status, JABBER_CONNECTED);
@@ -122,10 +113,9 @@ cmd_roster_remove_sends_roster_remove_request(void** state)
assert_true(result);
}
void
cmd_roster_nick_shows_message_when_no_jid(void** state)
void cmd_roster_nick_shows_message_when_no_jid(void **state)
{
gchar* args[] = { "nick", NULL };
gchar *args[] = { "nick", NULL };
will_return(connection_get_status, JABBER_CONNECTED);
@@ -135,10 +125,9 @@ cmd_roster_nick_shows_message_when_no_jid(void** state)
assert_true(result);
}
void
cmd_roster_nick_shows_message_when_no_nick(void** state)
void cmd_roster_nick_shows_message_when_no_nick(void **state)
{
gchar* args[] = { "nick", "bob@server.org", NULL };
gchar *args[] = { "nick", "bob@server.org", NULL };
will_return(connection_get_status, JABBER_CONNECTED);
@@ -148,10 +137,9 @@ cmd_roster_nick_shows_message_when_no_nick(void** state)
assert_true(result);
}
void
cmd_roster_nick_shows_message_when_no_contact_exists(void** state)
void cmd_roster_nick_shows_message_when_no_contact_exists(void **state)
{
gchar* args[] = { "nick", "bob@server.org", "bobster", NULL };
gchar *args[] = { "nick", "bob@server.org", "bobster", NULL };
roster_create();
@@ -165,15 +153,14 @@ cmd_roster_nick_shows_message_when_no_contact_exists(void** state)
roster_destroy();
}
void
cmd_roster_nick_sends_name_change_request(void** state)
void cmd_roster_nick_sends_name_change_request(void **state)
{
char* jid = "bob@server.org";
char* nick = "bobster";
gchar* args[] = { "nick", jid, nick, NULL };
char *jid = "bob@server.org";
char *nick = "bobster";
gchar *args[] = { "nick", jid, nick, NULL };
roster_create();
GSList* groups = NULL;
GSList *groups = NULL;
groups = g_slist_append(groups, strdup("group1"));
roster_add(jid, "bob", groups, "both", FALSE);
@@ -194,10 +181,9 @@ cmd_roster_nick_sends_name_change_request(void** state)
roster_destroy();
}
void
cmd_roster_clearnick_shows_message_when_no_jid(void** state)
void cmd_roster_clearnick_shows_message_when_no_jid(void **state)
{
gchar* args[] = { "clearnick", NULL };
gchar *args[] = { "clearnick", NULL };
will_return(connection_get_status, JABBER_CONNECTED);
@@ -207,10 +193,9 @@ cmd_roster_clearnick_shows_message_when_no_jid(void** state)
assert_true(result);
}
void
cmd_roster_clearnick_shows_message_when_no_contact_exists(void** state)
void cmd_roster_clearnick_shows_message_when_no_contact_exists(void **state)
{
gchar* args[] = { "clearnick", "bob@server.org", NULL };
gchar *args[] = { "clearnick", "bob@server.org", NULL };
roster_create();
@@ -224,14 +209,13 @@ cmd_roster_clearnick_shows_message_when_no_contact_exists(void** state)
roster_destroy();
}
void
cmd_roster_clearnick_sends_name_change_request_with_empty_nick(void** state)
void cmd_roster_clearnick_sends_name_change_request_with_empty_nick(void **state)
{
char* jid = "bob@server.org";
gchar* args[] = { "clearnick", jid, NULL };
char *jid = "bob@server.org";
gchar *args[] = { "clearnick", jid, NULL };
roster_create();
GSList* groups = NULL;
GSList *groups = NULL;
groups = g_slist_append(groups, strdup("group1"));
roster_add(jid, "bob", groups, "both", FALSE);

32
tests/unittests/test_cmd_roster.h
View File

@@ -1,16 +1,16 @@
void cmd_roster_shows_message_when_disconnecting(void** state);
void cmd_roster_shows_message_when_connecting(void** state);
void cmd_roster_shows_message_when_disconnected(void** state);
void cmd_roster_shows_message_when_undefined(void** state);
void cmd_roster_shows_roster_when_no_args(void** state);
void cmd_roster_add_shows_message_when_no_jid(void** state);
void cmd_roster_add_sends_roster_add_request(void** state);
void cmd_roster_remove_shows_message_when_no_jid(void** state);
void cmd_roster_remove_sends_roster_remove_request(void** state);
void cmd_roster_nick_shows_message_when_no_jid(void** state);
void cmd_roster_nick_shows_message_when_no_nick(void** state);
void cmd_roster_nick_shows_message_when_no_contact_exists(void** state);
void cmd_roster_nick_sends_name_change_request(void** state);
void cmd_roster_clearnick_shows_message_when_no_jid(void** state);
void cmd_roster_clearnick_shows_message_when_no_contact_exists(void** state);
void cmd_roster_clearnick_sends_name_change_request_with_empty_nick(void** state);
void cmd_roster_shows_message_when_disconnecting(void **state);
void cmd_roster_shows_message_when_connecting(void **state);
void cmd_roster_shows_message_when_disconnected(void **state);
void cmd_roster_shows_message_when_undefined(void **state);
void cmd_roster_shows_roster_when_no_args(void **state);
void cmd_roster_add_shows_message_when_no_jid(void **state);
void cmd_roster_add_sends_roster_add_request(void **state);
void cmd_roster_remove_shows_message_when_no_jid(void **state);
void cmd_roster_remove_sends_roster_remove_request(void **state);
void cmd_roster_nick_shows_message_when_no_jid(void **state);
void cmd_roster_nick_shows_message_when_no_nick(void **state);
void cmd_roster_nick_shows_message_when_no_contact_exists(void **state);
void cmd_roster_nick_sends_name_change_request(void **state);
void cmd_roster_clearnick_shows_message_when_no_jid(void **state);
void cmd_roster_clearnick_shows_message_when_no_contact_exists(void **state);
void cmd_roster_clearnick_sends_name_change_request_with_empty_nick(void **state);

18
tests/unittests/test_cmd_sub.c
View File

@@ -1,24 +1,23 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "xmpp/xmpp.h"
#include "ui/stub_ui.h"
#include "ui/ui.h"
#include "ui/stub_ui.h"
#include "command/cmd_funcs.h"
#define CMD_SUB "/sub"
void
cmd_sub_shows_message_when_not_connected(void** state)
void cmd_sub_shows_message_when_not_connected(void **state)
{
gchar* args[] = { NULL };
gchar *args[] = { NULL };
will_return(connection_get_status, JABBER_DISCONNECTED);
@@ -28,10 +27,9 @@ cmd_sub_shows_message_when_not_connected(void** state)
assert_true(result);
}
void
cmd_sub_shows_usage_when_no_arg(void** state)
void cmd_sub_shows_usage_when_no_arg(void **state)
{
gchar* args[] = { NULL };
gchar *args[] = { NULL };
will_return(connection_get_status, JABBER_CONNECTED);

4
tests/unittests/test_cmd_sub.h
View File

@@ -1,2 +1,2 @@
void cmd_sub_shows_message_when_not_connected(void** state);
void cmd_sub_shows_usage_when_no_arg(void** state);
void cmd_sub_shows_message_when_not_connected(void **state);
void cmd_sub_shows_usage_when_no_arg(void **state);

559
tests/unittests/test_common.c
View File

@@ -1,329 +1,298 @@
#include "common.h"
#include "xmpp/resource.h"
#include <cmocka.h>
#include <setjmp.h>
#include "common.h"
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
void
replace_one_substr(void** state)
void replace_one_substr(void **state)
{
char* string = "it is a string";
char* sub = "is";
char* new = "was";
char *string = "it is a string";
char *sub = "is";
char *new = "was";
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_string_equal("it was a string", result);
free(result);
}
void
replace_one_substr_beginning(void** state)
void replace_one_substr_beginning(void **state)
{
char* string = "it is a string";
char* sub = "it";
char* new = "that";
char *string = "it is a string";
char *sub = "it";
char *new = "that";
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_string_equal("that is a string", result);
free(result);
}
void
replace_one_substr_end(void** state)
void replace_one_substr_end(void **state)
{
char* string = "it is a string";
char* sub = "string";
char* new = "thing";
char *string = "it is a string";
char *sub = "string";
char *new = "thing";
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_string_equal("it is a thing", result);
free(result);
}
void
replace_two_substr(void** state)
void replace_two_substr(void **state)
{
char* string = "it is a is string";
char* sub = "is";
char* new = "was";
char *string = "it is a is string";
char *sub = "is";
char *new = "was";
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_string_equal("it was a was string", result);
free(result);
}
void
replace_char(void** state)
void replace_char(void **state)
{
char* string = "some & a thing & something else";
char* sub = "&";
char* new = "&amp;";
char *string = "some & a thing & something else";
char *sub = "&";
char *new = "&amp;";
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_string_equal("some &amp; a thing &amp; something else", result);
free(result);
}
void
replace_when_none(void** state)
void replace_when_none(void **state)
{
char* string = "its another string";
char* sub = "haha";
char* new = "replaced";
char *string = "its another string";
char *sub = "haha";
char *new = "replaced";
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_string_equal("its another string", result);
free(result);
}
void
replace_when_match(void** state)
void replace_when_match(void **state)
{
char* string = "hello";
char* sub = "hello";
char* new = "goodbye";
char *string = "hello";
char *sub = "hello";
char *new = "goodbye";
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_string_equal("goodbye", result);
free(result);
}
void
replace_when_string_empty(void** state)
void replace_when_string_empty(void **state)
{
char* string = "";
char* sub = "hello";
char* new = "goodbye";
char *string = "";
char *sub = "hello";
char *new = "goodbye";
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_string_equal("", result);
free(result);
}
void
replace_when_string_null(void** state)
void replace_when_string_null(void **state)
{
char* string = NULL;
char* sub = "hello";
char* new = "goodbye";
char *string = NULL;
char *sub = "hello";
char *new = "goodbye";
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_null(result);
}
void
replace_when_sub_empty(void** state)
void replace_when_sub_empty(void **state)
{
char* string = "hello";
char* sub = "";
char* new = "goodbye";
char *string = "hello";
char *sub = "";
char *new = "goodbye";
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_string_equal("hello", result);
free(result);
}
void
replace_when_sub_null(void** state)
void replace_when_sub_null(void **state)
{
char* string = "hello";
char* sub = NULL;
char* new = "goodbye";
char *string = "hello";
char *sub = NULL;
char *new = "goodbye";
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_string_equal("hello", result);
free(result);
}
void
replace_when_new_empty(void** state)
void replace_when_new_empty(void **state)
{
char* string = "hello";
char* sub = "hello";
char* new = "";
char *string = "hello";
char *sub = "hello";
char *new = "";
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_string_equal("", result);
free(result);
}
void
replace_when_new_null(void** state)
void replace_when_new_null(void **state)
{
char* string = "hello";
char* sub = "hello";
char* new = NULL;
char *string = "hello";
char *sub = "hello";
char *new = NULL;
char* result = str_replace(string, sub, new);
char *result = str_replace(string, sub, new);
assert_string_equal("hello", result);
free(result);
}
void
test_online_is_valid_resource_presence_string(void** state)
void test_online_is_valid_resource_presence_string(void **state)
{
assert_true(valid_resource_presence_string("online"));
}
void
test_chat_is_valid_resource_presence_string(void** state)
void test_chat_is_valid_resource_presence_string(void **state)
{
assert_true(valid_resource_presence_string("chat"));
}
void
test_away_is_valid_resource_presence_string(void** state)
void test_away_is_valid_resource_presence_string(void **state)
{
assert_true(valid_resource_presence_string("away"));
}
void
test_xa_is_valid_resource_presence_string(void** state)
void test_xa_is_valid_resource_presence_string(void **state)
{
assert_true(valid_resource_presence_string("xa"));
}
void
test_dnd_is_valid_resource_presence_string(void** state)
void test_dnd_is_valid_resource_presence_string(void **state)
{
assert_true(valid_resource_presence_string("dnd"));
}
void
test_available_is_not_valid_resource_presence_string(void** state)
void test_available_is_not_valid_resource_presence_string(void **state)
{
assert_false(valid_resource_presence_string("available"));
}
void
test_unavailable_is_not_valid_resource_presence_string(void** state)
void test_unavailable_is_not_valid_resource_presence_string(void **state)
{
assert_false(valid_resource_presence_string("unavailable"));
}
void
test_blah_is_not_valid_resource_presence_string(void** state)
void test_blah_is_not_valid_resource_presence_string(void **state)
{
assert_false(valid_resource_presence_string("blah"));
}
void
utf8_display_len_null_str(void** state)
void utf8_display_len_null_str(void **state)
{
int result = utf8_display_len(NULL);
assert_int_equal(0, result);
}
void
utf8_display_len_1_non_wide(void** state)
void utf8_display_len_1_non_wide(void **state)
{
int result = utf8_display_len("1");
assert_int_equal(1, result);
}
void
utf8_display_len_1_wide(void** state)
void utf8_display_len_1_wide(void **state)
{
int result = utf8_display_len("四");
assert_int_equal(2, result);
}
void
utf8_display_len_non_wide(void** state)
void utf8_display_len_non_wide(void **state)
{
int result = utf8_display_len("123456789abcdef");
assert_int_equal(15, result);
}
void
utf8_display_len_wide(void** state)
void utf8_display_len_wide(void **state)
{
int result = utf8_display_len("12三四56");
assert_int_equal(8, result);
}
void
utf8_display_len_all_wide(void** state)
void utf8_display_len_all_wide(void **state)
{
int result = utf8_display_len("ひらがな");
assert_int_equal(8, result);
}
void
strip_quotes_does_nothing_when_no_quoted(void** state)
void strip_quotes_does_nothing_when_no_quoted(void **state)
{
char* input = "/cmd test string";
char *input = "/cmd test string";
char* result = strip_arg_quotes(input);
char *result = strip_arg_quotes(input);
assert_string_equal("/cmd test string", result);
free(result);
}
void
strip_quotes_strips_first(void** state)
void strip_quotes_strips_first(void **state)
{
char* input = "/cmd \"test string";
char *input = "/cmd \"test string";
char* result = strip_arg_quotes(input);
char *result = strip_arg_quotes(input);
assert_string_equal("/cmd test string", result);
free(result);
}
void
strip_quotes_strips_last(void** state)
void strip_quotes_strips_last(void **state)
{
char* input = "/cmd test string\"";
char *input = "/cmd test string\"";
char* result = strip_arg_quotes(input);
char *result = strip_arg_quotes(input);
assert_string_equal("/cmd test string", result);
free(result);
}
void
strip_quotes_strips_both(void** state)
void strip_quotes_strips_both(void **state)
{
char* input = "/cmd \"test string\"";
char *input = "/cmd \"test string\"";
char* result = strip_arg_quotes(input);
char *result = strip_arg_quotes(input);
assert_string_equal("/cmd test string", result);
@@ -331,14 +300,14 @@ strip_quotes_strips_both(void** state)
}
gboolean
_lists_equal(GSList* a, GSList* b)
_lists_equal(GSList *a, GSList *b)
{
if (g_slist_length(a) != g_slist_length(b)) {
return FALSE;
}
GSList* curra = a;
GSList* currb = b;
GSList *curra = a;
GSList *currb = b;
while (curra) {
int aval = GPOINTER_TO_INT(curra->data);
@@ -355,297 +324,145 @@ _lists_equal(GSList* a, GSList* b)
return TRUE;
}
void
prof_partial_occurrences_tests(void** state)
void prof_partial_occurrences_tests(void **state)
{
GSList* actual = NULL;
GSList* expected = NULL;
GSList *actual = NULL;
GSList *expected = NULL;
assert_true(_lists_equal(prof_occurrences(NULL, NULL, 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences(NULL, "some string", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", NULL, 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences(NULL, NULL, 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "Boothj5", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("Boothj5", "boothj5", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences(NULL, "some string", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", NULL, 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences(NULL, NULL, 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "Boothj5", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("Boothj5", "boothj5", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(0));
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5hello", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5 hello", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5hello", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5 hello", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(5));
assert_true(_lists_equal(prof_occurrences("boothj5", "helloboothj5", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "helloboothj5hello", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "helloboothj5", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "helloboothj5hello", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(6));
assert_true(_lists_equal(prof_occurrences("boothj5", "hello boothj5", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hello boothj5 hello", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hello boothj5", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hello boothj5 hello", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(0));
expected = g_slist_append(expected, GINT_TO_POINTER(7));
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5boothj5", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5boothj5", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(0));
expected = g_slist_append(expected, GINT_TO_POINTER(12));
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5helloboothj5", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5helloboothj5", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(0));
expected = g_slist_append(expected, GINT_TO_POINTER(14));
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5 hello boothj5", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5 hello boothj5", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(2));
expected = g_slist_append(expected, GINT_TO_POINTER(16));
expected = g_slist_append(expected, GINT_TO_POINTER(29));
assert_true(_lists_equal(prof_occurrences("boothj5", "hiboothj5 hello boothj5there boothj5s", 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hiboothj5 hello boothj5there boothj5s", 0, FALSE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
}
void
prof_whole_occurrences_tests(void** state)
void prof_whole_occurrences_tests(void **state)
{
GSList* actual = NULL;
GSList* expected = NULL;
GSList *actual = NULL;
GSList *expected = NULL;
assert_true(_lists_equal(prof_occurrences(NULL, NULL, 0, FALSE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(actual); actual = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(0));
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5 hi", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5: hi", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5, hi", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5 hi", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5: hi", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5, hi", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(0));
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而 hi", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而: hi", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而, hi", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而 hi", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而: hi", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而, hi", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(6));
assert_true(_lists_equal(prof_occurrences("boothj5", "hello boothj5", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hello boothj5 there", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "heyy @boothj5, there", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hello boothj5", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hello boothj5 there", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "heyy @boothj5, there", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(6));
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hello 我能吞下玻璃而", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hello 我能吞下玻璃而 there", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "heyy @我能吞下玻璃而, there", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hello 我能吞下玻璃而", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hello 我能吞下玻璃而 there", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "heyy @我能吞下玻璃而, there", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(6));
expected = g_slist_append(expected, GINT_TO_POINTER(26));
assert_true(_lists_equal(prof_occurrences("boothj5", "hello boothj5 some more a boothj5 stuff", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hello boothj5 there ands #boothj5", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "heyy @boothj5, there hows boothj5?", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hello boothj5 some more a boothj5 stuff", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hello boothj5 there ands #boothj5", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "heyy @boothj5, there hows boothj5?", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(6));
expected = g_slist_append(expected, GINT_TO_POINTER(26));
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hello 我能吞下玻璃而 some more a 我能吞下玻璃而 stuff", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hello 我能吞下玻璃而 there ands #我能吞下玻璃而", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "heyy @我能吞下玻璃而, there hows 我能吞下玻璃而?", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hello 我能吞下玻璃而 some more a 我能吞下玻璃而 stuff", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hello 我能吞下玻璃而 there ands #我能吞下玻璃而", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "heyy @我能吞下玻璃而, there hows 我能吞下玻璃而?", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(6));
assert_true(_lists_equal(prof_occurrences("p", "ppppp p", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("p", "ppppp p", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(0));
assert_true(_lists_equal(prof_occurrences("p", "p ppppp", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("p", "p ppppp", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = g_slist_append(expected, GINT_TO_POINTER(4));
assert_true(_lists_equal(prof_occurrences("p", "ppp p ppp", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("p", "ppp p ppp", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5hello", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "heyboothj5", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "heyboothj5hithere", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hey boothj5hithere", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hey @boothj5hithere", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "heyboothj5 hithere", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "heyboothj5, hithere", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5boothj5", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5fillboothj5", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "dont know", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "kick", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "kick kick", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "kick kickk", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "kic", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "ick", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "kk", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "kkkkkkk", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5hello", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "heyboothj5", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "heyboothj5hithere", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hey boothj5hithere", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "hey @boothj5hithere", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "heyboothj5 hithere", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "heyboothj5, hithere", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5boothj5", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("boothj5", "boothj5fillboothj5", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "dont know", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "kick", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "kick kick", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "kick kickk", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "kic", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "ick", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "kk", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("k", "kkkkkkk", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
expected = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而hello", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hey我能吞下玻璃而", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hey我能吞下玻璃而hithere", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hey 我能吞下玻璃而hithere", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hey @我能吞下玻璃而hithere", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hey我能吞下玻璃而 hithere", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hey我能吞下玻璃而, hithere", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而我能吞下玻璃而", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而fill我能吞下玻璃而", 0, TRUE, &actual), expected));
g_slist_free(actual);
actual = NULL;
g_slist_free(expected);
expected = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而hello", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hey我能吞下玻璃而", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hey我能吞下玻璃而hithere", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hey 我能吞下玻璃而hithere", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hey @我能吞下玻璃而hithere", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hey我能吞下玻璃而 hithere", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "hey我能吞下玻璃而, hithere", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而我能吞下玻璃而", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
assert_true(_lists_equal(prof_occurrences("我能吞下玻璃而", "我能吞下玻璃而fill我能吞下玻璃而", 0, TRUE, &actual), expected)); g_slist_free(actual); actual = NULL;
g_slist_free(expected); expected = NULL;
}

82
tests/unittests/test_common.h
View File

@@ -1,41 +1,41 @@
void replace_one_substr(void** state);
void replace_one_substr_beginning(void** state);
void replace_one_substr_end(void** state);
void replace_two_substr(void** state);
void replace_char(void** state);
void replace_when_none(void** state);
void replace_when_match(void** state);
void replace_when_string_empty(void** state);
void replace_when_string_null(void** state);
void replace_when_sub_empty(void** state);
void replace_when_sub_null(void** state);
void replace_when_new_empty(void** state);
void replace_when_new_null(void** state);
void test_online_is_valid_resource_presence_string(void** state);
void test_chat_is_valid_resource_presence_string(void** state);
void test_away_is_valid_resource_presence_string(void** state);
void test_xa_is_valid_resource_presence_string(void** state);
void test_dnd_is_valid_resource_presence_string(void** state);
void test_available_is_not_valid_resource_presence_string(void** state);
void test_unavailable_is_not_valid_resource_presence_string(void** state);
void test_blah_is_not_valid_resource_presence_string(void** state);
void utf8_display_len_null_str(void** state);
void utf8_display_len_1_non_wide(void** state);
void utf8_display_len_1_wide(void** state);
void utf8_display_len_non_wide(void** state);
void utf8_display_len_wide(void** state);
void utf8_display_len_all_wide(void** state);
void strip_quotes_does_nothing_when_no_quoted(void** state);
void strip_quotes_strips_first(void** state);
void strip_quotes_strips_last(void** state);
void strip_quotes_strips_both(void** state);
void str_not_contains_str(void** state);
void str_contains_str_at_start(void** state);
void str_contains_str_at_end(void** state);
void str_contains_str_in_middle(void** state);
void str_contains_str_whole(void** state);
void str_empty_not_contains_str(void** state);
void str_not_contains_str_empty(void** state);
void str_empty_not_contains_str_empty(void** state);
void prof_partial_occurrences_tests(void** state);
void prof_whole_occurrences_tests(void** state);
void replace_one_substr(void **state);
void replace_one_substr_beginning(void **state);
void replace_one_substr_end(void **state);
void replace_two_substr(void **state);
void replace_char(void **state);
void replace_when_none(void **state);
void replace_when_match(void **state);
void replace_when_string_empty(void **state);
void replace_when_string_null(void **state);
void replace_when_sub_empty(void **state);
void replace_when_sub_null(void **state);
void replace_when_new_empty(void **state);
void replace_when_new_null(void **state);
void test_online_is_valid_resource_presence_string(void **state);
void test_chat_is_valid_resource_presence_string(void **state);
void test_away_is_valid_resource_presence_string(void **state);
void test_xa_is_valid_resource_presence_string(void **state);
void test_dnd_is_valid_resource_presence_string(void **state);
void test_available_is_not_valid_resource_presence_string(void **state);
void test_unavailable_is_not_valid_resource_presence_string(void **state);
void test_blah_is_not_valid_resource_presence_string(void **state);
void utf8_display_len_null_str(void **state);
void utf8_display_len_1_non_wide(void **state);
void utf8_display_len_1_wide(void **state);
void utf8_display_len_non_wide(void **state);
void utf8_display_len_wide(void **state);
void utf8_display_len_all_wide(void **state);
void strip_quotes_does_nothing_when_no_quoted(void **state);
void strip_quotes_strips_first(void **state);
void strip_quotes_strips_last(void **state);
void strip_quotes_strips_both(void **state);
void str_not_contains_str(void **state);
void str_contains_str_at_start(void **state);
void str_contains_str_at_end(void **state);
void str_contains_str_in_middle(void **state);
void str_contains_str_whole(void **state);
void str_empty_not_contains_str(void **state);
void str_not_contains_str_empty(void **state);
void str_empty_not_contains_str_empty(void **state);
void prof_partial_occurrences_tests(void **state);
void prof_whole_occurrences_tests(void **state);

250
tests/unittests/test_contact.c
View File

@@ -1,78 +1,73 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include "xmpp/contact.h"
void
contact_in_group(void** state)
void contact_in_group(void **state)
{
GSList* groups = NULL;
GSList *groups = NULL;
groups = g_slist_append(groups, strdup("somegroup"));
PContact contact = p_contact_new("bob@server.com", "bob", groups, "both",
"is offline", FALSE);
"is offline", FALSE);
gboolean result = p_contact_in_group(contact, "somegroup");
assert_true(result);
p_contact_free(contact);
// g_slist_free(groups);
// g_slist_free(groups);
}
void
contact_not_in_group(void** state)
void contact_not_in_group(void **state)
{
GSList* groups = NULL;
GSList *groups = NULL;
groups = g_slist_append(groups, strdup("somegroup"));
PContact contact = p_contact_new("bob@server.com", "bob", groups, "both",
"is offline", FALSE);
"is offline", FALSE);
gboolean result = p_contact_in_group(contact, "othergroup");
assert_false(result);
p_contact_free(contact);
// g_slist_free(groups);
// g_slist_free(groups);
}
void
contact_name_when_name_exists(void** state)
void contact_name_when_name_exists(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
const char* name = p_contact_name_or_jid(contact);
const char *name = p_contact_name_or_jid(contact);
assert_string_equal("bob", name);
p_contact_free(contact);
}
void
contact_jid_when_name_not_exists(void** state)
void contact_jid_when_name_not_exists(void **state)
{
PContact contact = p_contact_new("bob@server.com", NULL, NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
const char* jid = p_contact_name_or_jid(contact);
const char *jid = p_contact_name_or_jid(contact);
assert_string_equal("bob@server.com", jid);
p_contact_free(contact);
}
void
contact_string_when_name_exists(void** state)
void contact_string_when_name_exists(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
char* str = p_contact_create_display_string(contact, "laptop");
char *str = p_contact_create_display_string(contact, "laptop");
assert_string_equal("bob (laptop)", str);
@@ -80,13 +75,12 @@ contact_string_when_name_exists(void** state)
free(str);
}
void
contact_string_when_name_not_exists(void** state)
void contact_string_when_name_not_exists(void **state)
{
PContact contact = p_contact_new("bob@server.com", NULL, NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
char* str = p_contact_create_display_string(contact, "laptop");
char *str = p_contact_create_display_string(contact, "laptop");
assert_string_equal("bob@server.com (laptop)", str);
@@ -94,13 +88,12 @@ contact_string_when_name_not_exists(void** state)
free(str);
}
void
contact_string_when_default_resource(void** state)
void contact_string_when_default_resource(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
char* str = p_contact_create_display_string(contact, "__prof_default");
char *str = p_contact_create_display_string(contact, "__prof_default");
assert_string_equal("bob", str);
@@ -108,148 +101,140 @@ contact_string_when_default_resource(void** state)
free(str);
}
void
contact_presence_offline(void** state)
void contact_presence_offline(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
const char* presence = p_contact_presence(contact);
const char *presence = p_contact_presence(contact);
assert_string_equal("offline", presence);
p_contact_free(contact);
}
void
contact_presence_uses_highest_priority(void** state)
void contact_presence_uses_highest_priority(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
Resource* resource10 = resource_new("resource10", RESOURCE_ONLINE, NULL, 10);
Resource* resource20 = resource_new("resource20", RESOURCE_CHAT, NULL, 20);
Resource* resource30 = resource_new("resource30", RESOURCE_AWAY, NULL, 30);
Resource* resource1 = resource_new("resource1", RESOURCE_XA, NULL, 1);
Resource* resource2 = resource_new("resource2", RESOURCE_DND, NULL, 2);
Resource *resource10 = resource_new("resource10", RESOURCE_ONLINE, NULL, 10);
Resource *resource20 = resource_new("resource20", RESOURCE_CHAT, NULL, 20);
Resource *resource30 = resource_new("resource30", RESOURCE_AWAY, NULL, 30);
Resource *resource1 = resource_new("resource1", RESOURCE_XA, NULL, 1);
Resource *resource2 = resource_new("resource2", RESOURCE_DND, NULL, 2);
p_contact_set_presence(contact, resource10);
p_contact_set_presence(contact, resource20);
p_contact_set_presence(contact, resource30);
p_contact_set_presence(contact, resource1);
p_contact_set_presence(contact, resource2);
const char* presence = p_contact_presence(contact);
const char *presence = p_contact_presence(contact);
assert_string_equal("away", presence);
p_contact_free(contact);
}
void
contact_presence_chat_when_same_prioroty(void** state)
void contact_presence_chat_when_same_prioroty(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
Resource* resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10);
Resource* resource_chat = resource_new("resource_chat", RESOURCE_CHAT, NULL, 10);
Resource* resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource* resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource* resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
Resource *resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10);
Resource *resource_chat = resource_new("resource_chat", RESOURCE_CHAT, NULL, 10);
Resource *resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource *resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource *resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
p_contact_set_presence(contact, resource_online);
p_contact_set_presence(contact, resource_chat);
p_contact_set_presence(contact, resource_away);
p_contact_set_presence(contact, resource_xa);
p_contact_set_presence(contact, resource_dnd);
const char* presence = p_contact_presence(contact);
const char *presence = p_contact_presence(contact);
assert_string_equal("chat", presence);
p_contact_free(contact);
}
void
contact_presence_online_when_same_prioroty(void** state)
void contact_presence_online_when_same_prioroty(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
Resource* resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10);
Resource* resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource* resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource* resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
Resource *resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10);
Resource *resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource *resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource *resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
p_contact_set_presence(contact, resource_online);
p_contact_set_presence(contact, resource_away);
p_contact_set_presence(contact, resource_xa);
p_contact_set_presence(contact, resource_dnd);
const char* presence = p_contact_presence(contact);
const char *presence = p_contact_presence(contact);
assert_string_equal("online", presence);
p_contact_free(contact);
}
void
contact_presence_away_when_same_prioroty(void** state)
void contact_presence_away_when_same_prioroty(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
Resource* resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource* resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource* resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
Resource *resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource *resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource *resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
p_contact_set_presence(contact, resource_away);
p_contact_set_presence(contact, resource_xa);
p_contact_set_presence(contact, resource_dnd);
const char* presence = p_contact_presence(contact);
const char *presence = p_contact_presence(contact);
assert_string_equal("away", presence);
p_contact_free(contact);
}
void
contact_presence_xa_when_same_prioroty(void** state)
void contact_presence_xa_when_same_prioroty(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
Resource* resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource* resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
Resource *resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource *resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
p_contact_set_presence(contact, resource_xa);
p_contact_set_presence(contact, resource_dnd);
const char* presence = p_contact_presence(contact);
const char *presence = p_contact_presence(contact);
assert_string_equal("xa", presence);
p_contact_free(contact);
}
void
contact_presence_dnd(void** state)
void contact_presence_dnd(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
Resource* resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
Resource *resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
p_contact_set_presence(contact, resource_dnd);
const char* presence = p_contact_presence(contact);
const char *presence = p_contact_presence(contact);
assert_string_equal("dnd", presence);
p_contact_free(contact);
}
void
contact_subscribed_when_to(void** state)
void contact_subscribed_when_to(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "to",
"is offline", FALSE);
"is offline", FALSE);
gboolean result = p_contact_subscribed(contact);
@@ -258,11 +243,10 @@ contact_subscribed_when_to(void** state)
p_contact_free(contact);
}
void
contact_subscribed_when_both(void** state)
void contact_subscribed_when_both(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "both",
"is offline", FALSE);
"is offline", FALSE);
gboolean result = p_contact_subscribed(contact);
@@ -271,11 +255,10 @@ contact_subscribed_when_both(void** state)
p_contact_free(contact);
}
void
contact_not_subscribed_when_from(void** state)
void contact_not_subscribed_when_from(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, "from",
"is offline", FALSE);
"is offline", FALSE);
gboolean result = p_contact_subscribed(contact);
@@ -284,11 +267,10 @@ contact_not_subscribed_when_from(void** state)
p_contact_free(contact);
}
void
contact_not_subscribed_when_no_subscription_value(void** state)
void contact_not_subscribed_when_no_subscription_value(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, NULL,
"is offline", FALSE);
"is offline", FALSE);
gboolean result = p_contact_subscribed(contact);
@@ -297,11 +279,10 @@ contact_not_subscribed_when_no_subscription_value(void** state)
p_contact_free(contact);
}
void
contact_not_available(void** state)
void contact_not_available(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, NULL,
"is offline", FALSE);
"is offline", FALSE);
gboolean result = p_contact_is_available(contact);
@@ -310,17 +291,16 @@ contact_not_available(void** state)
p_contact_free(contact);
}
void
contact_not_available_when_highest_priority_away(void** state)
void contact_not_available_when_highest_priority_away(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, NULL,
"is offline", FALSE);
"is offline", FALSE);
Resource* resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10);
Resource* resource_chat = resource_new("resource_chat", RESOURCE_CHAT, NULL, 10);
Resource* resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 20);
Resource* resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource* resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
Resource *resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10);
Resource *resource_chat = resource_new("resource_chat", RESOURCE_CHAT, NULL, 10);
Resource *resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 20);
Resource *resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource *resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
p_contact_set_presence(contact, resource_online);
p_contact_set_presence(contact, resource_chat);
p_contact_set_presence(contact, resource_away);
@@ -334,17 +314,16 @@ contact_not_available_when_highest_priority_away(void** state)
p_contact_free(contact);
}
void
contact_not_available_when_highest_priority_xa(void** state)
void contact_not_available_when_highest_priority_xa(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, NULL,
"is offline", FALSE);
"is offline", FALSE);
Resource* resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10);
Resource* resource_chat = resource_new("resource_chat", RESOURCE_CHAT, NULL, 10);
Resource* resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource* resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 20);
Resource* resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
Resource *resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10);
Resource *resource_chat = resource_new("resource_chat", RESOURCE_CHAT, NULL, 10);
Resource *resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource *resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 20);
Resource *resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
p_contact_set_presence(contact, resource_online);
p_contact_set_presence(contact, resource_chat);
p_contact_set_presence(contact, resource_away);
@@ -358,17 +337,16 @@ contact_not_available_when_highest_priority_xa(void** state)
p_contact_free(contact);
}
void
contact_not_available_when_highest_priority_dnd(void** state)
void contact_not_available_when_highest_priority_dnd(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, NULL,
"is offline", FALSE);
"is offline", FALSE);
Resource* resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10);
Resource* resource_chat = resource_new("resource_chat", RESOURCE_CHAT, NULL, 10);
Resource* resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource* resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource* resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 20);
Resource *resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10);
Resource *resource_chat = resource_new("resource_chat", RESOURCE_CHAT, NULL, 10);
Resource *resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource *resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource *resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 20);
p_contact_set_presence(contact, resource_online);
p_contact_set_presence(contact, resource_chat);
p_contact_set_presence(contact, resource_away);
@@ -382,17 +360,16 @@ contact_not_available_when_highest_priority_dnd(void** state)
p_contact_free(contact);
}
void
contact_available_when_highest_priority_online(void** state)
void contact_available_when_highest_priority_online(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, NULL,
"is offline", FALSE);
"is offline", FALSE);
Resource* resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 20);
Resource* resource_chat = resource_new("resource_chat", RESOURCE_CHAT, NULL, 10);
Resource* resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource* resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource* resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
Resource *resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 20);
Resource *resource_chat = resource_new("resource_chat", RESOURCE_CHAT, NULL, 10);
Resource *resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource *resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource *resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
p_contact_set_presence(contact, resource_online);
p_contact_set_presence(contact, resource_chat);
p_contact_set_presence(contact, resource_away);
@@ -406,17 +383,16 @@ contact_available_when_highest_priority_online(void** state)
p_contact_free(contact);
}
void
contact_available_when_highest_priority_chat(void** state)
void contact_available_when_highest_priority_chat(void **state)
{
PContact contact = p_contact_new("bob@server.com", "bob", NULL, NULL,
"is offline", FALSE);
"is offline", FALSE);
Resource* resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10);
Resource* resource_chat = resource_new("resource_chat", RESOURCE_CHAT, NULL, 20);
Resource* resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource* resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource* resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
Resource *resource_online = resource_new("resource_online", RESOURCE_ONLINE, NULL, 10);
Resource *resource_chat = resource_new("resource_chat", RESOURCE_CHAT, NULL, 20);
Resource *resource_away = resource_new("resource_away", RESOURCE_AWAY, NULL, 10);
Resource *resource_xa = resource_new("resource_xa", RESOURCE_XA, NULL, 10);
Resource *resource_dnd = resource_new("resource_dnd", RESOURCE_DND, NULL, 10);
p_contact_set_presence(contact, resource_online);
p_contact_set_presence(contact, resource_chat);
p_contact_set_presence(contact, resource_away);

48
tests/unittests/test_contact.h
View File

@@ -1,24 +1,24 @@
void contact_in_group(void** state);
void contact_not_in_group(void** state);
void contact_name_when_name_exists(void** state);
void contact_jid_when_name_not_exists(void** state);
void contact_string_when_name_exists(void** state);
void contact_string_when_name_not_exists(void** state);
void contact_string_when_default_resource(void** state);
void contact_presence_offline(void** state);
void contact_presence_uses_highest_priority(void** state);
void contact_presence_chat_when_same_prioroty(void** state);
void contact_presence_online_when_same_prioroty(void** state);
void contact_presence_away_when_same_prioroty(void** state);
void contact_presence_xa_when_same_prioroty(void** state);
void contact_presence_dnd(void** state);
void contact_subscribed_when_to(void** state);
void contact_subscribed_when_both(void** state);
void contact_not_subscribed_when_from(void** state);
void contact_not_subscribed_when_no_subscription_value(void** state);
void contact_not_available(void** state);
void contact_not_available_when_highest_priority_away(void** state);
void contact_not_available_when_highest_priority_xa(void** state);
void contact_not_available_when_highest_priority_dnd(void** state);
void contact_available_when_highest_priority_online(void** state);
void contact_available_when_highest_priority_chat(void** state);
void contact_in_group(void **state);
void contact_not_in_group(void **state);
void contact_name_when_name_exists(void **state);
void contact_jid_when_name_not_exists(void **state);
void contact_string_when_name_exists(void **state);
void contact_string_when_name_not_exists(void **state);
void contact_string_when_default_resource(void **state);
void contact_presence_offline(void **state);
void contact_presence_uses_highest_priority(void **state);
void contact_presence_chat_when_same_prioroty(void **state);
void contact_presence_online_when_same_prioroty(void **state);
void contact_presence_away_when_same_prioroty(void **state);
void contact_presence_xa_when_same_prioroty(void **state);
void contact_presence_dnd(void **state);
void contact_subscribed_when_to(void **state);
void contact_subscribed_when_both(void **state);
void contact_not_subscribed_when_from(void **state);
void contact_not_subscribed_when_no_subscription_value(void **state);
void contact_not_available(void **state);
void contact_not_available_when_highest_priority_away(void **state);
void contact_not_available_when_highest_priority_xa(void **state);
void contact_not_available_when_highest_priority_dnd(void **state);
void contact_available_when_highest_priority_online(void **state);
void contact_available_when_highest_priority_chat(void **state);

270
tests/unittests/test_form.c
View File

@@ -1,14 +1,13 @@
#include <cmocka.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include "xmpp/form.h"
xmpp_ctx_t*
connection_get_ctx(void)
xmpp_ctx_t* connection_get_ctx(void)
{
return NULL;
}
@@ -16,7 +15,7 @@ connection_get_ctx(void)
static DataForm*
_new_form(void)
{
DataForm* form = malloc(sizeof(DataForm));
DataForm *form = malloc(sizeof(DataForm));
form->type = NULL;
form->title = NULL;
form->instructions = NULL;
@@ -31,7 +30,7 @@ _new_form(void)
static FormField*
_new_field(void)
{
FormField* field = malloc(sizeof(FormField));
FormField *field = malloc(sizeof(FormField));
field->label = NULL;
field->type = NULL;
field->description = NULL;
@@ -42,67 +41,64 @@ _new_field(void)
field->value_ac = NULL;
return field;
}
void
get_form_type_field_returns_null_no_fields(void** state)
void get_form_type_field_returns_null_no_fields(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
char* result = form_get_form_type_field(form);
char *result = form_get_form_type_field(form);
assert_null(result);
form_destroy(form);
}
void
get_form_type_field_returns_null_when_not_present(void** state)
void get_form_type_field_returns_null_when_not_present(void **state)
{
DataForm* form = _new_form();
FormField* field = _new_field();
DataForm *form = _new_form();
FormField *field = _new_field();
field->var = strdup("var1");
field->values = g_slist_append(field->values, strdup("value1"));
form->fields = g_slist_append(form->fields, field);
char* result = form_get_form_type_field(form);
char *result = form_get_form_type_field(form);
assert_null(result);
form_destroy(form);
}
void
get_form_type_field_returns_value_when_present(void** state)
void get_form_type_field_returns_value_when_present(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->values = g_slist_append(field1->values, strdup("value1"));
form->fields = g_slist_append(form->fields, field1);
FormField* field2 = _new_field();
FormField *field2 = _new_field();
field2->var = strdup("FORM_TYPE");
field2->values = g_slist_append(field2->values, strdup("value2"));
form->fields = g_slist_append(form->fields, field2);
FormField* field3 = _new_field();
FormField *field3 = _new_field();
field3->var = strdup("var3");
field3->values = g_slist_append(field3->values, strdup("value3"));
form->fields = g_slist_append(form->fields, field3);
char* result = form_get_form_type_field(form);
char *result = form_get_form_type_field(form);
assert_string_equal(result, "value2");
form_destroy(form);
}
void
get_field_type_returns_unknown_when_no_fields(void** state)
void get_field_type_returns_unknown_when_no_fields(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
form_field_type_t result = form_get_field_type(form, "tag");
@@ -111,20 +107,19 @@ get_field_type_returns_unknown_when_no_fields(void** state)
form_destroy(form);
}
void
get_field_type_returns_correct_type(void** state)
void get_field_type_returns_correct_type(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
g_hash_table_insert(form->tag_to_var, strdup("tag2"), strdup("var2"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_TEXT_SINGLE;
field1->values = g_slist_append(field1->values, strdup("value1"));
form->fields = g_slist_append(form->fields, field1);
FormField* field2 = _new_field();
FormField *field2 = _new_field();
field2->var = strdup("var2");
field2->type_t = FIELD_TEXT_MULTI;
field2->values = g_slist_append(field2->values, strdup("value2"));
@@ -137,20 +132,19 @@ get_field_type_returns_correct_type(void** state)
form_destroy(form);
}
void
set_value_adds_when_none(void** state)
void set_value_adds_when_none(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
g_hash_table_insert(form->tag_to_var, strdup("tag2"), strdup("var2"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_TEXT_SINGLE;
field1->values = g_slist_append(field1->values, strdup("value1"));
form->fields = g_slist_append(form->fields, field1);
FormField* field2 = _new_field();
FormField *field2 = _new_field();
field2->var = strdup("var2");
field2->type_t = FIELD_LIST_SINGLE;
form->fields = g_slist_append(form->fields, field2);
@@ -158,10 +152,10 @@ set_value_adds_when_none(void** state)
form_set_value(form, "tag2", "a new value");
int length = 0;
char* value = NULL;
GSList* curr_field = form->fields;
char *value = NULL;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var2") == 0) {
length = g_slist_length(field->values);
value = field->values->data;
@@ -176,19 +170,18 @@ set_value_adds_when_none(void** state)
form_destroy(form);
}
void
set_value_updates_when_one(void** state)
void set_value_updates_when_one(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
g_hash_table_insert(form->tag_to_var, strdup("tag2"), strdup("var2"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_TEXT_SINGLE;
form->fields = g_slist_append(form->fields, field1);
FormField* field2 = _new_field();
FormField *field2 = _new_field();
field2->var = strdup("var2");
field2->type_t = FIELD_LIST_SINGLE;
field2->values = g_slist_append(field2->values, strdup("value2"));
@@ -197,10 +190,10 @@ set_value_updates_when_one(void** state)
form_set_value(form, "tag2", "a new value");
int length = 0;
char* value = NULL;
GSList* curr_field = form->fields;
char *value = NULL;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var2") == 0) {
length = g_slist_length(field->values);
value = field->values->data;
@@ -215,19 +208,18 @@ set_value_updates_when_one(void** state)
form_destroy(form);
}
void
add_unique_value_adds_when_none(void** state)
void add_unique_value_adds_when_none(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
g_hash_table_insert(form->tag_to_var, strdup("tag2"), strdup("var2"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_JID_MULTI;
form->fields = g_slist_append(form->fields, field1);
FormField* field2 = _new_field();
FormField *field2 = _new_field();
field2->var = strdup("var2");
field2->type_t = FIELD_LIST_SINGLE;
field2->values = g_slist_append(field2->values, strdup("value2"));
@@ -236,10 +228,10 @@ add_unique_value_adds_when_none(void** state)
gboolean ret = form_add_unique_value(form, "tag1", "me@server.com");
int length = 0;
char* value = NULL;
GSList* curr_field = form->fields;
char *value = NULL;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
length = g_slist_length(field->values);
value = field->values->data;
@@ -255,20 +247,19 @@ add_unique_value_adds_when_none(void** state)
form_destroy(form);
}
void
add_unique_value_does_nothing_when_exists(void** state)
void add_unique_value_does_nothing_when_exists(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
g_hash_table_insert(form->tag_to_var, strdup("tag2"), strdup("var2"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_JID_MULTI;
field1->values = g_slist_append(field1->values, strdup("me@server.com"));
form->fields = g_slist_append(form->fields, field1);
FormField* field2 = _new_field();
FormField *field2 = _new_field();
field2->var = strdup("var2");
field2->type_t = FIELD_LIST_SINGLE;
field2->values = g_slist_append(field2->values, strdup("value2"));
@@ -277,10 +268,10 @@ add_unique_value_does_nothing_when_exists(void** state)
gboolean ret = form_add_unique_value(form, "tag1", "me@server.com");
int length = 0;
char* value = NULL;
GSList* curr_field = form->fields;
char *value = NULL;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
length = g_slist_length(field->values);
value = field->values->data;
@@ -296,14 +287,13 @@ add_unique_value_does_nothing_when_exists(void** state)
form_destroy(form);
}
void
add_unique_value_adds_when_doesnt_exist(void** state)
void add_unique_value_adds_when_doesnt_exist(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
g_hash_table_insert(form->tag_to_var, strdup("tag2"), strdup("var2"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_JID_MULTI;
field1->values = g_slist_append(field1->values, strdup("dolan@server.com"));
@@ -311,7 +301,7 @@ add_unique_value_adds_when_doesnt_exist(void** state)
field1->values = g_slist_append(field1->values, strdup("chi@server.com"));
form->fields = g_slist_append(form->fields, field1);
FormField* field2 = _new_field();
FormField *field2 = _new_field();
field2->var = strdup("var2");
field2->type_t = FIELD_LIST_SINGLE;
field2->values = g_slist_append(field2->values, strdup("value2"));
@@ -321,12 +311,12 @@ add_unique_value_adds_when_doesnt_exist(void** state)
int length = 0;
int count = 0;
GSList* curr_field = form->fields;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
length = g_slist_length(field->values);
GSList* curr_value = field->values;
GSList *curr_value = field->values;
while (curr_value != NULL) {
if (g_strcmp0(curr_value->data, "me@server.com") == 0) {
count++;
@@ -345,13 +335,12 @@ add_unique_value_adds_when_doesnt_exist(void** state)
form_destroy(form);
}
void
add_value_adds_when_none(void** state)
void add_value_adds_when_none(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_LIST_MULTI;
form->fields = g_slist_append(form->fields, field1);
@@ -359,10 +348,10 @@ add_value_adds_when_none(void** state)
form_add_value(form, "tag1", "somevalue");
int length = 0;
char* value = NULL;
GSList* curr_field = form->fields;
char *value = NULL;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
length = g_slist_length(field->values);
value = field->values->data;
@@ -377,13 +366,12 @@ add_value_adds_when_none(void** state)
form_destroy(form);
}
void
add_value_adds_when_some(void** state)
void add_value_adds_when_some(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_LIST_MULTI;
field1->values = g_slist_append(field1->values, strdup("some text"));
@@ -395,11 +383,11 @@ add_value_adds_when_some(void** state)
int num_values = 0;
int new_value_count = 0;
GSList* curr_field = form->fields;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
GSList* curr_value = field->values;
GSList *curr_value = field->values;
while (curr_value != NULL) {
num_values++;
if (g_strcmp0(curr_value->data, "new value") == 0) {
@@ -418,13 +406,12 @@ add_value_adds_when_some(void** state)
form_destroy(form);
}
void
add_value_adds_when_exists(void** state)
void add_value_adds_when_exists(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_LIST_MULTI;
field1->values = g_slist_append(field1->values, strdup("some text"));
@@ -437,11 +424,11 @@ add_value_adds_when_exists(void** state)
int num_values = 0;
int new_value_count = 0;
GSList* curr_field = form->fields;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
GSList* curr_value = field->values;
GSList *curr_value = field->values;
while (curr_value != NULL) {
num_values++;
if (g_strcmp0(curr_value->data, "new value") == 0) {
@@ -460,13 +447,12 @@ add_value_adds_when_exists(void** state)
form_destroy(form);
}
void
remove_value_does_nothing_when_none(void** state)
void remove_value_does_nothing_when_none(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_LIST_MULTI;
form->fields = g_slist_append(form->fields, field1);
@@ -474,9 +460,9 @@ remove_value_does_nothing_when_none(void** state)
gboolean res = form_remove_value(form, "tag1", "some value");
int length = -1;
GSList* curr_field = form->fields;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
length = g_slist_length(field->values);
}
@@ -489,13 +475,12 @@ remove_value_does_nothing_when_none(void** state)
form_destroy(form);
}
void
remove_value_does_nothing_when_doesnt_exist(void** state)
void remove_value_does_nothing_when_doesnt_exist(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_LIST_MULTI;
field1->values = g_slist_append(field1->values, strdup("value1"));
@@ -508,12 +493,12 @@ remove_value_does_nothing_when_doesnt_exist(void** state)
int length = -1;
int value_count = 0;
GSList* curr_field = form->fields;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
length = g_slist_length(field->values);
GSList* curr_value = field->values;
GSList *curr_value = field->values;
while (curr_value != NULL) {
if (g_strcmp0(curr_value->data, "value5") == 0) {
value_count++;
@@ -531,13 +516,12 @@ remove_value_does_nothing_when_doesnt_exist(void** state)
form_destroy(form);
}
void
remove_value_removes_when_one(void** state)
void remove_value_removes_when_one(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_LIST_MULTI;
field1->values = g_slist_append(field1->values, strdup("value4"));
@@ -546,9 +530,9 @@ remove_value_removes_when_one(void** state)
gboolean res = form_remove_value(form, "tag1", "value4");
int length = -1;
GSList* curr_field = form->fields;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
length = g_slist_length(field->values);
}
@@ -561,13 +545,12 @@ remove_value_removes_when_one(void** state)
form_destroy(form);
}
void
remove_value_removes_when_many(void** state)
void remove_value_removes_when_many(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_LIST_MULTI;
field1->values = g_slist_append(field1->values, strdup("value1"));
@@ -580,12 +563,12 @@ remove_value_removes_when_many(void** state)
int length = -1;
int value_count = 0;
GSList* curr_field = form->fields;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
length = g_slist_length(field->values);
GSList* curr_value = field->values;
GSList *curr_value = field->values;
while (curr_value != NULL) {
if (g_strcmp0(curr_value->data, "value2") == 0) {
value_count++;
@@ -603,13 +586,12 @@ remove_value_removes_when_many(void** state)
form_destroy(form);
}
void
remove_text_multi_value_does_nothing_when_none(void** state)
void remove_text_multi_value_does_nothing_when_none(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_LIST_MULTI;
form->fields = g_slist_append(form->fields, field1);
@@ -617,9 +599,9 @@ remove_text_multi_value_does_nothing_when_none(void** state)
gboolean res = form_remove_text_multi_value(form, "tag1", 3);
int length = -1;
GSList* curr_field = form->fields;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
length = g_slist_length(field->values);
}
@@ -632,13 +614,12 @@ remove_text_multi_value_does_nothing_when_none(void** state)
form_destroy(form);
}
void
remove_text_multi_value_does_nothing_when_doesnt_exist(void** state)
void remove_text_multi_value_does_nothing_when_doesnt_exist(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_LIST_MULTI;
field1->values = g_slist_append(field1->values, strdup("value1"));
@@ -651,12 +632,12 @@ remove_text_multi_value_does_nothing_when_doesnt_exist(void** state)
int length = -1;
int value_count = 0;
GSList* curr_field = form->fields;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
length = g_slist_length(field->values);
GSList* curr_value = field->values;
GSList *curr_value = field->values;
while (curr_value != NULL) {
if (g_strcmp0(curr_value->data, "value5") == 0) {
value_count++;
@@ -674,13 +655,12 @@ remove_text_multi_value_does_nothing_when_doesnt_exist(void** state)
form_destroy(form);
}
void
remove_text_multi_value_removes_when_one(void** state)
void remove_text_multi_value_removes_when_one(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_LIST_MULTI;
field1->values = g_slist_append(field1->values, strdup("value4"));
@@ -689,9 +669,9 @@ remove_text_multi_value_removes_when_one(void** state)
gboolean res = form_remove_text_multi_value(form, "tag1", 1);
int length = -1;
GSList* curr_field = form->fields;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
length = g_slist_length(field->values);
}
@@ -704,13 +684,12 @@ remove_text_multi_value_removes_when_one(void** state)
form_destroy(form);
}
void
remove_text_multi_value_removes_when_many(void** state)
void remove_text_multi_value_removes_when_many(void **state)
{
DataForm* form = _new_form();
DataForm *form = _new_form();
g_hash_table_insert(form->tag_to_var, strdup("tag1"), strdup("var1"));
FormField* field1 = _new_field();
FormField *field1 = _new_field();
field1->var = strdup("var1");
field1->type_t = FIELD_LIST_MULTI;
field1->values = g_slist_append(field1->values, strdup("value1"));
@@ -723,12 +702,12 @@ remove_text_multi_value_removes_when_many(void** state)
int length = -1;
int value_count = 0;
GSList* curr_field = form->fields;
GSList *curr_field = form->fields;
while (curr_field != NULL) {
FormField* field = curr_field->data;
FormField *field = curr_field->data;
if (g_strcmp0(field->var, "var1") == 0) {
length = g_slist_length(field->values);
GSList* curr_value = field->values;
GSList *curr_value = field->values;
while (curr_value != NULL) {
if (g_strcmp0(curr_value->data, "value2") == 0) {
value_count++;
@@ -745,3 +724,4 @@ remove_text_multi_value_removes_when_many(void** state)
form_destroy(form);
}

42
tests/unittests/test_form.h
View File

@@ -1,21 +1,21 @@
void get_form_type_field_returns_null_no_fields(void** state);
void get_form_type_field_returns_null_when_not_present(void** state);
void get_form_type_field_returns_value_when_present(void** state);
void get_field_type_returns_unknown_when_no_fields(void** state);
void get_field_type_returns_correct_type(void** state);
void set_value_adds_when_none(void** state);
void set_value_updates_when_one(void** state);
void add_unique_value_adds_when_none(void** state);
void add_unique_value_does_nothing_when_exists(void** state);
void add_unique_value_adds_when_doesnt_exist(void** state);
void add_value_adds_when_none(void** state);
void add_value_adds_when_some(void** state);
void add_value_adds_when_exists(void** state);
void remove_value_does_nothing_when_none(void** state);
void remove_value_does_nothing_when_doesnt_exist(void** state);
void remove_value_removes_when_one(void** state);
void remove_value_removes_when_many(void** state);
void remove_text_multi_value_does_nothing_when_none(void** state);
void remove_text_multi_value_does_nothing_when_doesnt_exist(void** state);
void remove_text_multi_value_removes_when_one(void** state);
void remove_text_multi_value_removes_when_many(void** state);
void get_form_type_field_returns_null_no_fields(void **state);
void get_form_type_field_returns_null_when_not_present(void **state);
void get_form_type_field_returns_value_when_present(void **state);
void get_field_type_returns_unknown_when_no_fields(void **state);
void get_field_type_returns_correct_type(void **state);
void set_value_adds_when_none(void **state);
void set_value_updates_when_one(void **state);
void add_unique_value_adds_when_none(void **state);
void add_unique_value_does_nothing_when_exists(void **state);
void add_unique_value_adds_when_doesnt_exist(void **state);
void add_value_adds_when_none(void **state);
void add_value_adds_when_some(void **state);
void add_value_adds_when_exists(void **state);
void remove_value_does_nothing_when_none(void **state);
void remove_value_does_nothing_when_doesnt_exist(void **state);
void remove_value_removes_when_one(void **state);
void remove_value_removes_when_many(void **state);
void remove_text_multi_value_does_nothing_when_none(void **state);
void remove_text_multi_value_does_nothing_when_doesnt_exist(void **state);
void remove_text_multi_value_removes_when_one(void **state);
void remove_text_multi_value_removes_when_many(void **state);

133
tests/unittests/test_jid.c
View File

@@ -1,167 +1,147 @@
#include <cmocka.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include "xmpp/jid.h"
void
create_jid_from_null_returns_null(void** state)
void create_jid_from_null_returns_null(void **state)
{
Jid* result = jid_create(NULL);
Jid *result = jid_create(NULL);
assert_null(result);
}
void
create_jid_from_empty_string_returns_null(void** state)
void create_jid_from_empty_string_returns_null(void **state)
{
Jid* result = jid_create("");
Jid *result = jid_create("");
assert_null(result);
}
void
create_jid_from_full_returns_full(void** state)
void create_jid_from_full_returns_full(void **state)
{
Jid* result = jid_create("myuser@mydomain/laptop");
Jid *result = jid_create("myuser@mydomain/laptop");
assert_string_equal("myuser@mydomain/laptop", result->fulljid);
jid_destroy(result);
}
void
create_jid_from_full_returns_bare(void** state)
void create_jid_from_full_returns_bare(void **state)
{
Jid* result = jid_create("myuser@mydomain/laptop");
Jid *result = jid_create("myuser@mydomain/laptop");
assert_string_equal("myuser@mydomain", result->barejid);
jid_destroy(result);
}
void
create_jid_from_full_returns_resourcepart(void** state)
void create_jid_from_full_returns_resourcepart(void **state)
{
Jid* result = jid_create("myuser@mydomain/laptop");
Jid *result = jid_create("myuser@mydomain/laptop");
assert_string_equal("laptop", result->resourcepart);
jid_destroy(result);
}
void
create_jid_from_full_returns_localpart(void** state)
void create_jid_from_full_returns_localpart(void **state)
{
Jid* result = jid_create("myuser@mydomain/laptop");
Jid *result = jid_create("myuser@mydomain/laptop");
assert_string_equal("myuser", result->localpart);
jid_destroy(result);
}
void
create_jid_from_full_returns_domainpart(void** state)
void create_jid_from_full_returns_domainpart(void **state)
{
Jid* result = jid_create("myuser@mydomain/laptop");
Jid *result = jid_create("myuser@mydomain/laptop");
assert_string_equal("mydomain", result->domainpart);
jid_destroy(result);
}
void
create_jid_from_full_nolocal_returns_full(void** state)
void create_jid_from_full_nolocal_returns_full(void **state)
{
Jid* result = jid_create("mydomain/laptop");
Jid *result = jid_create("mydomain/laptop");
assert_string_equal("mydomain/laptop", result->fulljid);
jid_destroy(result);
}
void
create_jid_from_full_nolocal_returns_bare(void** state)
void create_jid_from_full_nolocal_returns_bare(void **state)
{
Jid* result = jid_create("mydomain/laptop");
Jid *result = jid_create("mydomain/laptop");
assert_string_equal("mydomain", result->barejid);
jid_destroy(result);
}
void
create_jid_from_full_nolocal_returns_resourcepart(void** state)
void create_jid_from_full_nolocal_returns_resourcepart(void **state)
{
Jid* result = jid_create("mydomain/laptop");
Jid *result = jid_create("mydomain/laptop");
assert_string_equal("laptop", result->resourcepart);
jid_destroy(result);
}
void
create_jid_from_full_nolocal_returns_domainpart(void** state)
void create_jid_from_full_nolocal_returns_domainpart(void **state)
{
Jid* result = jid_create("mydomain/laptop");
Jid *result = jid_create("mydomain/laptop");
assert_string_equal("mydomain", result->domainpart);
jid_destroy(result);
}
void
create_jid_from_full_nolocal_returns_null_localpart(void** state)
void create_jid_from_full_nolocal_returns_null_localpart(void **state)
{
Jid* result = jid_create("mydomain/laptop");
Jid *result = jid_create("mydomain/laptop");
assert_null(result->localpart);
jid_destroy(result);
}
void
create_jid_from_bare_returns_null_full(void** state)
void create_jid_from_bare_returns_null_full(void **state)
{
Jid* result = jid_create("myuser@mydomain");
Jid *result = jid_create("myuser@mydomain");
assert_null(result->fulljid);
jid_destroy(result);
}
void
create_jid_from_bare_returns_null_resource(void** state)
void create_jid_from_bare_returns_null_resource(void **state)
{
Jid* result = jid_create("myuser@mydomain");
Jid *result = jid_create("myuser@mydomain");
assert_null(result->resourcepart);
jid_destroy(result);
}
void
create_jid_from_bare_returns_bare(void** state)
void create_jid_from_bare_returns_bare(void **state)
{
Jid* result = jid_create("myuser@mydomain");
Jid *result = jid_create("myuser@mydomain");
assert_string_equal("myuser@mydomain", result->barejid);
jid_destroy(result);
}
void
create_jid_from_bare_returns_localpart(void** state)
void create_jid_from_bare_returns_localpart(void **state)
{
Jid* result = jid_create("myuser@mydomain");
Jid *result = jid_create("myuser@mydomain");
assert_string_equal("myuser", result->localpart);
jid_destroy(result);
}
void
create_jid_from_bare_returns_domainpart(void** state)
void create_jid_from_bare_returns_domainpart(void **state)
{
Jid* result = jid_create("myuser@mydomain");
Jid *result = jid_create("myuser@mydomain");
assert_string_equal("mydomain", result->domainpart);
jid_destroy(result);
}
void
create_room_jid_returns_room(void** state)
void create_room_jid_returns_room(void **state)
{
Jid* result = jid_create_from_bare_and_resource("room@conference.domain.org", "myname");
Jid *result = jid_create_from_bare_and_resource("room@conference.domain.org", "myname");
assert_string_equal("room@conference.domain.org", result->barejid);
jid_destroy(result);
}
void
create_room_jid_returns_nick(void** state)
void create_room_jid_returns_nick(void **state)
{
Jid* result = jid_create_from_bare_and_resource("room@conference.domain.org", "myname");
Jid *result = jid_create_from_bare_and_resource("room@conference.domain.org", "myname");
assert_string_equal("myname", result->resourcepart);
jid_destroy(result);
}
void
create_with_slash_in_resource(void** state)
void create_with_slash_in_resource(void **state)
{
Jid* result = jid_create("room@conference.domain.org/my/nick");
Jid *result = jid_create("room@conference.domain.org/my/nick");
assert_string_equal("room", result->localpart);
assert_string_equal("conference.domain.org", result->domainpart);
@@ -172,10 +152,9 @@ create_with_slash_in_resource(void** state)
jid_destroy(result);
}
void
create_with_at_in_resource(void** state)
void create_with_at_in_resource(void **state)
{
Jid* result = jid_create("room@conference.domain.org/my@nick");
Jid *result = jid_create("room@conference.domain.org/my@nick");
assert_string_equal("room", result->localpart);
assert_string_equal("conference.domain.org", result->domainpart);
@@ -186,10 +165,9 @@ create_with_at_in_resource(void** state)
jid_destroy(result);
}
void
create_with_at_and_slash_in_resource(void** state)
void create_with_at_and_slash_in_resource(void **state)
{
Jid* result = jid_create("room@conference.domain.org/my@nick/something");
Jid *result = jid_create("room@conference.domain.org/my@nick/something");
assert_string_equal("room", result->localpart);
assert_string_equal("conference.domain.org", result->domainpart);
@@ -200,10 +178,9 @@ create_with_at_and_slash_in_resource(void** state)
jid_destroy(result);
}
void
create_full_with_trailing_slash(void** state)
void create_full_with_trailing_slash(void **state)
{
Jid* result = jid_create("room@conference.domain.org/nick/");
Jid *result = jid_create("room@conference.domain.org/nick/");
assert_string_equal("room", result->localpart);
assert_string_equal("conference.domain.org", result->domainpart);
@@ -214,24 +191,22 @@ create_full_with_trailing_slash(void** state)
jid_destroy(result);
}
void
returns_fulljid_when_exists(void** state)
void returns_fulljid_when_exists(void **state)
{
Jid* jid = jid_create("localpart@domainpart/resourcepart");
Jid *jid = jid_create("localpart@domainpart/resourcepart");
char* result = jid_fulljid_or_barejid(jid);
char *result = jid_fulljid_or_barejid(jid);
assert_string_equal("localpart@domainpart/resourcepart", result);
jid_destroy(jid);
}
void
returns_barejid_when_fulljid_not_exists(void** state)
void returns_barejid_when_fulljid_not_exists(void **state)
{
Jid* jid = jid_create("localpart@domainpart");
Jid *jid = jid_create("localpart@domainpart");
char* result = jid_fulljid_or_barejid(jid);
char *result = jid_fulljid_or_barejid(jid);
assert_string_equal("localpart@domainpart", result);

50
tests/unittests/test_jid.h
View File

@@ -1,25 +1,25 @@
void create_jid_from_null_returns_null(void** state);
void create_jid_from_empty_string_returns_null(void** state);
void create_jid_from_full_returns_full(void** state);
void create_jid_from_full_returns_bare(void** state);
void create_jid_from_full_returns_resourcepart(void** state);
void create_jid_from_full_returns_localpart(void** state);
void create_jid_from_full_returns_domainpart(void** state);
void create_jid_from_full_nolocal_returns_full(void** state);
void create_jid_from_full_nolocal_returns_bare(void** state);
void create_jid_from_full_nolocal_returns_resourcepart(void** state);
void create_jid_from_full_nolocal_returns_domainpart(void** state);
void create_jid_from_full_nolocal_returns_null_localpart(void** state);
void create_jid_from_bare_returns_null_full(void** state);
void create_jid_from_bare_returns_null_resource(void** state);
void create_jid_from_bare_returns_bare(void** state);
void create_jid_from_bare_returns_localpart(void** state);
void create_jid_from_bare_returns_domainpart(void** state);
void create_room_jid_returns_room(void** state);
void create_room_jid_returns_nick(void** state);
void create_with_slash_in_resource(void** state);
void create_with_at_in_resource(void** state);
void create_with_at_and_slash_in_resource(void** state);
void create_full_with_trailing_slash(void** state);
void returns_fulljid_when_exists(void** state);
void returns_barejid_when_fulljid_not_exists(void** state);
void create_jid_from_null_returns_null(void **state);
void create_jid_from_empty_string_returns_null(void **state);
void create_jid_from_full_returns_full(void **state);
void create_jid_from_full_returns_bare(void **state);
void create_jid_from_full_returns_resourcepart(void **state);
void create_jid_from_full_returns_localpart(void **state);
void create_jid_from_full_returns_domainpart(void **state);
void create_jid_from_full_nolocal_returns_full(void **state);
void create_jid_from_full_nolocal_returns_bare(void **state);
void create_jid_from_full_nolocal_returns_resourcepart(void **state);
void create_jid_from_full_nolocal_returns_domainpart(void **state);
void create_jid_from_full_nolocal_returns_null_localpart(void **state);
void create_jid_from_bare_returns_null_full(void **state);
void create_jid_from_bare_returns_null_resource(void **state);
void create_jid_from_bare_returns_bare(void **state);
void create_jid_from_bare_returns_localpart(void **state);
void create_jid_from_bare_returns_domainpart(void **state);
void create_room_jid_returns_room(void **state);
void create_room_jid_returns_nick(void **state);
void create_with_slash_in_resource(void **state);
void create_with_at_in_resource(void **state);
void create_with_at_and_slash_in_resource(void **state);
void create_full_with_trailing_slash(void **state);
void returns_fulljid_when_exists(void **state);
void returns_barejid_when_fulljid_not_exists(void **state);

38
tests/unittests/test_muc.c
View File

@@ -1,27 +1,24 @@
#include <cmocka.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include "xmpp/muc.h"
void
muc_before_test(void** state)
void muc_before_test(void **state)
{
muc_init();
}
void
muc_after_test(void** state)
void muc_after_test(void **state)
{
muc_close();
}
void
test_muc_invites_add(void** state)
void test_muc_invites_add(void **state)
{
char* room = "room@conf.server";
char *room = "room@conf.server";
muc_invites_add(room, NULL);
gboolean invite_exists = muc_invites_contain(room);
@@ -29,10 +26,9 @@ test_muc_invites_add(void** state)
assert_true(invite_exists);
}
void
test_muc_remove_invite(void** state)
void test_muc_remove_invite(void **state)
{
char* room = "room@conf.server";
char *room = "room@conf.server";
muc_invites_add(room, NULL);
muc_invites_remove(room);
@@ -41,16 +37,14 @@ test_muc_remove_invite(void** state)
assert_false(invite_exists);
}
void
test_muc_invites_count_0(void** state)
void test_muc_invites_count_0(void **state)
{
int invite_count = muc_invites_count();
assert_true(invite_count == 0);
}
void
test_muc_invites_count_5(void** state)
void test_muc_invites_count_5(void **state)
{
muc_invites_add("room1@conf.server", NULL);
muc_invites_add("room2@conf.server", NULL);
@@ -63,21 +57,19 @@ test_muc_invites_count_5(void** state)
assert_true(invite_count == 5);
}
void
test_muc_room_is_not_active(void** state)
void test_muc_room_is_not_active(void **state)
{
char* room = "room@server.org";
char *room = "room@server.org";
gboolean room_is_active = muc_active(room);
assert_false(room_is_active);
}
void
test_muc_active(void** state)
void test_muc_active(void **state)
{
char* room = "room@server.org";
char* nick = "bob";
char *room = "room@server.org";
char *nick = "bob";
muc_join(room, nick, NULL, FALSE);
gboolean room_is_active = muc_active(room);

16
tests/unittests/test_muc.h
View File

@@ -1,9 +1,9 @@
void muc_before_test(void** state);
void muc_after_test(void** state);
void muc_before_test(void **state);
void muc_after_test(void **state);
void test_muc_invites_add(void** state);
void test_muc_remove_invite(void** state);
void test_muc_invites_count_0(void** state);
void test_muc_invites_count_5(void** state);
void test_muc_room_is_not_active(void** state);
void test_muc_active(void** state);
void test_muc_invites_add(void **state);
void test_muc_remove_invite(void **state);
void test_muc_invites_count_0(void **state);
void test_muc_invites_count_5(void **state);
void test_muc_room_is_not_active(void **state);
void test_muc_active(void **state);

308
tests/unittests/test_parser.c
View File

@@ -1,17 +1,17 @@
#include <cmocka.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include "tools/parser.h"
void
parse_null_returns_null(void** state)
parse_null_returns_null(void **state)
{
char* inp = NULL;
char *inp = NULL;
gboolean result = TRUE;
gchar** args = parse_args(inp, 1, 2, &result);
gchar **args = parse_args(inp, 1, 2, &result);
assert_false(result);
assert_null(args);
@@ -19,11 +19,11 @@ parse_null_returns_null(void** state)
}
void
parse_empty_returns_null(void** state)
parse_empty_returns_null(void **state)
{
char* inp = "";
char *inp = "";
gboolean result = TRUE;
gchar** args = parse_args(inp, 1, 2, &result);
gchar **args = parse_args(inp, 1, 2, &result);
assert_false(result);
assert_null(args);
@@ -31,11 +31,11 @@ parse_empty_returns_null(void** state)
}
void
parse_space_returns_null(void** state)
parse_space_returns_null(void **state)
{
char* inp = " ";
char *inp = " ";
gboolean result = TRUE;
gchar** args = parse_args(inp, 1, 2, &result);
gchar **args = parse_args(inp, 1, 2, &result);
assert_false(result);
assert_null(args);
@@ -43,11 +43,11 @@ parse_space_returns_null(void** state)
}
void
parse_cmd_no_args_returns_null(void** state)
parse_cmd_no_args_returns_null(void **state)
{
char* inp = "/cmd";
char *inp = "/cmd";
gboolean result = TRUE;
gchar** args = parse_args(inp, 1, 2, &result);
gchar **args = parse_args(inp, 1, 2, &result);
assert_false(result);
assert_null(args);
@@ -55,11 +55,11 @@ parse_cmd_no_args_returns_null(void** state)
}
void
parse_cmd_with_space_returns_null(void** state)
parse_cmd_with_space_returns_null(void **state)
{
char* inp = "/cmd ";
char *inp = "/cmd ";
gboolean result = TRUE;
gchar** args = parse_args(inp, 1, 2, &result);
gchar **args = parse_args(inp, 1, 2, &result);
assert_false(result);
assert_null(args);
@@ -67,11 +67,11 @@ parse_cmd_with_space_returns_null(void** state)
}
void
parse_cmd_with_too_few_returns_null(void** state)
parse_cmd_with_too_few_returns_null(void **state)
{
char* inp = "/cmd arg1";
char *inp = "/cmd arg1";
gboolean result = TRUE;
gchar** args = parse_args(inp, 2, 3, &result);
gchar **args = parse_args(inp, 2, 3, &result);
assert_false(result);
assert_null(args);
@@ -79,11 +79,11 @@ parse_cmd_with_too_few_returns_null(void** state)
}
void
parse_cmd_with_too_many_returns_null(void** state)
parse_cmd_with_too_many_returns_null(void **state)
{
char* inp = "/cmd arg1 arg2 arg3 arg4";
char *inp = "/cmd arg1 arg2 arg3 arg4";
gboolean result = TRUE;
gchar** args = parse_args(inp, 1, 3, &result);
gchar **args = parse_args(inp, 1, 3, &result);
assert_false(result);
assert_null(args);
@@ -91,11 +91,11 @@ parse_cmd_with_too_many_returns_null(void** state)
}
void
parse_cmd_one_arg(void** state)
parse_cmd_one_arg(void **state)
{
char* inp = "/cmd arg1";
char *inp = "/cmd arg1";
gboolean result = FALSE;
gchar** args = parse_args(inp, 1, 2, &result);
gchar **args = parse_args(inp, 1, 2, &result);
assert_true(result);
assert_int_equal(1, g_strv_length(args));
@@ -104,11 +104,11 @@ parse_cmd_one_arg(void** state)
}
void
parse_cmd_two_args(void** state)
parse_cmd_two_args(void **state)
{
char* inp = "/cmd arg1 arg2";
char *inp = "/cmd arg1 arg2";
gboolean result = FALSE;
gchar** args = parse_args(inp, 1, 2, &result);
gchar **args = parse_args(inp, 1, 2, &result);
assert_true(result);
assert_int_equal(2, g_strv_length(args));
@@ -118,11 +118,11 @@ parse_cmd_two_args(void** state)
}
void
parse_cmd_three_args(void** state)
parse_cmd_three_args(void **state)
{
char* inp = "/cmd arg1 arg2 arg3";
char *inp = "/cmd arg1 arg2 arg3";
gboolean result = FALSE;
gchar** args = parse_args(inp, 3, 3, &result);
gchar **args = parse_args(inp, 3, 3, &result);
assert_true(result);
assert_int_equal(3, g_strv_length(args));
@@ -133,11 +133,11 @@ parse_cmd_three_args(void** state)
}
void
parse_cmd_three_args_with_spaces(void** state)
parse_cmd_three_args_with_spaces(void **state)
{
char* inp = " /cmd arg1 arg2 arg3 ";
char *inp = " /cmd arg1 arg2 arg3 ";
gboolean result = FALSE;
gchar** args = parse_args(inp, 3, 3, &result);
gchar **args = parse_args(inp, 3, 3, &result);
assert_true(result);
assert_int_equal(3, g_strv_length(args));
@@ -148,11 +148,11 @@ parse_cmd_three_args_with_spaces(void** state)
}
void
parse_cmd_with_freetext(void** state)
parse_cmd_with_freetext(void **state)
{
char* inp = "/cmd this is some free text";
char *inp = "/cmd this is some free text";
gboolean result = FALSE;
gchar** args = parse_args_with_freetext(inp, 1, 1, &result);
gchar **args = parse_args_with_freetext(inp, 1, 1, &result);
assert_true(result);
assert_int_equal(1, g_strv_length(args));
@@ -161,11 +161,11 @@ parse_cmd_with_freetext(void** state)
}
void
parse_cmd_one_arg_with_freetext(void** state)
parse_cmd_one_arg_with_freetext(void **state)
{
char* inp = "/cmd arg1 this is some free text";
char *inp = "/cmd arg1 this is some free text";
gboolean result = FALSE;
gchar** args = parse_args_with_freetext(inp, 1, 2, &result);
gchar **args = parse_args_with_freetext(inp, 1, 2, &result);
assert_true(result);
assert_int_equal(2, g_strv_length(args));
@@ -175,11 +175,11 @@ parse_cmd_one_arg_with_freetext(void** state)
}
void
parse_cmd_two_args_with_freetext(void** state)
parse_cmd_two_args_with_freetext(void **state)
{
char* inp = "/cmd arg1 arg2 this is some free text";
char *inp = "/cmd arg1 arg2 this is some free text";
gboolean result = FALSE;
gchar** args = parse_args_with_freetext(inp, 1, 3, &result);
gchar **args = parse_args_with_freetext(inp, 1, 3, &result);
assert_true(result);
assert_int_equal(3, g_strv_length(args));
@@ -190,11 +190,11 @@ parse_cmd_two_args_with_freetext(void** state)
}
void
parse_cmd_min_zero(void** state)
parse_cmd_min_zero(void **state)
{
char* inp = "/cmd";
char *inp = "/cmd";
gboolean result = FALSE;
gchar** args = parse_args(inp, 0, 2, &result);
gchar **args = parse_args(inp, 0, 2, &result);
assert_true(result);
assert_int_equal(0, g_strv_length(args));
@@ -203,11 +203,11 @@ parse_cmd_min_zero(void** state)
}
void
parse_cmd_min_zero_with_freetext(void** state)
parse_cmd_min_zero_with_freetext(void **state)
{
char* inp = "/cmd";
char *inp = "/cmd";
gboolean result = FALSE;
gchar** args = parse_args_with_freetext(inp, 0, 2, &result);
gchar **args = parse_args_with_freetext(inp, 0, 2, &result);
assert_true(result);
assert_int_equal(0, g_strv_length(args));
@@ -216,11 +216,11 @@ parse_cmd_min_zero_with_freetext(void** state)
}
void
parse_cmd_with_quoted(void** state)
parse_cmd_with_quoted(void **state)
{
char* inp = "/cmd \"arg1\" arg2";
char *inp = "/cmd \"arg1\" arg2";
gboolean result = FALSE;
gchar** args = parse_args(inp, 2, 2, &result);
gchar **args = parse_args(inp, 2, 2, &result);
assert_true(result);
assert_int_equal(2, g_strv_length(args));
@@ -230,11 +230,11 @@ parse_cmd_with_quoted(void** state)
}
void
parse_cmd_with_quoted_and_space(void** state)
parse_cmd_with_quoted_and_space(void **state)
{
char* inp = "/cmd \"the arg1\" arg2";
char *inp = "/cmd \"the arg1\" arg2";
gboolean result = FALSE;
gchar** args = parse_args(inp, 2, 2, &result);
gchar **args = parse_args(inp, 2, 2, &result);
assert_true(result);
assert_int_equal(2, g_strv_length(args));
@@ -244,11 +244,11 @@ parse_cmd_with_quoted_and_space(void** state)
}
void
parse_cmd_with_quoted_and_many_spaces(void** state)
parse_cmd_with_quoted_and_many_spaces(void **state)
{
char* inp = "/cmd \"the arg1 is here\" arg2";
char *inp = "/cmd \"the arg1 is here\" arg2";
gboolean result = FALSE;
gchar** args = parse_args(inp, 2, 2, &result);
gchar **args = parse_args(inp, 2, 2, &result);
assert_true(result);
assert_int_equal(2, g_strv_length(args));
@@ -258,11 +258,11 @@ parse_cmd_with_quoted_and_many_spaces(void** state)
}
void
parse_cmd_with_many_quoted_and_many_spaces(void** state)
parse_cmd_with_many_quoted_and_many_spaces(void **state)
{
char* inp = "/cmd \"the arg1 is here\" \"and arg2 is right here\"";
char *inp = "/cmd \"the arg1 is here\" \"and arg2 is right here\"";
gboolean result = FALSE;
gchar** args = parse_args(inp, 2, 2, &result);
gchar **args = parse_args(inp, 2, 2, &result);
assert_true(result);
assert_int_equal(2, g_strv_length(args));
@@ -272,11 +272,11 @@ parse_cmd_with_many_quoted_and_many_spaces(void** state)
}
void
parse_cmd_freetext_with_quoted(void** state)
parse_cmd_freetext_with_quoted(void **state)
{
char* inp = "/cmd \"arg1\" arg2 hello there whats up";
char *inp = "/cmd \"arg1\" arg2 hello there whats up";
gboolean result = FALSE;
gchar** args = parse_args_with_freetext(inp, 3, 3, &result);
gchar **args = parse_args_with_freetext(inp, 3, 3, &result);
assert_true(result);
assert_int_equal(3, g_strv_length(args));
@@ -287,11 +287,11 @@ parse_cmd_freetext_with_quoted(void** state)
}
void
parse_cmd_freetext_with_quoted_and_space(void** state)
parse_cmd_freetext_with_quoted_and_space(void **state)
{
char* inp = "/cmd \"the arg1\" arg2 another bit of freetext";
char *inp = "/cmd \"the arg1\" arg2 another bit of freetext";
gboolean result = FALSE;
gchar** args = parse_args_with_freetext(inp, 3, 3, &result);
gchar **args = parse_args_with_freetext(inp, 3, 3, &result);
assert_true(result);
assert_int_equal(3, g_strv_length(args));
@@ -302,11 +302,11 @@ parse_cmd_freetext_with_quoted_and_space(void** state)
}
void
parse_cmd_freetext_with_quoted_and_many_spaces(void** state)
parse_cmd_freetext_with_quoted_and_many_spaces(void **state)
{
char* inp = "/cmd \"the arg1 is here\" arg2 some more freetext";
char *inp = "/cmd \"the arg1 is here\" arg2 some more freetext";
gboolean result = FALSE;
gchar** args = parse_args_with_freetext(inp, 3, 3, &result);
gchar **args = parse_args_with_freetext(inp, 3, 3, &result);
assert_true(result);
assert_int_equal(3, g_strv_length(args));
@@ -317,11 +317,11 @@ parse_cmd_freetext_with_quoted_and_many_spaces(void** state)
}
void
parse_cmd_freetext_with_many_quoted_and_many_spaces(void** state)
parse_cmd_freetext_with_many_quoted_and_many_spaces(void **state)
{
char* inp = "/cmd \"the arg1 is here\" \"and arg2 is right here\" and heres the free text";
char *inp = "/cmd \"the arg1 is here\" \"and arg2 is right here\" and heres the free text";
gboolean result = FALSE;
gchar** args = parse_args_with_freetext(inp, 3, 3, &result);
gchar **args = parse_args_with_freetext(inp, 3, 3, &result);
assert_true(result);
assert_int_equal(3, g_strv_length(args));
@@ -332,11 +332,11 @@ parse_cmd_freetext_with_many_quoted_and_many_spaces(void** state)
}
void
parse_cmd_with_quoted_freetext(void** state)
parse_cmd_with_quoted_freetext(void **state)
{
char* inp = "/cmd arg1 here is \"some\" quoted freetext";
char *inp = "/cmd arg1 here is \"some\" quoted freetext";
gboolean result = FALSE;
gchar** args = parse_args_with_freetext(inp, 1, 2, &result);
gchar **args = parse_args_with_freetext(inp, 1, 2, &result);
assert_true(result);
assert_int_equal(2, g_strv_length(args));
@@ -346,11 +346,11 @@ parse_cmd_with_quoted_freetext(void** state)
}
void
parse_cmd_with_third_arg_quoted_0_min_3_max(void** state)
parse_cmd_with_third_arg_quoted_0_min_3_max(void **state)
{
char* inp = "/group add friends \"The User\"";
char *inp = "/group add friends \"The User\"";
gboolean result = FALSE;
gchar** args = parse_args_with_freetext(inp, 0, 3, &result);
gchar **args = parse_args_with_freetext(inp, 0, 3, &result);
assert_true(result);
assert_int_equal(3, g_strv_length(args));
@@ -362,11 +362,11 @@ parse_cmd_with_third_arg_quoted_0_min_3_max(void** state)
}
void
parse_cmd_with_second_arg_quoted_0_min_3_max(void** state)
parse_cmd_with_second_arg_quoted_0_min_3_max(void **state)
{
char* inp = "/group add \"The Group\" friend";
char *inp = "/group add \"The Group\" friend";
gboolean result = FALSE;
gchar** args = parse_args_with_freetext(inp, 0, 3, &result);
gchar **args = parse_args_with_freetext(inp, 0, 3, &result);
assert_true(result);
assert_int_equal(3, g_strv_length(args));
@@ -378,11 +378,11 @@ parse_cmd_with_second_arg_quoted_0_min_3_max(void** state)
}
void
parse_cmd_with_second_and_third_arg_quoted_0_min_3_max(void** state)
parse_cmd_with_second_and_third_arg_quoted_0_min_3_max(void **state)
{
char* inp = "/group add \"The Group\" \"The User\"";
char *inp = "/group add \"The Group\" \"The User\"";
gboolean result = FALSE;
gchar** args = parse_args_with_freetext(inp, 0, 3, &result);
gchar **args = parse_args_with_freetext(inp, 0, 3, &result);
assert_true(result);
assert_int_equal(3, g_strv_length(args));
@@ -394,137 +394,137 @@ parse_cmd_with_second_and_third_arg_quoted_0_min_3_max(void** state)
}
void
count_one_token(void** state)
count_one_token(void **state)
{
char* inp = "one";
char *inp = "one";
int result = count_tokens(inp);
assert_int_equal(1, result);
}
void
count_one_token_quoted_no_whitespace(void** state)
count_one_token_quoted_no_whitespace(void **state)
{
char* inp = "\"one\"";
char *inp = "\"one\"";
int result = count_tokens(inp);
assert_int_equal(1, result);
}
void
count_one_token_quoted_with_whitespace(void** state)
count_one_token_quoted_with_whitespace(void **state)
{
char* inp = "\"one two\"";
char *inp = "\"one two\"";
int result = count_tokens(inp);
assert_int_equal(1, result);
}
void
count_two_tokens(void** state)
count_two_tokens(void **state)
{
char* inp = "one two";
char *inp = "one two";
int result = count_tokens(inp);
assert_int_equal(2, result);
}
void
count_two_tokens_first_quoted(void** state)
count_two_tokens_first_quoted(void **state)
{
char* inp = "\"one and\" two";
char *inp = "\"one and\" two";
int result = count_tokens(inp);
assert_int_equal(2, result);
}
void
count_two_tokens_second_quoted(void** state)
count_two_tokens_second_quoted(void **state)
{
char* inp = "one \"two and\"";
char *inp = "one \"two and\"";
int result = count_tokens(inp);
assert_int_equal(2, result);
}
void
count_two_tokens_both_quoted(void** state)
count_two_tokens_both_quoted(void **state)
{
char* inp = "\"one and then\" \"two and\"";
char *inp = "\"one and then\" \"two and\"";
int result = count_tokens(inp);
assert_int_equal(2, result);
}
void
get_first_of_one(void** state)
get_first_of_one(void **state)
{
char* inp = "one";
char* result = get_start(inp, 2);
char *inp = "one";
char *result = get_start(inp, 2);
assert_string_equal("one", result);
free(result);
}
void
get_first_of_two(void** state)
get_first_of_two(void **state)
{
char* inp = "one two";
char* result = get_start(inp, 2);
char *inp = "one two";
char *result = get_start(inp, 2);
assert_string_equal("one ", result);
free(result);
}
void
get_first_two_of_three(void** state)
get_first_two_of_three(void **state)
{
char* inp = "one two three";
char* result = get_start(inp, 3);
char *inp = "one two three";
char *result = get_start(inp, 3);
assert_string_equal("one two ", result);
free(result);
}
void
get_first_two_of_three_first_quoted(void** state)
get_first_two_of_three_first_quoted(void **state)
{
char* inp = "\"one\" two three";
char* result = get_start(inp, 3);
char *inp = "\"one\" two three";
char *result = get_start(inp, 3);
assert_string_equal("\"one\" two ", result);
free(result);
}
void
get_first_two_of_three_second_quoted(void** state)
get_first_two_of_three_second_quoted(void **state)
{
char* inp = "one \"two\" three";
char* result = get_start(inp, 3);
char *inp = "one \"two\" three";
char *result = get_start(inp, 3);
assert_string_equal("one \"two\" ", result);
free(result);
}
void
get_first_two_of_three_first_and_second_quoted(void** state)
get_first_two_of_three_first_and_second_quoted(void **state)
{
char* inp = "\"one\" \"two\" three";
char* result = get_start(inp, 3);
char *inp = "\"one\" \"two\" three";
char *result = get_start(inp, 3);
assert_string_equal("\"one\" \"two\" ", result);
free(result);
}
void
parse_options_when_none_returns_empty_hasmap(void** state)
parse_options_when_none_returns_empty_hasmap(void **state)
{
gchar* args[] = { "cmd1", "cmd2", NULL };
gchar* keys[] = { "opt1", NULL };
gchar *args[] = { "cmd1", "cmd2", NULL };
gchar *keys[] = { "opt1", NULL };
gboolean res = FALSE;
GHashTable* options = parse_options(&args[2], keys, &res);
GHashTable *options = parse_options(&args[2], keys, &res);
assert_true(options != NULL);
assert_int_equal(0, g_hash_table_size(options));
@@ -534,14 +534,14 @@ parse_options_when_none_returns_empty_hasmap(void** state)
}
void
parse_options_when_opt1_no_val_sets_error(void** state)
parse_options_when_opt1_no_val_sets_error(void **state)
{
gchar* args[] = { "cmd1", "cmd2", "opt1", NULL };
gchar* keys[] = { "opt1", NULL };
gchar *args[] = { "cmd1", "cmd2", "opt1", NULL };
gchar *keys[] = { "opt1", NULL };
gboolean res = TRUE;
GHashTable* options = parse_options(&args[2], keys, &res);
GHashTable *options = parse_options(&args[2], keys, &res);
assert_null(options);
assert_false(res);
@@ -550,14 +550,14 @@ parse_options_when_opt1_no_val_sets_error(void** state)
}
void
parse_options_when_one_returns_map(void** state)
parse_options_when_one_returns_map(void **state)
{
gchar* args[] = { "cmd1", "cmd2", "opt1", "val1", NULL };
gchar* keys[] = { "opt1", NULL };
gchar *args[] = { "cmd1", "cmd2", "opt1", "val1", NULL };
gchar *keys[] = { "opt1", NULL };
gboolean res = FALSE;
GHashTable* options = parse_options(&args[2], keys, &res);
GHashTable *options = parse_options(&args[2], keys, &res);
assert_int_equal(1, g_hash_table_size(options));
assert_true(g_hash_table_contains(options, "opt1"));
@@ -568,14 +568,14 @@ parse_options_when_one_returns_map(void** state)
}
void
parse_options_when_opt2_no_val_sets_error(void** state)
parse_options_when_opt2_no_val_sets_error(void **state)
{
gchar* args[] = { "cmd1", "cmd2", "opt1", "val1", "opt2", NULL };
gchar* keys[] = { "opt1", "opt2", NULL };
gchar *args[] = { "cmd1", "cmd2", "opt1", "val1", "opt2", NULL };
gchar *keys[] = { "opt1", "opt2", NULL };
gboolean res = TRUE;
GHashTable* options = parse_options(&args[2], keys, &res);
GHashTable *options = parse_options(&args[2], keys, &res);
assert_null(options);
assert_false(res);
@@ -584,14 +584,14 @@ parse_options_when_opt2_no_val_sets_error(void** state)
}
void
parse_options_when_two_returns_map(void** state)
parse_options_when_two_returns_map(void **state)
{
gchar* args[] = { "cmd1", "cmd2", "opt1", "val1", "opt2", "val2", NULL };
gchar* keys[] = { "opt1", "opt2", NULL };
gchar *args[] = { "cmd1", "cmd2", "opt1", "val1", "opt2", "val2", NULL };
gchar *keys[] = { "opt1", "opt2", NULL };
gboolean res = FALSE;
GHashTable* options = parse_options(&args[2], keys, &res);
GHashTable *options = parse_options(&args[2], keys, &res);
assert_int_equal(2, g_hash_table_size(options));
assert_true(g_hash_table_contains(options, "opt1"));
@@ -604,14 +604,14 @@ parse_options_when_two_returns_map(void** state)
}
void
parse_options_when_opt3_no_val_sets_error(void** state)
parse_options_when_opt3_no_val_sets_error(void **state)
{
gchar* args[] = { "cmd1", "cmd2", "opt1", "val1", "opt2", "val2", "opt3", NULL };
gchar* keys[] = { "opt1", "opt2", "opt3", NULL };
gchar *args[] = { "cmd1", "cmd2", "opt1", "val1", "opt2", "val2", "opt3", NULL };
gchar *keys[] = { "opt1", "opt2", "opt3", NULL };
gboolean res = TRUE;
GHashTable* options = parse_options(&args[2], keys, &res);
GHashTable *options = parse_options(&args[2], keys, &res);
assert_null(options);
assert_false(res);
@@ -620,14 +620,14 @@ parse_options_when_opt3_no_val_sets_error(void** state)
}
void
parse_options_when_three_returns_map(void** state)
parse_options_when_three_returns_map(void **state)
{
gchar* args[] = { "cmd1", "cmd2", "opt1", "val1", "opt2", "val2", "opt3", "val3", NULL };
gchar* keys[] = { "opt1", "opt2", "opt3", NULL };
gchar *args[] = { "cmd1", "cmd2", "opt1", "val1", "opt2", "val2", "opt3", "val3", NULL };
gchar *keys[] = { "opt1", "opt2", "opt3", NULL };
gboolean res = FALSE;
GHashTable* options = parse_options(&args[2], keys, &res);
GHashTable *options = parse_options(&args[2], keys, &res);
assert_int_equal(3, g_hash_table_size(options));
assert_true(g_hash_table_contains(options, "opt1"));
@@ -642,14 +642,14 @@ parse_options_when_three_returns_map(void** state)
}
void
parse_options_when_unknown_opt_sets_error(void** state)
parse_options_when_unknown_opt_sets_error(void **state)
{
gchar* args[] = { "cmd1", "cmd2", "opt1", "val1", "oops", "val2", "opt3", "val3", NULL };
gchar* keys[] = { "opt1", "opt2", "opt3", NULL };
gchar *args[] = { "cmd1", "cmd2", "opt1", "val1", "oops", "val2", "opt3", "val3", NULL };
gchar *keys[] = { "opt1", "opt2", "opt3", NULL };
gboolean res = TRUE;
GHashTable* options = parse_options(&args[2], keys, &res);
GHashTable *options = parse_options(&args[2], keys, &res);
assert_null(options);
assert_false(res);
@@ -658,14 +658,14 @@ parse_options_when_unknown_opt_sets_error(void** state)
}
void
parse_options_with_duplicated_option_sets_error(void** state)
parse_options_with_duplicated_option_sets_error(void **state)
{
gchar* args[] = { "cmd1", "cmd2", "opt1", "val1", "opt2", "val2", "opt1", "val3", NULL };
gchar* keys[] = { "opt1", "opt2", "opt3", NULL };
gchar *args[] = { "cmd1", "cmd2", "opt1", "val1", "opt2", "val2", "opt1", "val3", NULL };
gchar *keys[] = { "opt1", "opt2", "opt3", NULL };
gboolean res = TRUE;
GHashTable* options = parse_options(&args[2], keys, &res);
GHashTable *options = parse_options(&args[2], keys, &res);
assert_null(options);
assert_false(res);

100
tests/unittests/test_parser.h
View File

@@ -1,50 +1,50 @@
void parse_null_returns_null(void** state);
void parse_empty_returns_null(void** state);
void parse_space_returns_null(void** state);
void parse_cmd_no_args_returns_null(void** state);
void parse_cmd_with_space_returns_null(void** state);
void parse_cmd_with_too_few_returns_null(void** state);
void parse_cmd_with_too_many_returns_null(void** state);
void parse_cmd_one_arg(void** state);
void parse_cmd_two_args(void** state);
void parse_cmd_three_args(void** state);
void parse_cmd_three_args_with_spaces(void** state);
void parse_cmd_with_freetext(void** state);
void parse_cmd_one_arg_with_freetext(void** state);
void parse_cmd_two_args_with_freetext(void** state);
void parse_cmd_min_zero(void** state);
void parse_cmd_min_zero_with_freetext(void** state);
void parse_cmd_with_quoted(void** state);
void parse_cmd_with_quoted_and_space(void** state);
void parse_cmd_with_quoted_and_many_spaces(void** state);
void parse_cmd_with_many_quoted_and_many_spaces(void** state);
void parse_cmd_freetext_with_quoted(void** state);
void parse_cmd_freetext_with_quoted_and_space(void** state);
void parse_cmd_freetext_with_quoted_and_many_spaces(void** state);
void parse_cmd_freetext_with_many_quoted_and_many_spaces(void** state);
void parse_cmd_with_quoted_freetext(void** state);
void parse_cmd_with_third_arg_quoted_0_min_3_max(void** state);
void parse_cmd_with_second_arg_quoted_0_min_3_max(void** state);
void parse_cmd_with_second_and_third_arg_quoted_0_min_3_max(void** state);
void count_one_token(void** state);
void count_one_token_quoted_no_whitespace(void** state);
void count_one_token_quoted_with_whitespace(void** state);
void count_two_tokens(void** state);
void count_two_tokens_first_quoted(void** state);
void count_two_tokens_second_quoted(void** state);
void count_two_tokens_both_quoted(void** state);
void get_first_of_one(void** state);
void get_first_of_two(void** state);
void get_first_two_of_three(void** state);
void get_first_two_of_three_first_quoted(void** state);
void get_first_two_of_three_second_quoted(void** state);
void get_first_two_of_three_first_and_second_quoted(void** state);
void parse_options_when_none_returns_empty_hasmap(void** state);
void parse_options_when_opt1_no_val_sets_error(void** state);
void parse_options_when_one_returns_map(void** state);
void parse_options_when_opt2_no_val_sets_error(void** state);
void parse_options_when_two_returns_map(void** state);
void parse_options_when_opt3_no_val_sets_error(void** state);
void parse_options_when_three_returns_map(void** state);
void parse_options_when_unknown_opt_sets_error(void** state);
void parse_options_with_duplicated_option_sets_error(void** state);
void parse_null_returns_null(void **state);
void parse_empty_returns_null(void **state);
void parse_space_returns_null(void **state);
void parse_cmd_no_args_returns_null(void **state);
void parse_cmd_with_space_returns_null(void **state);
void parse_cmd_with_too_few_returns_null(void **state);
void parse_cmd_with_too_many_returns_null(void **state);
void parse_cmd_one_arg(void **state);
void parse_cmd_two_args(void **state);
void parse_cmd_three_args(void **state);
void parse_cmd_three_args_with_spaces(void **state);
void parse_cmd_with_freetext(void **state);
void parse_cmd_one_arg_with_freetext(void **state);
void parse_cmd_two_args_with_freetext(void **state);
void parse_cmd_min_zero(void **state);
void parse_cmd_min_zero_with_freetext(void **state);
void parse_cmd_with_quoted(void **state);
void parse_cmd_with_quoted_and_space(void **state);
void parse_cmd_with_quoted_and_many_spaces(void **state);
void parse_cmd_with_many_quoted_and_many_spaces(void **state);
void parse_cmd_freetext_with_quoted(void **state);
void parse_cmd_freetext_with_quoted_and_space(void **state);
void parse_cmd_freetext_with_quoted_and_many_spaces(void **state);
void parse_cmd_freetext_with_many_quoted_and_many_spaces(void **state);
void parse_cmd_with_quoted_freetext(void **state);
void parse_cmd_with_third_arg_quoted_0_min_3_max(void **state);
void parse_cmd_with_second_arg_quoted_0_min_3_max(void **state);
void parse_cmd_with_second_and_third_arg_quoted_0_min_3_max(void **state);
void count_one_token(void **state);
void count_one_token_quoted_no_whitespace(void **state);
void count_one_token_quoted_with_whitespace(void **state);
void count_two_tokens(void **state);
void count_two_tokens_first_quoted(void **state);
void count_two_tokens_second_quoted(void **state);
void count_two_tokens_both_quoted(void **state);
void get_first_of_one(void **state);
void get_first_of_two(void **state);
void get_first_two_of_three(void **state);
void get_first_two_of_three_first_quoted(void **state);
void get_first_two_of_three_second_quoted(void **state);
void get_first_two_of_three_first_and_second_quoted(void **state);
void parse_options_when_none_returns_empty_hasmap(void **state);
void parse_options_when_opt1_no_val_sets_error(void **state);
void parse_options_when_one_returns_map(void **state);
void parse_options_when_opt2_no_val_sets_error(void **state);
void parse_options_when_two_returns_map(void **state);
void parse_options_when_opt3_no_val_sets_error(void **state);
void parse_options_when_three_returns_map(void **state);
void parse_options_when_unknown_opt_sets_error(void **state);
void parse_options_with_duplicated_option_sets_error(void **state);

34
tests/unittests/test_plugins_disco.c
View File

@@ -1,16 +1,16 @@
#include <cmocka.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include "plugins/disco.h"
void
returns_empty_list_when_none(void** state)
returns_empty_list_when_none(void **state)
{
disco_close();
GList* features = disco_get_features();
GList *features = disco_get_features();
assert_int_equal(g_list_length(features), 0);
@@ -19,14 +19,14 @@ returns_empty_list_when_none(void** state)
}
void
returns_added_feature(void** state)
returns_added_feature(void **state)
{
disco_close();
disco_add_feature("my_plugin", "some:feature:example");
GList* features = disco_get_features();
GList *features = disco_get_features();
assert_int_equal(g_list_length(features), 1);
char* feature = features->data;
char *feature = features->data;
assert_string_equal(feature, "some:feature:example");
g_list_free(features);
@@ -34,12 +34,12 @@ returns_added_feature(void** state)
}
void
resets_features_on_close(void** state)
resets_features_on_close(void **state)
{
disco_close();
disco_add_feature("my_plugin", "some:feature:example");
GList* features = disco_get_features();
GList *features = disco_get_features();
assert_int_equal(g_list_length(features), 1);
g_list_free(features);
@@ -52,7 +52,7 @@ resets_features_on_close(void** state)
}
void
returns_all_added_features(void** state)
returns_all_added_features(void **state)
{
disco_close();
disco_add_feature("first_plugin", "first:feature");
@@ -61,7 +61,7 @@ returns_all_added_features(void** state)
disco_add_feature("third_plugin", "fourth:feature");
disco_add_feature("third_plugin", "fifth:feature");
GList* features = disco_get_features();
GList *features = disco_get_features();
assert_int_equal(g_list_length(features), 5);
assert_true(g_list_find_custom(features, "first:feature", (GCompareFunc)g_strcmp0));
@@ -75,13 +75,13 @@ returns_all_added_features(void** state)
}
void
does_not_add_duplicate_feature(void** state)
does_not_add_duplicate_feature(void **state)
{
disco_close();
disco_add_feature("my_plugin", "my:feature");
disco_add_feature("some_other_plugin", "my:feature");
GList* features = disco_get_features();
GList *features = disco_get_features();
assert_int_equal(g_list_length(features), 1);
g_list_free(features);
@@ -89,14 +89,14 @@ does_not_add_duplicate_feature(void** state)
}
void
removes_plugin_features(void** state)
removes_plugin_features(void **state)
{
disco_close();
disco_add_feature("plugin1", "plugin1:feature1");
disco_add_feature("plugin1", "plugin1:feature2");
disco_add_feature("plugin2", "plugin2:feature1");
GList* features = disco_get_features();
GList *features = disco_get_features();
assert_int_equal(g_list_length(features), 3);
g_list_free(features);
@@ -110,14 +110,14 @@ removes_plugin_features(void** state)
}
void
does_not_remove_feature_when_more_than_one_reference(void** state)
does_not_remove_feature_when_more_than_one_reference(void **state)
{
disco_close();
disco_add_feature("plugin1", "feature1");
disco_add_feature("plugin1", "feature2");
disco_add_feature("plugin2", "feature1");
GList* features = disco_get_features();
GList *features = disco_get_features();
assert_int_equal(g_list_length(features), 2);
g_list_free(features);

14
tests/unittests/test_plugins_disco.h
View File

@@ -1,7 +1,7 @@
void returns_empty_list_when_none(void** state);
void returns_added_feature(void** state);
void resets_features_on_close(void** state);
void returns_all_added_features(void** state);
void does_not_add_duplicate_feature(void** state);
void removes_plugin_features(void** state);
void does_not_remove_feature_when_more_than_one_reference(void** state);
void returns_empty_list_when_none(void **state);
void returns_added_feature(void **state);
void resets_features_on_close(void **state);
void returns_all_added_features(void **state);
void does_not_add_duplicate_feature(void **state);
void removes_plugin_features(void **state);
void does_not_remove_feature_when_more_than_one_reference(void **state);

21
tests/unittests/test_preferences.c
View File

@@ -1,37 +1,34 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "config/preferences.h"
void
statuses_console_defaults_to_all(void** state)
void statuses_console_defaults_to_all(void **state)
{
char* setting = prefs_get_string(PREF_STATUSES_CONSOLE);
char *setting = prefs_get_string(PREF_STATUSES_CONSOLE);
assert_non_null(setting);
assert_string_equal("all", setting);
g_free(setting);
}
void
statuses_chat_defaults_to_all(void** state)
void statuses_chat_defaults_to_all(void **state)
{
char* setting = prefs_get_string(PREF_STATUSES_CHAT);
char *setting = prefs_get_string(PREF_STATUSES_CHAT);
assert_non_null(setting);
assert_string_equal("all", setting);
g_free(setting);
}
void
statuses_muc_defaults_to_all(void** state)
void statuses_muc_defaults_to_all(void **state)
{
char* setting = prefs_get_string(PREF_STATUSES_MUC);
char *setting = prefs_get_string(PREF_STATUSES_MUC);
assert_non_null(setting);
assert_string_equal("all", setting);

6
tests/unittests/test_preferences.h
View File

@@ -1,3 +1,3 @@
void statuses_console_defaults_to_all(void** state);
void statuses_chat_defaults_to_all(void** state);
void statuses_muc_defaults_to_all(void** state);
void statuses_console_defaults_to_all(void **state);
void statuses_chat_defaults_to_all(void **state);
void statuses_muc_defaults_to_all(void **state);

246
tests/unittests/test_roster_list.c
View File

@@ -1,43 +1,40 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include "xmpp/contact.h"
#include "xmpp/roster_list.h"
void
empty_list_when_none_added(void** state)
void empty_list_when_none_added(void **state)
{
roster_create();
GSList* list = roster_get_contacts(ROSTER_ORD_NAME);
GSList *list = roster_get_contacts(ROSTER_ORD_NAME);
assert_null(list);
g_slist_free(list);
roster_destroy();
}
void
contains_one_element(void** state)
void contains_one_element(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
GSList* list = roster_get_contacts(ROSTER_ORD_NAME);
GSList *list = roster_get_contacts(ROSTER_ORD_NAME);
assert_int_equal(1, g_slist_length(list));
g_slist_free(list);
roster_destroy();
}
void
first_element_correct(void** state)
void first_element_correct(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
GSList* list = roster_get_contacts(ROSTER_ORD_NAME);
GSList *list = roster_get_contacts(ROSTER_ORD_NAME);
PContact james = list->data;
assert_string_equal("James", p_contact_barejid(james));
@@ -46,13 +43,12 @@ first_element_correct(void** state)
roster_destroy();
}
void
contains_two_elements(void** state)
void contains_two_elements(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Dave", NULL, NULL, NULL, FALSE);
GSList* list = roster_get_contacts(ROSTER_ORD_NAME);
GSList *list = roster_get_contacts(ROSTER_ORD_NAME);
assert_int_equal(2, g_slist_length(list));
@@ -60,13 +56,12 @@ contains_two_elements(void** state)
roster_destroy();
}
void
first_and_second_elements_correct(void** state)
void first_and_second_elements_correct(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Dave", NULL, NULL, NULL, FALSE);
GSList* list = roster_get_contacts(ROSTER_ORD_NAME);
GSList *list = roster_get_contacts(ROSTER_ORD_NAME);
PContact first = list->data;
PContact second = (g_slist_next(list))->data;
@@ -78,14 +73,13 @@ first_and_second_elements_correct(void** state)
roster_destroy();
}
void
contains_three_elements(void** state)
void contains_three_elements(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Bob", NULL, NULL, NULL, FALSE);
roster_add("Dave", NULL, NULL, NULL, FALSE);
GSList* list = roster_get_contacts(ROSTER_ORD_NAME);
GSList *list = roster_get_contacts(ROSTER_ORD_NAME);
assert_int_equal(3, g_slist_length(list));
@@ -93,14 +87,13 @@ contains_three_elements(void** state)
roster_destroy();
}
void
first_three_elements_correct(void** state)
void first_three_elements_correct(void **state)
{
roster_create();
roster_add("Bob", NULL, NULL, NULL, FALSE);
roster_add("Dave", NULL, NULL, NULL, FALSE);
roster_add("James", NULL, NULL, NULL, FALSE);
GSList* list = roster_get_contacts(ROSTER_ORD_NAME);
GSList *list = roster_get_contacts(ROSTER_ORD_NAME);
PContact bob = list->data;
PContact dave = (g_slist_next(list))->data;
PContact james = (g_slist_next(g_slist_next(list)))->data;
@@ -113,15 +106,14 @@ first_three_elements_correct(void** state)
roster_destroy();
}
void
add_twice_at_beginning_adds_once(void** state)
void add_twice_at_beginning_adds_once(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Dave", NULL, NULL, NULL, FALSE);
roster_add("Bob", NULL, NULL, NULL, FALSE);
GSList* list = roster_get_contacts(ROSTER_ORD_NAME);
GSList *list = roster_get_contacts(ROSTER_ORD_NAME);
PContact first = list->data;
PContact second = (g_slist_next(list))->data;
PContact third = (g_slist_next(g_slist_next(list)))->data;
@@ -135,15 +127,14 @@ add_twice_at_beginning_adds_once(void** state)
roster_destroy();
}
void
add_twice_in_middle_adds_once(void** state)
void add_twice_in_middle_adds_once(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Dave", NULL, NULL, NULL, FALSE);
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Bob", NULL, NULL, NULL, FALSE);
GSList* list = roster_get_contacts(ROSTER_ORD_NAME);
GSList *list = roster_get_contacts(ROSTER_ORD_NAME);
PContact first = list->data;
PContact second = (g_slist_next(list))->data;
PContact third = (g_slist_next(g_slist_next(list)))->data;
@@ -157,15 +148,14 @@ add_twice_in_middle_adds_once(void** state)
roster_destroy();
}
void
add_twice_at_end_adds_once(void** state)
void add_twice_at_end_adds_once(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Dave", NULL, NULL, NULL, FALSE);
roster_add("Bob", NULL, NULL, NULL, FALSE);
roster_add("James", NULL, NULL, NULL, FALSE);
GSList* list = roster_get_contacts(ROSTER_ORD_NAME);
GSList *list = roster_get_contacts(ROSTER_ORD_NAME);
PContact first = list->data;
PContact second = (g_slist_next(list))->data;
PContact third = (g_slist_next(g_slist_next(list)))->data;
@@ -179,91 +169,84 @@ add_twice_at_end_adds_once(void** state)
roster_destroy();
}
void
find_first_exists(void** state)
void find_first_exists(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Dave", NULL, NULL, NULL, FALSE);
roster_add("Bob", NULL, NULL, NULL, FALSE);
char* search = strdup("B");
char *search = strdup("B");
char* result = roster_contact_autocomplete(search, FALSE, NULL);
char *result = roster_contact_autocomplete(search, FALSE, NULL);
assert_string_equal("Bob", result);
free(result);
free(search);
roster_destroy();
}
void
find_second_exists(void** state)
void find_second_exists(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Dave", NULL, NULL, NULL, FALSE);
roster_add("Bob", NULL, NULL, NULL, FALSE);
char* result = roster_contact_autocomplete("Dav", FALSE, NULL);
char *result = roster_contact_autocomplete("Dav", FALSE, NULL);
assert_string_equal("Dave", result);
free(result);
roster_destroy();
}
void
find_third_exists(void** state)
void find_third_exists(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Dave", NULL, NULL, NULL, FALSE);
roster_add("Bob", NULL, NULL, NULL, FALSE);
char* result = roster_contact_autocomplete("Ja", FALSE, NULL);
char *result = roster_contact_autocomplete("Ja", FALSE, NULL);
assert_string_equal("James", result);
free(result);
roster_destroy();
}
void
find_returns_null(void** state)
void find_returns_null(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Dave", NULL, NULL, NULL, FALSE);
roster_add("Bob", NULL, NULL, NULL, FALSE);
char* result = roster_contact_autocomplete("Mike", FALSE, NULL);
char *result = roster_contact_autocomplete("Mike", FALSE, NULL);
assert_null(result);
roster_destroy();
}
void
find_on_empty_returns_null(void** state)
void find_on_empty_returns_null(void **state)
{
roster_create();
char* result = roster_contact_autocomplete("James", FALSE, NULL);
char *result = roster_contact_autocomplete("James", FALSE, NULL);
assert_null(result);
roster_destroy();
}
void
find_twice_returns_second_when_two_match(void** state)
void find_twice_returns_second_when_two_match(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Jamie", NULL, NULL, NULL, FALSE);
roster_add("Bob", NULL, NULL, NULL, FALSE);
char* result1 = roster_contact_autocomplete("Jam", FALSE, NULL);
char* result2 = roster_contact_autocomplete(result1, FALSE, NULL);
char *result1 = roster_contact_autocomplete("Jam", FALSE, NULL);
char *result2 = roster_contact_autocomplete(result1, FALSE, NULL);
assert_string_equal("Jamie", result2);
free(result1);
free(result2);
roster_destroy();
}
void
find_five_times_finds_fifth(void** state)
void find_five_times_finds_fifth(void **state)
{
roster_create();
roster_add("Jama", NULL, NULL, NULL, FALSE);
@@ -277,11 +260,11 @@ find_five_times_finds_fifth(void** state)
roster_add("Jamy", NULL, NULL, NULL, FALSE);
roster_add("Jamz", NULL, NULL, NULL, FALSE);
char* result1 = roster_contact_autocomplete("Jam", FALSE, NULL);
char* result2 = roster_contact_autocomplete(result1, FALSE, NULL);
char* result3 = roster_contact_autocomplete(result2, FALSE, NULL);
char* result4 = roster_contact_autocomplete(result3, FALSE, NULL);
char* result5 = roster_contact_autocomplete(result4, FALSE, NULL);
char *result1 = roster_contact_autocomplete("Jam", FALSE, NULL);
char *result2 = roster_contact_autocomplete(result1, FALSE, NULL);
char *result3 = roster_contact_autocomplete(result2, FALSE, NULL);
char *result4 = roster_contact_autocomplete(result3, FALSE, NULL);
char *result5 = roster_contact_autocomplete(result4, FALSE, NULL);
assert_string_equal("Jamo", result5);
free(result1);
free(result2);
@@ -291,49 +274,46 @@ find_five_times_finds_fifth(void** state)
roster_destroy();
}
void
find_twice_returns_first_when_two_match_and_reset(void** state)
void find_twice_returns_first_when_two_match_and_reset(void **state)
{
roster_create();
roster_add("James", NULL, NULL, NULL, FALSE);
roster_add("Jamie", NULL, NULL, NULL, FALSE);
roster_add("Bob", NULL, NULL, NULL, FALSE);
char* result1 = roster_contact_autocomplete("Jam", FALSE, NULL);
char *result1 = roster_contact_autocomplete("Jam", FALSE, NULL);
roster_reset_search_attempts();
char* result2 = roster_contact_autocomplete(result1, FALSE, NULL);
char *result2 = roster_contact_autocomplete(result1, FALSE, NULL);
assert_string_equal("James", result2);
free(result1);
free(result2);
roster_destroy();
}
void
add_contact_with_no_group(void** state)
void add_contact_with_no_group(void **state)
{
roster_create();
roster_add("person@server.org", NULL, NULL, NULL, FALSE);
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 0);
g_list_free_full(groups_res, free);
roster_destroy();
}
void
add_contact_with_group(void** state)
void add_contact_with_group(void **state)
{
roster_create();
GSList* groups = NULL;
GSList *groups = NULL;
groups = g_slist_append(groups, strdup("friends"));
roster_add("person@server.org", NULL, groups, NULL, FALSE);
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 1);
GList* found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
GList *found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
assert_string_equal(found->data, "friends");
@@ -341,20 +321,19 @@ add_contact_with_group(void** state)
roster_destroy();
}
void
add_contact_with_two_groups(void** state)
void add_contact_with_two_groups(void **state)
{
roster_create();
GSList* groups = NULL;
GSList *groups = NULL;
groups = g_slist_append(groups, strdup("friends"));
groups = g_slist_append(groups, strdup("work"));
roster_add("person@server.org", NULL, groups, NULL, FALSE);
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 2);
GList* found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
GList *found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
assert_string_equal(found->data, "friends");
found = g_list_find_custom(groups_res, "work", (GCompareFunc)g_strcmp0);
@@ -365,21 +344,20 @@ add_contact_with_two_groups(void** state)
roster_destroy();
}
void
add_contact_with_three_groups(void** state)
void add_contact_with_three_groups(void **state)
{
roster_create();
GSList* groups = NULL;
GSList *groups = NULL;
groups = g_slist_append(groups, strdup("friends"));
groups = g_slist_append(groups, strdup("work"));
groups = g_slist_append(groups, strdup("stuff"));
roster_add("person@server.org", NULL, groups, NULL, FALSE);
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 3);
GList* found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
GList *found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
assert_string_equal(found->data, "friends");
found = g_list_find_custom(groups_res, "work", (GCompareFunc)g_strcmp0);
@@ -393,18 +371,17 @@ add_contact_with_three_groups(void** state)
roster_destroy();
}
void
add_contact_with_three_groups_update_adding_two(void** state)
void add_contact_with_three_groups_update_adding_two(void **state)
{
roster_create();
GSList* groups1 = NULL;
GSList *groups1 = NULL;
groups1 = g_slist_append(groups1, strdup("friends"));
groups1 = g_slist_append(groups1, strdup("work"));
groups1 = g_slist_append(groups1, strdup("stuff"));
roster_add("person@server.org", NULL, groups1, NULL, FALSE);
GSList* groups2 = NULL;
GSList *groups2 = NULL;
groups2 = g_slist_append(groups2, strdup("friends"));
groups2 = g_slist_append(groups2, strdup("work"));
groups2 = g_slist_append(groups2, strdup("stuff"));
@@ -412,10 +389,10 @@ add_contact_with_three_groups_update_adding_two(void** state)
groups2 = g_slist_append(groups2, strdup("people"));
roster_update("person@server.org", NULL, groups2, NULL, FALSE);
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 5);
GList* found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
GList *found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
assert_string_equal(found->data, "friends");
found = g_list_find_custom(groups_res, "work", (GCompareFunc)g_strcmp0);
@@ -435,26 +412,25 @@ add_contact_with_three_groups_update_adding_two(void** state)
roster_destroy();
}
void
add_contact_with_three_groups_update_removing_one(void** state)
void add_contact_with_three_groups_update_removing_one(void **state)
{
roster_create();
GSList* groups1 = NULL;
GSList *groups1 = NULL;
groups1 = g_slist_append(groups1, strdup("friends"));
groups1 = g_slist_append(groups1, strdup("work"));
groups1 = g_slist_append(groups1, strdup("stuff"));
roster_add("person@server.org", NULL, groups1, NULL, FALSE);
GSList* groups2 = NULL;
GSList *groups2 = NULL;
groups2 = g_slist_append(groups2, strdup("friends"));
groups2 = g_slist_append(groups2, strdup("stuff"));
roster_update("person@server.org", NULL, groups2, NULL, FALSE);
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 2);
GList* found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
GList *found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
assert_string_equal(found->data, "friends");
found = g_list_find_custom(groups_res, "stuff", (GCompareFunc)g_strcmp0);
@@ -465,25 +441,24 @@ add_contact_with_three_groups_update_removing_one(void** state)
roster_destroy();
}
void
add_contact_with_three_groups_update_removing_two(void** state)
void add_contact_with_three_groups_update_removing_two(void **state)
{
roster_create();
GSList* groups1 = NULL;
GSList *groups1 = NULL;
groups1 = g_slist_append(groups1, strdup("friends"));
groups1 = g_slist_append(groups1, strdup("work"));
groups1 = g_slist_append(groups1, strdup("stuff"));
roster_add("person@server.org", NULL, groups1, NULL, FALSE);
GSList* groups2 = NULL;
GSList *groups2 = NULL;
groups2 = g_slist_append(groups2, strdup("stuff"));
roster_update("person@server.org", NULL, groups2, NULL, FALSE);
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 1);
GList* found = g_list_find_custom(groups_res, "stuff", (GCompareFunc)g_strcmp0);
GList *found = g_list_find_custom(groups_res, "stuff", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
assert_string_equal(found->data, "stuff");
@@ -491,12 +466,11 @@ add_contact_with_three_groups_update_removing_two(void** state)
roster_destroy();
}
void
add_contact_with_three_groups_update_removing_three(void** state)
void add_contact_with_three_groups_update_removing_three(void **state)
{
roster_create();
GSList* groups1 = NULL;
GSList *groups1 = NULL;
groups1 = g_slist_append(groups1, strdup("friends"));
groups1 = g_slist_append(groups1, strdup("work"));
groups1 = g_slist_append(groups1, strdup("stuff"));
@@ -504,33 +478,32 @@ add_contact_with_three_groups_update_removing_three(void** state)
roster_update("person@server.org", NULL, NULL, NULL, FALSE);
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 0);
g_list_free_full(groups_res, free);
roster_destroy();
}
void
add_contact_with_three_groups_update_two_new(void** state)
void add_contact_with_three_groups_update_two_new(void **state)
{
roster_create();
GSList* groups1 = NULL;
GSList *groups1 = NULL;
groups1 = g_slist_append(groups1, strdup("friends"));
groups1 = g_slist_append(groups1, strdup("work"));
groups1 = g_slist_append(groups1, strdup("stuff"));
roster_add("person@server.org", NULL, groups1, NULL, FALSE);
GSList* groups2 = NULL;
GSList *groups2 = NULL;
groups2 = g_slist_append(groups2, strdup("newfriends"));
groups2 = g_slist_append(groups2, strdup("somepeople"));
roster_update("person@server.org", NULL, groups2, NULL, FALSE);
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 2);
GList* found = g_list_find_custom(groups_res, "newfriends", (GCompareFunc)g_strcmp0);
GList *found = g_list_find_custom(groups_res, "newfriends", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
found = g_list_find_custom(groups_res, "somepeople", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
@@ -539,12 +512,11 @@ add_contact_with_three_groups_update_two_new(void** state)
roster_destroy();
}
void
add_remove_contact_groups(void** state)
void add_remove_contact_groups(void **state)
{
roster_create();
GSList* groups1 = NULL;
GSList *groups1 = NULL;
groups1 = g_slist_append(groups1, strdup("friends"));
groups1 = g_slist_append(groups1, strdup("work"));
groups1 = g_slist_append(groups1, strdup("stuff"));
@@ -552,33 +524,32 @@ add_remove_contact_groups(void** state)
roster_remove("person@server.org", "person@server.org");
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 0);
g_list_free_full(groups_res, free);
roster_destroy();
}
void
add_contacts_with_different_groups(void** state)
void add_contacts_with_different_groups(void **state)
{
roster_create();
GSList* groups1 = NULL;
GSList *groups1 = NULL;
groups1 = g_slist_append(groups1, strdup("friends"));
groups1 = g_slist_append(groups1, strdup("work"));
groups1 = g_slist_append(groups1, strdup("stuff"));
roster_add("person@server.org", NULL, groups1, NULL, FALSE);
GSList* groups2 = NULL;
GSList *groups2 = NULL;
groups2 = g_slist_append(groups2, strdup("newfriends"));
groups2 = g_slist_append(groups2, strdup("somepeople"));
roster_add("bob@server.org", NULL, groups2, NULL, FALSE);
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 5);
GList* found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
GList *found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
found = g_list_find_custom(groups_res, "work", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
@@ -593,27 +564,26 @@ add_contacts_with_different_groups(void** state)
roster_destroy();
}
void
add_contacts_with_same_groups(void** state)
void add_contacts_with_same_groups(void **state)
{
roster_create();
GSList* groups1 = NULL;
GSList *groups1 = NULL;
groups1 = g_slist_append(groups1, strdup("friends"));
groups1 = g_slist_append(groups1, strdup("work"));
groups1 = g_slist_append(groups1, strdup("stuff"));
roster_add("person@server.org", NULL, groups1, NULL, FALSE);
GSList* groups2 = NULL;
GSList *groups2 = NULL;
groups2 = g_slist_append(groups2, strdup("friends"));
groups2 = g_slist_append(groups2, strdup("work"));
groups2 = g_slist_append(groups2, strdup("stuff"));
roster_add("bob@server.org", NULL, groups2, NULL, FALSE);
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 3);
GList* found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
GList *found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
found = g_list_find_custom(groups_res, "work", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
@@ -624,27 +594,26 @@ add_contacts_with_same_groups(void** state)
roster_destroy();
}
void
add_contacts_with_overlapping_groups(void** state)
void add_contacts_with_overlapping_groups(void **state)
{
roster_create();
GSList* groups1 = NULL;
GSList *groups1 = NULL;
groups1 = g_slist_append(groups1, strdup("friends"));
groups1 = g_slist_append(groups1, strdup("work"));
groups1 = g_slist_append(groups1, strdup("stuff"));
roster_add("person@server.org", NULL, groups1, NULL, FALSE);
GSList* groups2 = NULL;
GSList *groups2 = NULL;
groups2 = g_slist_append(groups2, strdup("friends"));
groups2 = g_slist_append(groups2, strdup("work"));
groups2 = g_slist_append(groups2, strdup("different"));
roster_add("bob@server.org", NULL, groups2, NULL, FALSE);
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 4);
GList* found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
GList *found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
found = g_list_find_custom(groups_res, "work", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
@@ -657,18 +626,17 @@ add_contacts_with_overlapping_groups(void** state)
roster_destroy();
}
void
remove_contact_with_remaining_in_group(void** state)
void remove_contact_with_remaining_in_group(void **state)
{
roster_create();
GSList* groups1 = NULL;
GSList *groups1 = NULL;
groups1 = g_slist_append(groups1, strdup("friends"));
groups1 = g_slist_append(groups1, strdup("work"));
groups1 = g_slist_append(groups1, strdup("stuff"));
roster_add("person@server.org", NULL, groups1, NULL, FALSE);
GSList* groups2 = NULL;
GSList *groups2 = NULL;
groups2 = g_slist_append(groups2, strdup("friends"));
groups2 = g_slist_append(groups2, strdup("work"));
groups2 = g_slist_append(groups2, strdup("different"));
@@ -676,10 +644,10 @@ remove_contact_with_remaining_in_group(void** state)
roster_remove("bob@server.org", "bob@server.org");
GList* groups_res = roster_get_groups();
GList *groups_res = roster_get_groups();
assert_int_equal(g_list_length(groups_res), 3);
GList* found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
GList *found = g_list_find_custom(groups_res, "friends", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);
found = g_list_find_custom(groups_res, "work", (GCompareFunc)g_strcmp0);
assert_true(found != NULL);

64
tests/unittests/test_roster_list.h
View File

@@ -1,32 +1,32 @@
void empty_list_when_none_added(void** state);
void contains_one_element(void** state);
void first_element_correct(void** state);
void contains_two_elements(void** state);
void first_and_second_elements_correct(void** state);
void contains_three_elements(void** state);
void first_three_elements_correct(void** state);
void add_twice_at_beginning_adds_once(void** state);
void add_twice_in_middle_adds_once(void** state);
void add_twice_at_end_adds_once(void** state);
void find_first_exists(void** state);
void find_second_exists(void** state);
void find_third_exists(void** state);
void find_returns_null(void** state);
void find_on_empty_returns_null(void** state);
void find_twice_returns_second_when_two_match(void** state);
void find_five_times_finds_fifth(void** state);
void find_twice_returns_first_when_two_match_and_reset(void** state);
void add_contact_with_no_group(void** state);
void add_contact_with_group(void** state);
void add_contact_with_two_groups(void** state);
void add_contact_with_three_groups(void** state);
void add_contact_with_three_groups_update_adding_two(void** state);
void add_contact_with_three_groups_update_removing_one(void** state);
void add_contact_with_three_groups_update_removing_two(void** state);
void add_contact_with_three_groups_update_removing_three(void** state);
void add_contact_with_three_groups_update_two_new(void** state);
void add_remove_contact_groups(void** state);
void add_contacts_with_different_groups(void** state);
void add_contacts_with_same_groups(void** state);
void add_contacts_with_overlapping_groups(void** state);
void remove_contact_with_remaining_in_group(void** state);
void empty_list_when_none_added(void **state);
void contains_one_element(void **state);
void first_element_correct(void **state);
void contains_two_elements(void **state);
void first_and_second_elements_correct(void **state);
void contains_three_elements(void **state);
void first_three_elements_correct(void **state);
void add_twice_at_beginning_adds_once(void **state);
void add_twice_in_middle_adds_once(void **state);
void add_twice_at_end_adds_once(void **state);
void find_first_exists(void **state);
void find_second_exists(void **state);
void find_third_exists(void **state);
void find_returns_null(void **state);
void find_on_empty_returns_null(void **state);
void find_twice_returns_second_when_two_match(void **state);
void find_five_times_finds_fifth(void **state);
void find_twice_returns_first_when_two_match_and_reset(void **state);
void add_contact_with_no_group(void **state);
void add_contact_with_group(void **state);
void add_contact_with_two_groups(void **state);
void add_contact_with_three_groups(void **state);
void add_contact_with_three_groups_update_adding_two(void **state);
void add_contact_with_three_groups_update_removing_one(void **state);
void add_contact_with_three_groups_update_removing_two(void **state);
void add_contact_with_three_groups_update_removing_three(void **state);
void add_contact_with_three_groups_update_two_new(void **state);
void add_remove_contact_groups(void **state);
void add_contacts_with_different_groups(void **state);
void add_contacts_with_same_groups(void **state);
void add_contacts_with_overlapping_groups(void **state);
void remove_contact_with_remaining_in_group(void **state);

63
tests/unittests/test_server_events.c
View File

@@ -1,32 +1,31 @@
#include <cmocka.h>
#include <glib.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "config/preferences.h"
#include "event/server_events.h"
#include "plugins/plugins.h"
#include "ui/stub_ui.h"
#include "ui/ui.h"
#include "ui/window_list.h"
#include "xmpp/chat_session.h"
#include "xmpp/muc.h"
#include "xmpp/roster_list.h"
#include "xmpp/xmpp.h"
#include "xmpp/roster_list.h"
#include "xmpp/chat_session.h"
#include "config/preferences.h"
#include "ui/ui.h"
#include "ui/stub_ui.h"
#include "xmpp/muc.h"
#include "plugins/plugins.h"
#include "ui/window_list.h"
void
console_shows_online_presence_when_set_online(void** state)
void console_shows_online_presence_when_set_online(void **state)
{
prefs_set_string(PREF_STATUSES_CONSOLE, "online");
plugins_init();
roster_create();
roster_process_pending_presence();
char* barejid = "test1@server";
char *barejid = "test1@server";
roster_add(barejid, "bob", NULL, "both", FALSE);
Resource* resource = resource_new("resource", RESOURCE_ONLINE, NULL, 10);
Resource *resource = resource_new("resource", RESOURCE_ONLINE, NULL, 10);
expect_memory(ui_contact_online, barejid, barejid, sizeof(barejid));
expect_memory(ui_contact_online, resource, resource, sizeof(resource));
@@ -38,16 +37,15 @@ console_shows_online_presence_when_set_online(void** state)
plugins_shutdown();
}
void
console_shows_online_presence_when_set_all(void** state)
void console_shows_online_presence_when_set_all(void **state)
{
prefs_set_string(PREF_STATUSES_CONSOLE, "all");
plugins_init();
roster_create();
roster_process_pending_presence();
char* barejid = "test1@server";
char *barejid = "test1@server";
roster_add(barejid, "bob", NULL, "both", FALSE);
Resource* resource = resource_new("resource", RESOURCE_ONLINE, NULL, 10);
Resource *resource = resource_new("resource", RESOURCE_ONLINE, NULL, 10);
expect_memory(ui_contact_online, barejid, barejid, sizeof(barejid));
expect_memory(ui_contact_online, resource, resource, sizeof(resource));
@@ -59,16 +57,15 @@ console_shows_online_presence_when_set_all(void** state)
plugins_shutdown();
}
void
console_shows_dnd_presence_when_set_all(void** state)
void console_shows_dnd_presence_when_set_all(void **state)
{
prefs_set_string(PREF_STATUSES_CONSOLE, "all");
plugins_init();
roster_create();
roster_process_pending_presence();
char* barejid = "test1@server";
char *barejid = "test1@server";
roster_add(barejid, "bob", NULL, "both", FALSE);
Resource* resource = resource_new("resource", RESOURCE_ONLINE, NULL, 10);
Resource *resource = resource_new("resource", RESOURCE_ONLINE, NULL, 10);
expect_memory(ui_contact_online, barejid, barejid, sizeof(barejid));
expect_memory(ui_contact_online, resource, resource, sizeof(resource));
@@ -80,24 +77,23 @@ console_shows_dnd_presence_when_set_all(void** state)
plugins_shutdown();
}
void
handle_offline_removes_chat_session(void** state)
void handle_offline_removes_chat_session(void **state)
{
plugins_init();
roster_create();
roster_process_pending_presence();
chat_sessions_init();
char* barejid = "friend@server.chat.com";
char* resource = "home";
char *barejid = "friend@server.chat.com";
char *resource = "home";
roster_add(barejid, "bob", NULL, "both", FALSE);
Resource* resourcep = resource_new(resource, RESOURCE_ONLINE, NULL, 10);
Resource *resourcep = resource_new(resource, RESOURCE_ONLINE, NULL, 10);
roster_update_presence(barejid, resourcep, NULL);
chat_session_recipient_active(barejid, resource, FALSE);
ProfConsoleWin* console = malloc(sizeof(ProfConsoleWin));
ProfConsoleWin *console = malloc(sizeof(ProfConsoleWin));
will_return(win_create_console, &console->window);
wins_init();
sv_ev_contact_offline(barejid, resource, NULL);
ChatSession* session = chat_session_get(barejid);
ChatSession *session = chat_session_get(barejid);
assert_null(session);
@@ -106,8 +102,7 @@ handle_offline_removes_chat_session(void** state)
plugins_shutdown();
}
void
lost_connection_clears_chat_sessions(void** state)
void lost_connection_clears_chat_sessions(void **state)
{
roster_create();
roster_process_pending_presence();
@@ -118,8 +113,8 @@ lost_connection_clears_chat_sessions(void** state)
sv_ev_lost_connection();
ChatSession* session1 = chat_session_get("bob@server.org");
ChatSession* session2 = chat_session_get("steve@server.org");
ChatSession *session1 = chat_session_get("bob@server.org");
ChatSession *session2 = chat_session_get("steve@server.org");
assert_null(session1);
assert_null(session2);
}

28
tests/unittests/test_server_events.h
View File

@@ -1,14 +1,14 @@
void console_doesnt_show_online_presence_when_set_none(void** state);
void console_shows_online_presence_when_set_online(void** state);
void console_shows_online_presence_when_set_all(void** state);
void console_doesnt_show_dnd_presence_when_set_none(void** state);
void console_doesnt_show_dnd_presence_when_set_online(void** state);
void console_shows_dnd_presence_when_set_all(void** state);
void handle_message_error_when_no_recipient(void** state);
void handle_message_error_when_recipient_cancel(void** state);
void handle_message_error_when_recipient_cancel_disables_chat_session(void** state);
void handle_message_error_when_recipient_and_no_type(void** state);
void handle_presence_error_when_no_recipient(void** state);
void handle_presence_error_when_from_recipient(void** state);
void handle_offline_removes_chat_session(void** state);
void lost_connection_clears_chat_sessions(void** state);
void console_doesnt_show_online_presence_when_set_none(void **state);
void console_shows_online_presence_when_set_online(void **state);
void console_shows_online_presence_when_set_all(void **state);
void console_doesnt_show_dnd_presence_when_set_none(void **state);
void console_doesnt_show_dnd_presence_when_set_online(void **state);
void console_shows_dnd_presence_when_set_all(void **state);
void handle_message_error_when_no_recipient(void **state);
void handle_message_error_when_recipient_cancel(void **state);
void handle_message_error_when_recipient_cancel_disables_chat_session(void **state);
void handle_message_error_when_recipient_and_no_type(void **state);
void handle_presence_error_when_no_recipient(void **state);
void handle_presence_error_when_from_recipient(void **state);
void handle_offline_removes_chat_session(void **state);
void lost_connection_clears_chat_sessions(void **state);

35
tests/unittests/tools/stub_http_upload.c
View File

@@ -7,39 +7,26 @@
// forward -> ui/win_types.h
typedef struct prof_win_t ProfWin;
typedef struct http_upload_t
{
char* filename;
typedef struct http_upload_t {
char *filename;
off_t filesize;
curl_off_t bytes_sent;
char* mime_type;
char* get_url;
char* put_url;
ProfWin* window;
char *mime_type;
char *get_url;
char *put_url;
ProfWin *window;
pthread_t worker;
int cancel;
} HTTPUpload;
//GSList *upload_processes;
void*
http_file_put(void* userdata)
{
return NULL;
}
void* http_file_put(void *userdata) { return NULL; }
char*
file_mime_type(const char* const file_name)
{
return NULL;
}
off_t
file_size(const char* const file_name)
{
return 0;
}
char* file_mime_type(const char* const file_name) { return NULL; }
off_t file_size(const char* const file_name) { return 0; }
void http_upload_cancel_processes(){};
void http_upload_add_upload(){};
void http_upload_cancel_processes() {};
void http_upload_add_upload() {};
#endif

1366
tests/unittests/ui/stub_ui.c
View File

File diff suppressed because it is too large Load Diff

6
tests/unittests/ui/stub_ui.h
View File

@@ -1,5 +1,5 @@
void expect_cons_show(char* expected);
void expect_cons_show(char *expected);
void expect_any_cons_show(void);
void expect_cons_show_error(char* expected);
void expect_cons_show_error(char *expected);
void expect_any_cons_show_error(void);
void expect_win_println(char* message);
void expect_win_println(char *message);

288
tests/unittests/unittests.c
View File

@@ -1,50 +1,48 @@
#include <cmocka.h>
#include <fcntl.h>
#include <langinfo.h>
#include <locale.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <locale.h>
#include <langinfo.h>
#include "config.h"
#include "xmpp/chat_session.h"
#include "helpers.h"
#include "test_autocomplete.h"
#include "test_callbacks.h"
#include "test_chat_session.h"
#include "test_cmd_account.h"
#include "test_cmd_alias.h"
#include "test_cmd_bookmark.h"
#include "test_cmd_connect.h"
#include "test_cmd_disconnect.h"
#include "test_cmd_join.h"
#include "test_cmd_otr.h"
#include "test_cmd_pgp.h"
#include "test_cmd_presence.h"
#include "test_cmd_rooms.h"
#include "test_cmd_roster.h"
#include "test_cmd_sub.h"
#include "test_common.h"
#include "test_contact.h"
#include "test_form.h"
#include "test_cmd_connect.h"
#include "test_cmd_account.h"
#include "test_cmd_rooms.h"
#include "test_cmd_sub.h"
#include "test_cmd_presence.h"
#include "test_cmd_otr.h"
#include "test_cmd_pgp.h"
#include "test_jid.h"
#include "test_muc.h"
#include "test_parser.h"
#include "test_plugins_disco.h"
#include "test_preferences.h"
#include "test_roster_list.h"
#include "test_preferences.h"
#include "test_server_events.h"
#include "xmpp/chat_session.h"
#include "test_cmd_alias.h"
#include "test_cmd_bookmark.h"
#include "test_cmd_join.h"
#include "test_muc.h"
#include "test_cmd_roster.h"
#include "test_cmd_disconnect.h"
#include "test_form.h"
#include "test_callbacks.h"
#include "test_plugins_disco.h"
int
main(int argc, char* argv[])
{
int main(int argc, char* argv[]) {
setlocale(LC_ALL, "en_GB.UTF-8");
char* codeset = nl_langinfo(CODESET);
char* lang = getenv("LANG");
char *codeset = nl_langinfo(CODESET);
char *lang = getenv("LANG");
printf("Charset information:\n");
@@ -219,93 +217,93 @@ main(int argc, char* argv[])
unit_test(remove_contact_with_remaining_in_group),
unit_test_setup_teardown(returns_false_when_chat_session_does_not_exist,
init_chat_sessions,
close_chat_sessions),
init_chat_sessions,
close_chat_sessions),
unit_test_setup_teardown(creates_chat_session_on_recipient_activity,
init_chat_sessions,
close_chat_sessions),
init_chat_sessions,
close_chat_sessions),
unit_test_setup_teardown(replaces_chat_session_on_recipient_activity_with_different_resource,
init_chat_sessions,
close_chat_sessions),
init_chat_sessions,
close_chat_sessions),
unit_test_setup_teardown(removes_chat_session,
init_chat_sessions,
close_chat_sessions),
init_chat_sessions,
close_chat_sessions),
unit_test_setup_teardown(cmd_connect_shows_message_when_disconnecting,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_message_when_connecting,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_message_when_connected,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_when_no_account,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_fail_message,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_lowercases_argument_with_account,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_lowercases_argument_with_no_account,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_asks_password_when_not_in_account,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_usage_when_no_server_value,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_message_when_connecting_with_account,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_connects_with_account,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_usage_when_server_no_port_value,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_usage_when_no_port_value,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_usage_when_port_no_server_value,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_message_when_port_0,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_message_when_port_minus1,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_message_when_port_65536,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_message_when_port_contains_chars,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_with_server_when_provided,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_with_port_when_provided,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_with_server_and_port_when_provided,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_usage_when_server_provided_twice,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_usage_when_port_provided_twice,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_usage_when_invalid_first_property,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_connect_shows_usage_when_invalid_second_property,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test(cmd_rooms_shows_message_when_disconnected),
unit_test(cmd_rooms_shows_message_when_disconnecting),
@@ -406,55 +404,55 @@ main(int argc, char* argv[])
unit_test(cmd_presence_shows_usage_when_bad_chat_setting),
unit_test(cmd_presence_shows_usage_when_bad_muc_setting),
unit_test_setup_teardown(cmd_presence_console_sets_all,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_presence_console_sets_online,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_presence_console_sets_none,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_presence_chat_sets_all,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_presence_chat_sets_online,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_presence_chat_sets_none,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_presence_room_sets_all,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_presence_room_sets_online,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_presence_room_sets_none,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(statuses_console_defaults_to_all,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(statuses_chat_defaults_to_all,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(statuses_muc_defaults_to_all,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(console_shows_online_presence_when_set_online,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(console_shows_online_presence_when_set_all,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(console_shows_dnd_presence_when_set_all,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(handle_offline_removes_chat_session,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test(lost_connection_clears_chat_sessions),
unit_test(cmd_alias_add_shows_usage_when_no_args),
@@ -462,20 +460,20 @@ main(int argc, char* argv[])
unit_test(cmd_alias_remove_shows_usage_when_no_args),
unit_test(cmd_alias_show_usage_when_invalid_subcmd),
unit_test_setup_teardown(cmd_alias_add_adds_alias,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_alias_add_shows_message_when_exists,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_alias_remove_removes_alias,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_alias_remove_shows_message_when_no_alias,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_alias_list_shows_all_aliases,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(test_muc_invites_add, muc_before_test, muc_after_test),
unit_test_setup_teardown(test_muc_remove_invite, muc_before_test, muc_after_test),
@@ -506,20 +504,20 @@ main(int argc, char* argv[])
unit_test(cmd_otr_log_shows_usage_when_no_args),
unit_test(cmd_otr_log_shows_usage_when_invalid_subcommand),
unit_test_setup_teardown(cmd_otr_log_on_enables_logging,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_otr_log_off_disables_logging,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_otr_redact_redacts_logging,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_otr_log_on_shows_warning_when_chlog_disabled,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test_setup_teardown(cmd_otr_log_redact_shows_warning_when_chlog_disabled,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test(cmd_otr_libver_shows_libotr_version),
unit_test(cmd_otr_gen_shows_message_when_not_connected),
unit_test(cmd_otr_gen_generates_key_for_connected_account),
@@ -542,8 +540,8 @@ main(int argc, char* argv[])
unit_test(cmd_otr_start_shows_message_when_already_started),
unit_test(cmd_otr_start_shows_message_when_no_key),
unit_test_setup_teardown(cmd_otr_start_sends_otr_query_message_to_current_recipeint,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
#else
unit_test(cmd_otr_shows_message_when_otr_unsupported),
#endif
@@ -610,8 +608,8 @@ main(int argc, char* argv[])
unit_test(remove_text_multi_value_removes_when_many),
unit_test_setup_teardown(clears_chat_sessions,
load_preferences,
close_preferences),
load_preferences,
close_preferences),
unit_test(prof_partial_occurrences_tests),
unit_test(prof_whole_occurrences_tests),

11
tests/unittests/xmpp/stub_avatar.c
View File

@@ -1,10 +1,7 @@
#include <glib.h>
#include <stdio.h>
#include <glib.h>
#include <stdlib.h>
void avatar_pep_subscribe(void){};
gboolean
avatar_get_by_nick(const char* nick)
{
return TRUE;
}
void avatar_pep_subscribe(void) {};
gboolean avatar_get_by_nick(const char* nick) {return TRUE;}

9
tests/unittests/xmpp/stub_message.c
View File

@@ -1,12 +1,7 @@
#include "xmpp/message.h"
ProfMessage*
message_init(void)
{
ProfMessage *message_init(void) {
return NULL;
}
void
message_free(ProfMessage* message)
{
}
void message_free(ProfMessage *message) {}

4
tests/unittests/xmpp/stub_ox.c
View File

@@ -1,8 +1,8 @@
#include <glib.h>
#include <stdio.h>
#include <glib.h>
#include <stdlib.h>
gboolean
gboolean
ox_announce_public_key(const char* const filename)
{
return FALSE;

432
tests/unittests/xmpp/stub_xmpp.c
View File

@@ -1,28 +1,18 @@
#include <cmocka.h>
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include "xmpp/xmpp.h"
// connection functions
void
session_init(void)
{
}
void
session_init_activity(void)
{
}
void
session_check_autoaway(void)
{
}
void session_init(void) {}
void session_init_activity(void) {}
void session_check_autoaway(void) {}
jabber_conn_status_t
session_connect_with_details(const char* const jid,
const char* const passwd, const char* const altdomain, const int port, const char* const tls_policy,
const char* const auth_policy)
jabber_conn_status_t session_connect_with_details(const char * const jid,
const char * const passwd, const char * const altdomain, const int port, const char *const tls_policy,
const char *const auth_policy)
{
check_expected(jid);
check_expected(passwd);
@@ -31,45 +21,31 @@ session_connect_with_details(const char* const jid,
return mock_type(jabber_conn_status_t);
}
jabber_conn_status_t
session_connect_with_account(const ProfAccount* const account)
jabber_conn_status_t session_connect_with_account(const ProfAccount * const account)
{
check_expected(account);
return mock_type(jabber_conn_status_t);
}
void
session_disconnect(void)
void session_disconnect(void) {}
void session_shutdown(void) {}
void session_process_events(void) {}
const char * connection_get_fulljid(void)
{
}
void
session_shutdown(void)
{
}
void
session_process_events(void)
{
}
const char*
connection_get_fulljid(void)
{
return mock_ptr_type(char*);
return mock_ptr_type(char *);
}
char*
connection_get_barejid(void)
char* connection_get_barejid(void)
{
return mock_ptr_type(char*);
return mock_ptr_type(char *);
}
const char*
connection_get_domain(void)
const char * connection_get_domain(void)
{
return NULL;
}
gboolean
connection_is_secured(void)
gboolean connection_is_secured(void)
{
return 1;
}
@@ -80,355 +56,202 @@ connection_get_tls_peer_cert(void)
return NULL;
}
char*
connection_create_uuid(void)
char* connection_create_uuid(void)
{
return NULL;
}
void
connection_free_uuid(char* uuid)
{
}
void connection_free_uuid(char * uuid) {}
jabber_conn_status_t
connection_get_status(void)
jabber_conn_status_t connection_get_status(void)
{
return mock_type(jabber_conn_status_t);
}
char*
connection_get_presence_msg(void)
char* connection_get_presence_msg(void)
{
return mock_ptr_type(char*);
}
char*
session_get_account_name(void)
char* session_get_account_name(void)
{
return mock_ptr_type(char*);
}
GList*
session_get_available_resources(void)
GList * session_get_available_resources(void)
{
return NULL;
}
void
connection_set_presence_msg(const char* const message)
{
}
void connection_set_presence_msg(const char *const message) {}
gboolean
connection_send_stanza(const char* const stanza)
connection_send_stanza(const char *const stanza)
{
return TRUE;
}
gboolean
connection_supports(const char* const feature)
connection_supports(const char *const feature)
{
return FALSE;
}
const char*
connection_get_profanity_identifier(void)
{
const char* connection_get_profanity_identifier(void) {
return "profident";
}
// message functions
char*
message_send_chat(const char* const barejid, const char* const msg, const char* const oob_url, gboolean request_receipt, const char* const replace_id)
char* message_send_chat(const char *const barejid, const char *const msg, const char *const oob_url, gboolean request_receipt, const char *const replace_id)
{
check_expected(barejid);
check_expected(msg);
return NULL;
}
char*
message_send_chat_otr(const char* const barejid, const char* const msg, gboolean request_receipt, const char* const replace_id)
char* message_send_chat_otr(const char * const barejid, const char * const msg, gboolean request_receipt, const char *const replace_id)
{
check_expected(barejid);
check_expected(msg);
return NULL;
}
char*
message_send_chat_pgp(const char* const barejid, const char* const msg, gboolean request_receipt, const char* const replace_id)
char* message_send_chat_pgp(const char * const barejid, const char * const msg, gboolean request_receipt, const char *const replace_id)
{
return NULL;
}
char*
message_send_chat_ox(const char* const barejid, const char* const msg, gboolean request_receipt, const char* const replace_id)
char* message_send_chat_ox(const char * const barejid, const char * const msg, gboolean request_receipt, const char *const replace_id)
{
return NULL;
}
char*
message_send_private(const char* const fulljid, const char* const msg, const char* const oob_url)
char* message_send_private(const char *const fulljid, const char *const msg, const char *const oob_url)
{
return NULL;
}
char*
message_send_groupchat(const char* const roomjid, const char* const msg, const char* const oob_url, const char* const replace_id)
char* message_send_groupchat(const char *const roomjid, const char *const msg, const char *const oob_url, const char *const replace_id)
{
return NULL;
}
void
message_send_groupchat_subject(const char* const roomjid, const char* const subject)
{
}
void message_send_groupchat_subject(const char * const roomjid, const char * const subject) {}
void
message_send_inactive(const char* const barejid)
{
}
void
message_send_composing(const char* const barejid)
{
}
void
message_send_paused(const char* const barejid)
{
}
void
message_send_gone(const char* const barejid)
{
}
void message_send_inactive(const char * const barejid) {}
void message_send_composing(const char * const barejid) {}
void message_send_paused(const char * const barejid) {}
void message_send_gone(const char * const barejid) {}
void
message_send_invite(const char* const room, const char* const contact,
const char* const reason)
{
}
void message_send_invite(const char * const room, const char * const contact,
const char * const reason) {}
bool
message_is_sent_by_us(const ProfMessage* const message, bool checkOID)
{
bool message_is_sent_by_us(const ProfMessage *const message, bool checkOID) {
return TRUE;
}
// presence functions
void
presence_subscription(const char* const jid, const jabber_subscr_t action)
{
}
void presence_subscription(const char * const jid, const jabber_subscr_t action) {}
GList*
presence_get_subscription_requests(void)
GList* presence_get_subscription_requests(void)
{
return NULL;
}
gint
presence_sub_request_count(void)
gint presence_sub_request_count(void)
{
return 0;
}
void
presence_reset_sub_request_search(void)
void presence_reset_sub_request_search(void) {}
char * presence_sub_request_find(const char * const search_str, gboolean previous, void *context)
{
return NULL;
}
char*
presence_sub_request_find(const char* const search_str, gboolean previous, void* context)
{
return NULL;
}
void
presence_join_room(const char* const room, const char* const nick, const char* const passwd)
void presence_join_room(const char *const room, const char *const nick, const char *const passwd)
{
check_expected(room);
check_expected(nick);
check_expected(passwd);
}
void
presence_change_room_nick(const char* const room, const char* const nick)
{
}
void
presence_leave_chat_room(const char* const room_jid)
{
}
void presence_change_room_nick(const char * const room, const char * const nick) {}
void presence_leave_chat_room(const char * const room_jid) {}
void
presence_send(resource_presence_t status, int idle, char* signed_status)
void presence_send(resource_presence_t status, int idle, char *signed_status)
{
check_expected(status);
check_expected(idle);
check_expected(signed_status);
}
gboolean
presence_sub_request_exists(const char* const bare_jid)
gboolean presence_sub_request_exists(const char * const bare_jid)
{
return FALSE;
}
// iq functions
void iq_disable_carbons(){};
void iq_enable_carbons(){};
void
iq_send_software_version(const char* const fulljid)
{
}
void iq_disable_carbons() {};
void iq_enable_carbons() {};
void iq_send_software_version(const char * const fulljid) {}
void
iq_room_list_request(gchar* conferencejid, gchar* filter)
void iq_room_list_request(gchar *conferencejid, gchar *filter)
{
check_expected(conferencejid);
check_expected(filter);
}
void
iq_disco_info_request(gchar* jid)
{
}
void
iq_disco_items_request(gchar* jid)
{
}
void
iq_set_autoping(int seconds)
{
}
void
iq_http_upload_request(HTTPUpload* upload)
{
}
void
iq_confirm_instant_room(const char* const room_jid)
{
}
void
iq_destroy_room(const char* const room_jid)
{
}
void
iq_request_room_config_form(const char* const room_jid)
{
}
void
iq_submit_room_config(ProfConfWin* confwin)
{
}
void
iq_room_config_cancel(ProfConfWin* confwin)
{
}
void
iq_send_ping(const char* const target)
{
}
void
iq_send_caps_request(const char* const to, const char* const id,
const char* const node, const char* const ver)
{
}
void
iq_send_caps_request_for_jid(const char* const to, const char* const id,
const char* const node, const char* const ver)
{
}
void
iq_send_caps_request_legacy(const char* const to, const char* const id,
const char* const node, const char* const ver)
{
}
void
iq_room_info_request(const char* const room, gboolean display)
{
}
void
iq_room_affiliation_list(const char* const room, char* affiliation, bool show)
{
}
void
iq_room_affiliation_set(const char* const room, const char* const jid, char* affiliation,
const char* const reason)
{
}
void
iq_room_kick_occupant(const char* const room, const char* const nick, const char* const reason)
{
}
void
iq_room_role_set(const char* const room, const char* const nick, char* role,
const char* const reason)
{
}
void
iq_room_role_list(const char* const room, char* role)
{
}
void
iq_last_activity_request(gchar* jid)
{
}
void
iq_autoping_timer_cancel(void)
{
}
void
iq_autoping_check(void)
{
}
void
iq_rooms_cache_clear(void)
{
}
void
iq_command_list(const char* const target)
{
}
void
iq_command_exec(const char* const target, const char* const command)
{
}
void iq_disco_info_request(gchar *jid) {}
void iq_disco_items_request(gchar *jid) {}
void iq_set_autoping(int seconds) {}
void iq_http_upload_request(HTTPUpload *upload) {}
void iq_confirm_instant_room(const char * const room_jid) {}
void iq_destroy_room(const char * const room_jid) {}
void iq_request_room_config_form(const char * const room_jid) {}
void iq_submit_room_config(ProfConfWin *confwin) {}
void iq_room_config_cancel(ProfConfWin *confwin) {}
void iq_send_ping(const char * const target) {}
void iq_send_caps_request(const char * const to, const char * const id,
const char * const node, const char * const ver) {}
void iq_send_caps_request_for_jid(const char * const to, const char * const id,
const char * const node, const char * const ver) {}
void iq_send_caps_request_legacy(const char * const to, const char * const id,
const char * const node, const char * const ver) {}
void iq_room_info_request(const char * const room, gboolean display) {}
void iq_room_affiliation_list(const char * const room, char *affiliation, bool show) {}
void iq_room_affiliation_set(const char * const room, const char * const jid, char *affiliation,
const char * const reason) {}
void iq_room_kick_occupant(const char * const room, const char * const nick, const char * const reason) {}
void iq_room_role_set(const char * const room, const char * const nick, char *role,
const char * const reason) {}
void iq_room_role_list(const char * const room, char *role) {}
void iq_last_activity_request(gchar *jid) {}
void iq_autoping_timer_cancel(void) {}
void iq_autoping_check(void) {}
void iq_rooms_cache_clear(void) {}
void iq_command_list(const char *const target) {}
void iq_command_exec(const char *const target, const char *const command) {}
// caps functions
void
caps_add_feature(char* feature)
{
}
void
caps_remove_feature(char* feature)
{
}
EntityCapabilities*
caps_lookup(const char* const jid)
void caps_add_feature(char *feature) {}
void caps_remove_feature(char *feature) {}
EntityCapabilities* caps_lookup(const char * const jid)
{
return NULL;
}
void
caps_close(void)
{
}
void
caps_destroy(EntityCapabilities* caps)
{
}
void
caps_reset_ver(void)
{
}
gboolean
caps_jid_has_feature(const char* const jid, const char* const feature)
void caps_close(void) {}
void caps_destroy(EntityCapabilities *caps) {}
void caps_reset_ver(void) {}
gboolean caps_jid_has_feature(const char *const jid, const char *const feature)
{
return FALSE;
}
gboolean
bookmark_add(const char* jid, const char* nick, const char* password, const char* autojoin_str, const char* name)
gboolean bookmark_add(const char *jid, const char *nick, const char *password, const char *autojoin_str, const char *name)
{
check_expected(jid);
check_expected(nick);
@@ -437,103 +260,78 @@ bookmark_add(const char* jid, const char* nick, const char* password, const char
return mock_type(gboolean);
}
gboolean
bookmark_update(const char* jid, const char* nick, const char* password, const char* autojoin_str, const char* name)
gboolean bookmark_update(const char *jid, const char *nick, const char *password, const char *autojoin_str, const char *name)
{
return FALSE;
}
gboolean
bookmark_remove(const char* jid)
gboolean bookmark_remove(const char *jid)
{
check_expected(jid);
return mock_type(gboolean);
}
gboolean
bookmark_join(const char* jid)
gboolean bookmark_join(const char *jid)
{
return FALSE;
}
GList*
bookmark_get_list(void)
GList * bookmark_get_list(void)
{
return mock_ptr_type(GList*);
return mock_ptr_type(GList *);
}
char*
bookmark_find(const char* const search_str, gboolean previous, void* context)
char * bookmark_find(const char * const search_str, gboolean previous, void *context)
{
return NULL;
}
void
bookmark_autocomplete_reset(void)
{
}
void bookmark_autocomplete_reset(void) {}
void
roster_send_name_change(const char* const barejid, const char* const new_name, GSList* groups)
void roster_send_name_change(const char * const barejid, const char * const new_name, GSList *groups)
{
check_expected(barejid);
check_expected(new_name);
check_expected(groups);
}
gboolean
bookmark_exists(const char* const room)
gboolean bookmark_exists(const char *const room)
{
return FALSE;
}
void
roster_send_add_to_group(const char* const group, PContact contact)
{
}
void
roster_send_remove_from_group(const char* const group, PContact contact)
{
}
void roster_send_add_to_group(const char * const group, PContact contact) {}
void roster_send_remove_from_group(const char * const group, PContact contact) {}
void
roster_send_add_new(const char* const barejid, const char* const name)
void roster_send_add_new(const char * const barejid, const char * const name)
{
check_expected(barejid);
check_expected(name);
}
void
roster_send_remove(const char* const barejid)
void roster_send_remove(const char * const barejid)
{
check_expected(barejid);
}
GList*
blocked_list(void)
GList* blocked_list(void)
{
return NULL;
}
gboolean
blocked_add(char* jid)
gboolean blocked_add(char *jid)
{
return TRUE;
}
gboolean
blocked_remove(char* jid)
gboolean blocked_remove(char *jid)
{
return TRUE;
}
char*
blocked_ac_find(const char* const search_str, gboolean previous, void* context)
char* blocked_ac_find(const char *const search_str, gboolean previous, void *context)
{
return NULL;
}
void
blocked_ac_reset(void)
{
}
void blocked_ac_reset(void) {}