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

Added mock_accounts and fixed tests

Browse Source
This commit is contained in:
James Booth
2013-12-26 13:37:22 +00:00
parent b83b262d47
commit 8685e78c86
9 changed files with 847 additions and 336 deletions
Download Patch File Download Diff File Expand all files Collapse all files

516
tests/config/mock_accounts.c
View File

@@ -23,168 +23,558 @@
#include <glib.h>
#include <setjmp.h>
#include <cmocka.h>
#include <string.h>
#include "config/accounts.h"
void accounts_load(void) {}
void accounts_close(void) {}
// mocks and stubs
char * accounts_find_all(char *prefix)
{
return (char *)mock();
}
char * accounts_find_enabled(char *prefix)
{
return (char *)mock();
}
void accounts_reset_all_search(void) {}
void accounts_reset_enabled_search(void) {}
void accounts_add(const char *jid, const char *altdomain)
{
check_expected(jid);
}
gchar** accounts_get_list(void)
{
return (gchar **)mock();
}
ProfAccount* accounts_get_account(const char * const name)
static ProfAccount *
_mock_accounts_get_account(const char * const name)
{
check_expected(name);
return (ProfAccount *)mock();
}
void accounts_free_account(ProfAccount *account)
static char *
_mock_accounts_create_full_jid(ProfAccount *account)
{
check_expected(account);
return (char *)mock();
}
void
_stub_accounts_free_account(ProfAccount *account)
{
// do nothing
}
void
_mock_accounts_free_account(ProfAccount *account)
{
check_expected(account);
}
gboolean accounts_enable(const char * const name)
gchar **
_mock_accounts_get_list(void)
{
return (gchar **)mock();
}
void
_mock_accounts_add(const char *account_name, const char *altdomain)
{
check_expected(account_name);
check_expected(altdomain);
}
void
_stub_accounts_add(const char *account_name, const char *altdomain)
{
// do nothing
}
static gboolean
_mock_accounts_enable(const char * const name)
{
check_expected(name);
return (gboolean)mock();
}
gboolean accounts_disable(const char * const name)
static gboolean
_mock_accounts_disable(const char * const name)
{
check_expected(name);
return (gboolean)mock();
}
gboolean accounts_rename(const char * const account_name,
const char * const new_name)
static gboolean
_mock_accounts_rename(const char * const account_name, const char * const new_name)
{
check_expected(account_name);
check_expected(new_name);
return (gboolean)mock();
}
gboolean accounts_account_exists(const char * const account_name)
static gboolean
_mock_accounts_account_exists(const char * const account_name)
{
check_expected(account_name);
return (gboolean)mock();
}
void accounts_set_jid(const char * const account_name, const char * const value)
static void
_mock_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)
static void
_stub_accounts_set_jid(const char * const account_name, const char * const value)
{
// do nothing
}
static void
_mock_accounts_set_resource(const char * const account_name, const char * const value)
{
check_expected(account_name);
check_expected(value);
}
void accounts_set_resource(const char * const account_name, const char * const value)
static void
_stub_accounts_set_resource(const char * const account_name, const char * const value)
{
// do nothing
}
static void
_mock_accounts_set_server(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)
static void
_stub_accounts_set_server(const char * const account_name, const char * const value)
{
// do nothing
}
static void
_mock_accounts_set_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)
static void
_stub_accounts_set_password(const char * const account_name, const char * const value)
{
// do nothing
}
static void
_mock_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)
static void
_stub_accounts_set_muc_service(const char * const account_name, const char * const value)
{
// do nothing
}
static void
_mock_accounts_set_muc_nick(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) {}
static void
_stub_accounts_set_muc_nick(const char * const account_name, const char * const value)
{
// do nothing
}
void accounts_set_login_presence(const char * const account_name, const char * const value)
static void
_mock_accounts_set_priority_online(const char * const account_name, const gint value)
{
check_expected(account_name);
check_expected(value);
}
resource_presence_t accounts_get_login_presence(const char * const account_name)
{
return (resource_presence_t)mock();
}
resource_presence_t accounts_get_last_presence(const char * const account_name)
{
return (resource_presence_t)mock();
}
void accounts_set_priority_online(const char * const account_name, const gint value)
static void
_mock_accounts_set_priority_chat(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)
static void
_mock_accounts_set_priority_away(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)
static void
_mock_accounts_set_priority_xa(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)
static void
_mock_accounts_set_priority_dnd(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)
static void
_mock_accounts_set_login_presence(const char * const account_name, const char * const 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)
static void
_stub_accounts_set_login_presence(const char * const account_name, const char * const value)
{
return (gint)mock();
}
void accounts_clear_password(const char * const account_name) {}
// set up functions
char * accounts_create_full_jid(ProfAccount *account)
void
mock_accounts_get_account(void)
{
return (char *)mock();
accounts_get_account = _mock_accounts_get_account;
}
void
mock_accounts_create_full_jid(void)
{
accounts_create_full_jid = _mock_accounts_create_full_jid;
}
void
stub_accounts_free_account(void)
{
accounts_free_account = _stub_accounts_free_account;
}
void
mock_accounts_free_account(void)
{
accounts_free_account = _mock_accounts_free_account;
}
void
mock_accounts_get_list(void)
{
accounts_get_list = _mock_accounts_get_list;
}
void
mock_accounts_add(void)
{
accounts_add = _mock_accounts_add;
}
void
stub_accounts_add(void)
{
accounts_add = _stub_accounts_add;
}
void
mock_accounts_enable(void)
{
accounts_enable = _mock_accounts_enable;
}
void
mock_accounts_disable(void)
{
accounts_disable = _mock_accounts_disable;
}
void
mock_accounts_rename(void)
{
accounts_rename = _mock_accounts_rename;
}
void
mock_accounts_account_exists(void)
{
accounts_account_exists = _mock_accounts_account_exists;
}
void
mock_accounts_set_jid(void)
{
accounts_set_jid = _mock_accounts_set_jid;
}
void
stub_accounts_set_jid(void)
{
accounts_set_jid = _stub_accounts_set_jid;
}
void
mock_accounts_set_resource(void)
{
accounts_set_resource = _mock_accounts_set_resource;
}
void
stub_accounts_set_resource(void)
{
accounts_set_resource = _stub_accounts_set_resource;
}
void
mock_accounts_set_server(void)
{
accounts_set_server = _mock_accounts_set_server;
}
void
stub_accounts_set_server(void)
{
accounts_set_server = _stub_accounts_set_server;
}
void
mock_accounts_set_password(void)
{
accounts_set_password = _mock_accounts_set_password;
}
void
stub_accounts_set_password(void)
{
accounts_set_password = _stub_accounts_set_password;
}
void
mock_accounts_set_muc_service(void)
{
accounts_set_muc_service = _mock_accounts_set_muc_service;
}
void
stub_accounts_set_muc_service(void)
{
accounts_set_muc_service = _stub_accounts_set_muc_service;
}
void
mock_accounts_set_muc_nick(void)
{
accounts_set_muc_nick = _mock_accounts_set_muc_nick;
}
void
stub_accounts_set_muc_nick(void)
{
accounts_set_muc_nick = _stub_accounts_set_muc_nick;
}
void
mock_accounts_set_priorities(void)
{
accounts_set_priority_online = _mock_accounts_set_priority_online;
accounts_set_priority_chat = _mock_accounts_set_priority_chat;
accounts_set_priority_away = _mock_accounts_set_priority_away;
accounts_set_priority_xa = _mock_accounts_set_priority_xa;
accounts_set_priority_dnd = _mock_accounts_set_priority_dnd;
}
void
mock_accounts_set_login_presence(void)
{
accounts_set_login_presence = _mock_accounts_set_login_presence;
}
void
stub_accounts_set_login_presence(void)
{
accounts_set_login_presence = _stub_accounts_set_login_presence;
}
// mock behaviours
void
accounts_get_account_expect_and_return(const char * const name, ProfAccount *account)
{
expect_string(_mock_accounts_get_account, name, name);
will_return(_mock_accounts_get_account, account);
}
void
accounts_get_account_return(ProfAccount *account)
{
expect_any(_mock_accounts_get_account, name);
will_return(_mock_accounts_get_account, account);
}
void
accounts_create_full_jid_return(char *fulljid)
{
expect_any(_mock_accounts_create_full_jid, account);
if (fulljid != NULL) {
will_return(_mock_accounts_create_full_jid, strdup(fulljid));
} else {
will_return(_mock_accounts_create_full_jid, NULL);
}
}
void
accounts_free_account_expect(ProfAccount *account)
{
expect_memory(_mock_accounts_free_account, account, account, sizeof(ProfAccount));
}
void
accounts_get_list_return(gchar **accounts)
{
will_return(_mock_accounts_get_list, accounts);
}
void
accounts_add_expect_account_name(char *account_name)
{
expect_any(_mock_accounts_add, altdomain);
expect_string(_mock_accounts_add, account_name, account_name);
}
void
accounts_enable_expect(char *name)
{
expect_string(_mock_accounts_enable, name, name);
will_return(_mock_accounts_enable, TRUE);
}
void
accounts_enable_return(gboolean result)
{
expect_any(_mock_accounts_enable, name);
will_return(_mock_accounts_enable, result);
}
void
accounts_disable_expect(char *name)
{
expect_string(_mock_accounts_disable, name, name);
will_return(_mock_accounts_disable, TRUE);
}
void
accounts_disable_return(gboolean result)
{
expect_any(_mock_accounts_disable, name);
will_return(_mock_accounts_disable, result);
}
void
accounts_rename_expect(char *account_name, char *new_name)
{
expect_string(_mock_accounts_rename, account_name, account_name);
expect_string(_mock_accounts_rename, new_name, new_name);
will_return(_mock_accounts_rename, TRUE);
}
void
accounts_rename_return(gboolean result)
{
expect_any(_mock_accounts_rename, account_name);
expect_any(_mock_accounts_rename, new_name);
will_return(_mock_accounts_rename, result);
}
void
accounts_account_exists_expect(char *account_name)
{
expect_string(_mock_accounts_account_exists, account_name, account_name);
will_return(_mock_accounts_account_exists, TRUE);
}
void
accounts_account_exists_return(gboolean result)
{
expect_any(_mock_accounts_account_exists, account_name);
will_return(_mock_accounts_account_exists, result);
}
void
accounts_set_jid_expect(char *account_name, char *jid)
{
expect_string(_mock_accounts_set_jid, account_name, account_name);
expect_string(_mock_accounts_set_jid, value, jid);
}
void
accounts_set_resource_expect(char *account_name, char *resource)
{
expect_string(_mock_accounts_set_resource, account_name, account_name);
expect_string(_mock_accounts_set_resource, value, resource);
}
void
accounts_set_server_expect(char *account_name, char *server)
{
expect_string(_mock_accounts_set_server, account_name, account_name);
expect_string(_mock_accounts_set_server, value, server);
}
void
accounts_set_password_expect(char *account_name, char *password)
{
expect_string(_mock_accounts_set_password, account_name, account_name);
expect_string(_mock_accounts_set_password, value, password);
}
void
accounts_set_muc_service_expect(char *account_name, char *service)
{
expect_string(_mock_accounts_set_muc_service, account_name, account_name);
expect_string(_mock_accounts_set_muc_service, value, service);
}
void
accounts_set_muc_nick_expect(char *account_name, char *nick)
{
expect_string(_mock_accounts_set_muc_nick, account_name, account_name);
expect_string(_mock_accounts_set_muc_nick, value, nick);
}
void
accounts_set_priority_online_expect(char *account_name, gint priority)
{
expect_string(_mock_accounts_set_priority_online, account_name, account_name);
expect_value(_mock_accounts_set_priority_online, value, priority);
}
void
accounts_set_priority_chat_expect(char *account_name, gint priority)
{
expect_string(_mock_accounts_set_priority_chat, account_name, account_name);
expect_value(_mock_accounts_set_priority_chat, value, priority);
}
void
accounts_set_priority_away_expect(char *account_name, gint priority)
{
expect_string(_mock_accounts_set_priority_away, account_name, account_name);
expect_value(_mock_accounts_set_priority_away, value, priority);
}
void
accounts_set_priority_xa_expect(char *account_name, gint priority)
{
expect_string(_mock_accounts_set_priority_xa, account_name, account_name);
expect_value(_mock_accounts_set_priority_xa, value, priority);
}
void
accounts_set_priority_dnd_expect(char *account_name, gint priority)
{
expect_string(_mock_accounts_set_priority_dnd, account_name, account_name);
expect_value(_mock_accounts_set_priority_dnd, value, priority);
}
void
accounts_set_login_presence_expect(char *account_name, char *presence)
{
expect_string(_mock_accounts_set_login_presence, account_name, account_name);
expect_string(_mock_accounts_set_login_presence, value, presence);
}

90
tests/config/mock_accounts.h Normal file
View File

@@ -0,0 +1,90 @@
/*
* mock_accounts.h
*
* Copyright (C) 2012, 2013 James Booth <boothj5@gmail.com>
*
* This file is part of Profanity.
*
* Profanity is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Profanity is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY {} without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Profanity. If not, see <http://www.gnu.org/licenses/>.
*
*/
void mock_accounts_get_account(void);
void accounts_get_account_expect_and_return(const char * const name, ProfAccount *account);
void accounts_get_account_return(ProfAccount *account);
void mock_accounts_create_full_jid(void);
void accounts_create_full_jid_return(char *fulljid);
void mock_accounts_free_account(void);
void stub_accounts_free_account(void);
void accounts_free_account_expect(ProfAccount *account);
void mock_accounts_get_list(void);
void accounts_get_list_return(gchar **accounts);
void mock_accounts_add(void);
void stub_accounts_add(void);
void accounts_add_expect_account_name(char *account_name);
void mock_accounts_enable(void);
void accounts_enable_expect(char *name);
void accounts_enable_return(gboolean result);
void mock_accounts_disable(void);
void accounts_disable_expect(char *name);
void accounts_disable_return(gboolean result);
void mock_accounts_rename(void);
void accounts_rename_expect(char *account_name, char *new_name);
void accounts_rename_return(gboolean result);
void mock_accounts_account_exists(void);
void accounts_account_exists_expect(char *account_name);
void accounts_account_exists_return(gboolean result);
void mock_accounts_set_jid(void);
void stub_accounts_set_jid(void);
void accounts_set_jid_expect(char *account_name, char *jid);
void mock_accounts_set_resource(void);
void stub_accounts_set_resource(void);
void accounts_set_resource_expect(char *account_name, char *resource);
void mock_accounts_set_server(void);
void stub_accounts_set_server(void);
void accounts_set_server_expect(char *account_name, char *server);
void mock_accounts_set_password(void);
void stub_accounts_set_password(void);
void accounts_set_password_expect(char *account_name, char *password);
void mock_accounts_set_muc_service(void);
void stub_accounts_set_muc_service(void);
void accounts_set_muc_service_expect(char *account_name, char *service);
void mock_accounts_set_muc_nick(void);
void stub_accounts_set_muc_nick(void);
void accounts_set_muc_nick_expect(char *account_name, char *nick);
void mock_accounts_set_priorities(void);
void accounts_set_priority_online_expect(char *account_name, gint priority);
void accounts_set_priority_chat_expect(char *account_name, gint priority);
void accounts_set_priority_away_expect(char *account_name, gint priority);
void accounts_set_priority_xa_expect(char *account_name, gint priority);
void accounts_set_priority_dnd_expect(char *account_name, gint priority);
void mock_accounts_set_login_presence(void);
void stub_accounts_set_login_presence(void);
void accounts_set_login_presence_expect(char *account_name, char *presence);