refactored tests

test/mock/config_builder.cc

@@ -0,0 +1,254 @@
+#include "mock/config_builder.hpp"
+
+extern "C"
+{
+using webfused_test::IConfigBuilder;
+
+static IConfigBuilder * wfd_MockConfigBuilder = nullptr;
+
+extern struct wfd_config *
+__real_wfd_config_create(void);
+
+extern void
+__real_wfd_config_dispose(
+    struct wfd_config * config);
+
+extern void
+__real_wfd_config_set_server_vhostname(
+    struct wfd_config * config,
+    char const * vhost_name);
+
+extern void
+__real_wfd_config_set_server_port(
+    struct wfd_config * config,
+    int port);
+
+extern void
+__real_wfd_config_set_server_key(
+    struct wfd_config * config,
+    char const * key_path);
+
+extern void
+__real_wfd_config_set_server_cert(
+    struct wfd_config * config,
+    char const * cert_path);
+
+extern void
+__real_wfd_config_set_server_document_root(
+    struct wfd_config * config,
+    char const * document_root);
+
+extern bool
+__real_wfd_config_add_auth_provider(
+    struct wfd_config * config,
+    char const * provider,
+    struct wfd_settings * settings);
+
+extern bool
+__real_wfd_config_add_filesystem(
+    struct wfd_config * config,
+    char const * name,
+    char const * mount_point);
+
+extern bool
+__real_wfd_config_set_logger(
+    struct wfd_config * config,
+    char const * provider,
+    int level,
+    struct wfd_settings * settings);
+
+extern void
+__real_wfd_config_set_user(
+    struct wfd_config * config,
+    char const * user,
+    char const * group);
+
+struct wfd_config *
+__wrap_wfd_config_create(void)
+{
+    if (nullptr == wfd_MockConfigBuilder)
+    {
+        return __real_wfd_config_create();
+    }
+    else
+    {
+        return wfd_MockConfigBuilder->create();
+    }
+}
+
+void
+__wrap_wfd_config_dispose(
+    struct wfd_config * config)
+{
+    if (nullptr == wfd_MockConfigBuilder)
+    {
+        __real_wfd_config_dispose(config);
+    }
+    else
+    {
+        wfd_MockConfigBuilder->dispose(config);
+    }
+}
+
+void
+__wrap_wfd_config_set_server_vhostname(
+    struct wfd_config * config,
+    char const * vhost_name)
+{
+    if (nullptr == wfd_MockConfigBuilder)
+    {
+        __real_wfd_config_set_server_vhostname(config, vhost_name);
+    }
+    else
+    {
+        wfd_MockConfigBuilder->setServerVhostname(vhost_name);
+    }
+}
+
+void
+__wrap_wfd_config_set_server_port(
+    struct wfd_config * config,
+    int port)
+{
+    if (nullptr == wfd_MockConfigBuilder)
+    {
+        __real_wfd_config_set_server_port(config, port);
+    }
+    else
+    {
+        wfd_MockConfigBuilder->setServerPort(port);
+    }
+}
+
+void
+__wrap_wfd_config_set_server_key(
+    struct wfd_config * config,
+    char const * key_path)
+{
+    if (nullptr == wfd_MockConfigBuilder)
+    {
+        __real_wfd_config_set_server_key(config, key_path);
+    }
+    else
+    {
+        wfd_MockConfigBuilder->setServerKey(key_path);
+    }
+}
+
+void
+__wrap_wfd_config_set_server_cert(
+    struct wfd_config * config,
+    char const * cert_path)
+{
+    if (nullptr == wfd_MockConfigBuilder)
+    {
+        __real_wfd_config_set_server_cert(config, cert_path);
+    }
+    else
+    {
+        wfd_MockConfigBuilder->setServerCert(cert_path);
+    }
+}
+
+void
+__wrap_wfd_config_set_server_document_root(
+    struct wfd_config * config,
+    char const * document_root)
+{
+    if (nullptr == wfd_MockConfigBuilder)
+    {
+        __real_wfd_config_set_server_document_root(config, document_root);
+    }
+    else
+    {
+        wfd_MockConfigBuilder->setServerDocumentRoot(document_root);
+    }
+}
+
+bool
+__wrap_wfd_config_add_auth_provider(
+    struct wfd_config * config,
+    char const * provider,
+    struct wfd_settings * settings)
+{
+    if (nullptr == wfd_MockConfigBuilder)
+    {
+        return __real_wfd_config_add_auth_provider(config, provider, settings);
+    }
+    else
+    {
+        return wfd_MockConfigBuilder->addAuthProvider(provider, settings);
+    }
+}
+
+bool
+__wrap_wfd_config_add_filesystem(
+    struct wfd_config * config,
+    char const * name,
+    char const * mount_point)
+{
+    if (nullptr == wfd_MockConfigBuilder)
+    {
+        return __real_wfd_config_add_filesystem(config, name, mount_point);
+    }
+    else
+    {
+        return wfd_MockConfigBuilder->addFilesystem(name, mount_point);
+    }
+}
+
+bool
+__wrap_wfd_config_set_logger(
+    struct wfd_config * config,
+    char const * provider,
+    int level,
+    struct wfd_settings * settings)
+{
+    if (nullptr == wfd_MockConfigBuilder)
+    {
+        return __real_wfd_config_set_logger(config, provider, level, settings);
+    }
+    else
+    {
+        return wfd_MockConfigBuilder->setLogger(provider, level, settings);
+    }
+}
+
+void
+__wrap_wfd_config_set_user(
+    struct wfd_config * config,
+    char const * user,
+    char const * group)
+{
+    if (nullptr == wfd_MockConfigBuilder)
+    {
+        __real_wfd_config_set_user(config, user, group);
+    }
+    else
+    {
+        wfd_MockConfigBuilder->setUser(user, group);
+    }
+}
+
+}
+
+namespace webfused_test
+{
+
+MockConfigBuilder::MockConfigBuilder()
+{
+    wfd_MockConfigBuilder = this;    
+}
+
+MockConfigBuilder::~MockConfigBuilder()
+{
+    wfd_MockConfigBuilder = nullptr;
+}
+
+struct wfd_config * MockConfigBuilder::getBuilder()
+{
+    IConfigBuilder * config_builder = this;
+
+    return reinterpret_cast<wfd_config *>(config_builder);
+}
+}

test/mock/config_builder.hpp

@@ -0,0 +1,49 @@
+#ifndef WFD_MOCK_CONFIG_BUILDER_HPP
+#define WFD_MOCK_CONFIG_BUILDER_HPP
+
+#include <gmock/gmock.h>
+#include "webfused/config/config_intern.h"
+
+namespace webfused_test
+{
+
+class IConfigBuilder
+{
+public:
+    virtual ~IConfigBuilder() = default;
+    virtual wfd_config * create(void) = 0;
+    virtual void dispose(wfd_config * config) = 0;
+    virtual void setServerVhostname(char const * vhostname) = 0;
+    virtual void setServerPort(int port) = 0;
+    virtual void setServerKey(char const * key_path) = 0;
+    virtual void setServerCert(char const * cert_path) = 0;
+    virtual void setServerDocumentRoot(char const * document_root) = 0;
+    virtual bool addAuthProvider(char const * provider, wfd_settings * settings) = 0;
+    virtual bool addFilesystem(char const * name, char const * mountpoint) = 0;
+    virtual bool setLogger(char const * provider, int level, wfd_settings * settings) = 0;
+    virtual void setUser(char const * user, char const * group) = 0;
+};
+
+class MockConfigBuilder: public IConfigBuilder
+{
+public:
+    MockConfigBuilder();
+    ~MockConfigBuilder() override;
+    MOCK_METHOD0(create, wfd_config * (void));
+    MOCK_METHOD1(dispose, void (wfd_config * config));
+    MOCK_METHOD1(setServerVhostname, void (char const * vhostname));
+    MOCK_METHOD1(setServerPort, void (int port));
+    MOCK_METHOD1(setServerKey, void (char const * key_path));
+    MOCK_METHOD1(setServerCert, void (char const * cert_path));
+    MOCK_METHOD1(setServerDocumentRoot, void (char const * document_root));
+    MOCK_METHOD2(addAuthProvider, bool (char const * provider, wfd_settings * settings));
+    MOCK_METHOD2(addFilesystem, bool (char const * name, char const * mountpoint));
+    MOCK_METHOD3(setLogger, bool (char const * provider, int level, wfd_settings * settings));
+    MOCK_METHOD2(setUser, void (char const * user, char const * group));
+
+    struct wfd_config * getBuilder();
+};
+
+}
+
+#endif

test/mock/credentials.cc

@@ -0,0 +1,64 @@
+#include "mock/credentials.hpp"
+
+
+extern "C"
+{
+using webfused_test::ICredentials;
+
+static ICredentials * wfd_mock_credentials = nullptr;
+
+extern char const * 
+__real_wf_credentials_type(
+    struct wf_credentials const * credentials);
+
+char const *
+__wrap_wf_credentials_type(
+    struct wf_credentials const * credentials)
+{
+    if (nullptr == wfd_mock_credentials)
+    {
+        return __real_wf_credentials_type(credentials);
+    }
+    else
+    {
+        return wfd_mock_credentials->type();
+    }
+}
+
+extern char const * __real_wf_credentials_get(
+    struct wf_credentials const * credentials,
+    char const * key);
+
+
+char const * __wrap_wf_credentials_get(
+    struct wf_credentials const * credentials,
+    char const * key)
+{
+    if (nullptr == wfd_mock_credentials)
+    {
+        return __real_wf_credentials_get(credentials, key);
+    }
+    else
+    {
+        return wfd_mock_credentials->get(key);
+    }
+}
+
+
+}
+
+
+namespace webfused_test
+{
+
+MockCredentials::MockCredentials()
+{
+    wfd_mock_credentials = this;
+}
+
+MockCredentials::~MockCredentials()
+{
+    wfd_mock_credentials = nullptr;
+}
+
+}

test/mock/credentials.hpp

@@ -0,0 +1,29 @@
+#ifndef WFD_MOCK_CREDENTIALS_HPP
+#define WFD_MOCK_CREDENTIALS_HPP
+
+#include <gmock/gmock.h>
+#include "webfuse/adapter/credentials.h"
+
+namespace webfused_test
+{
+
+class ICredentials
+{
+public:
+    virtual ~ICredentials() = default;
+    virtual char const * type() = 0;
+    virtual char const * get(char const * key) = 0;   
+};
+
+class MockCredentials: public ICredentials
+{
+public:
+    MockCredentials();
+    virtual ~MockCredentials();
+    MOCK_METHOD0(type, char const*());
+    MOCK_METHOD1(get, char const *(char const * key));
+};
+
+}
+
+#endif

test/mock/libconfig.cc

@@ -0,0 +1,27 @@
+#include "mock/libconfig.hpp"
+#include "util/wrap.hpp"
+
+extern "C"
+{
+
+static webfused_test::ILibConfig * wfd_MockLibConfig = nullptr;
+
+WFD_WRAP_FUNC2(wfd_MockLibConfig, config_setting_t *, config_setting_get_elem, 
+    config_setting_t const *, unsigned int);
+
+}
+
+namespace webfused_test
+{
+
+MockLibConfig::MockLibConfig()
+{
+    wfd_MockLibConfig = this;
+}
+
+MockLibConfig::~MockLibConfig()
+{
+    wfd_MockLibConfig = nullptr;
+}
+
+}

test/mock/libconfig.hpp

@@ -0,0 +1,32 @@
+#ifndef WFD_MOCK_LIBCONFIG_HPP
+#define WFD_MOCK_LIBCONFIG_HPP
+
+#include <libconfig.h>
+#include <gmock/gmock.h>
+
+namespace webfused_test
+{
+
+class ILibConfig
+{
+public:
+    virtual ~ILibConfig() = default;
+    virtual config_setting_t * config_setting_get_elem(
+        config_setting_t const * setting,
+        unsigned int i) = 0;
+};
+
+class MockLibConfig: public ILibConfig
+{
+public:
+    MockLibConfig();
+    ~MockLibConfig() override;
+    MOCK_METHOD2(config_setting_get_elem, config_setting_t * (
+        config_setting_t const * setting, 
+        unsigned int i));
+
+};
+
+}
+
+#endif

test/mock/linux.cc

@@ -0,0 +1,31 @@
+#include "mock/linux.hpp"
+#include "util/wrap.hpp"
+
+extern "C"
+{
+
+static webfused_test::ILinux * wfd_MockLinux = nullptr;
+
+WFD_WRAP_FUNC0( wfd_MockLinux, uid_t, getuid);
+WFD_WRAP_FUNC1( wfd_MockLinux, struct group *, getgrnam, char const *);
+WFD_WRAP_FUNC1( wfd_MockLinux, int, setgid, gid_t);
+WFD_WRAP_FUNC2( wfd_MockLinux, int, setgroups, int, gid_t *);
+WFD_WRAP_FUNC1( wfd_MockLinux, struct passwd *, getpwnam, char const *);
+WFD_WRAP_FUNC1( wfd_MockLinux, int, setuid, uid_t);
+
+}
+
+namespace webfused_test
+{
+
+MockLinux::MockLinux()
+{
+    wfd_MockLinux = this;
+}
+
+MockLinux::~MockLinux()
+{
+    wfd_MockLinux = nullptr;
+}
+
+}

test/mock/linux.hpp

@@ -0,0 +1,41 @@
+#ifndef WFD_MOCK_LINUX_HPP
+#define WFD_MOCK_LINUX_HPP
+
+#include <unistd.h>
+#include <sys/types.h>
+#include <grp.h>
+#include <pwd.h>
+
+#include <gmock/gmock.h>
+
+namespace webfused_test
+{
+
+class ILinux
+{
+public:
+    virtual ~ILinux() = default;
+    virtual uid_t getuid() = 0;
+    virtual struct group * getgrnam(char const * name) = 0;
+    virtual int setgid(gid_t gid) = 0;
+    virtual int setgroups(int size, gid_t * list) = 0;
+    virtual struct passwd * getpwnam(char const * name) = 0;
+    virtual int setuid(uid_t uid) = 0;
+};
+
+class MockLinux: public ILinux
+{
+public:
+    MockLinux();
+    ~MockLinux();
+    MOCK_METHOD0(getuid, uid_t());
+    MOCK_METHOD1(getgrnam, struct group * (char const * name));
+    MOCK_METHOD1(setgid, int (gid_t gid));
+    MOCK_METHOD2(setgroups, int (int size, gid_t * list));
+    MOCK_METHOD1(getpwnam, struct passwd * (char const * name));
+    MOCK_METHOD1(setuid, int (uid_t uid));
+};
+
+}
+
+#endif

test/mock/logger.cc

@@ -0,0 +1,58 @@
+#include "mock/logger.hpp"
+#include "webfused/log/logger.h"
+#include "webfused/log/log.h"
+
+namespace webfused_test
+{
+
+MockLogger::MockLogger(bool omit_init)
+: close_on_destruct(!omit_init)
+{
+    if (!omit_init)
+    {
+        wfd_logger_init(
+            WFD_LOGLEVEL_ALL,
+            &wfd_MockLogger_log,
+            &wfd_MockLogger_onclose,
+            getUserData());
+    }
+}
+
+MockLogger::~MockLogger()
+{
+    if (close_on_destruct)
+    {
+        wfd_logger_close();
+    }
+}
+
+void * MockLogger::getUserData() 
+{
+    ILogger * logger = this;
+    return reinterpret_cast<void*>(logger);
+}
+
+}
+
+extern "C"
+{
+using webfused_test::ILogger;
+
+void wfd_MockLogger_log(
+    void * user_data,
+    int level,
+    char const * format,
+    va_list args)
+{
+    ILogger * logger = reinterpret_cast<ILogger*>(user_data);
+    logger->log(level, format, args);
+}
+
+void wfd_MockLogger_onclose(
+    void * user_data)
+{
+    ILogger * logger = reinterpret_cast<ILogger*>(user_data);
+    logger->onclose();
+}
+
+}

test/mock/logger.hpp

@@ -0,0 +1,47 @@
+#ifndef WFD_MOCK_LOGGER_HPP
+#define WFD_MOCK_LOGGER_HPP
+
+#include <gmock/gmock.h>
+#include <cstdarg>
+
+namespace webfused_test
+{
+
+class ILogger
+{
+public:
+    virtual ~ILogger() = default;
+    virtual void log(int level, char const * format, va_list args) = 0;
+    virtual void onclose() = 0;
+};
+
+class MockLogger: public ILogger
+{
+public:
+    explicit MockLogger(bool omit_init = false);
+    ~MockLogger() override;
+    MOCK_METHOD3(log, void(int level, char const * format, va_list args));
+    MOCK_METHOD0(onclose, void(void));
+
+    void * getUserData();
+private:
+    bool close_on_destruct;
+};
+
+}
+
+extern "C"
+{
+
+extern void wfd_MockLogger_log(
+    void * user_data,
+    int level,
+    char const * format,
+    va_list args);
+
+extern void wfd_MockLogger_onclose(
+    void * user_data);
+
+}
+
+#endif

test/mock/pam.cc

@@ -0,0 +1,99 @@
+#include "mock/pam.hpp"
+
+extern "C"
+{
+
+static webfused_test::IPam * wfd_MockPam = nullptr;
+
+extern int __real_pam_start(
+    char const * service_name,
+    char const * user,
+    struct pam_conv const * conversation,
+    pam_handle_t * * handle);
+extern int __real_pam_end(pam_handle_t * handle, int status);
+extern int __real_pam_authenticate(pam_handle_t * handle, int flags);
+extern int __real_pam_acct_mgmt(pam_handle_t * handle, int flags);
+extern char const * __real_pam_strerror(pam_handle_t * handle, int errnum);
+
+int __wrap_pam_start(
+    char const * service_name,
+    char const * user,
+    struct pam_conv const * conversation,
+    pam_handle_t * * handle)
+{
+    if (nullptr == wfd_MockPam)
+    {
+        return __real_pam_start(service_name, user, conversation, handle);
+    }
+    else
+    {
+        return wfd_MockPam->start(service_name, user, conversation, handle);
+    }
+
+}
+
+int __wrap_pam_end(pam_handle_t * handle, int status)
+{
+    if (nullptr == wfd_MockPam)
+    {
+        return __real_pam_end(handle, status);
+    }
+    else
+    {
+        return wfd_MockPam->end(handle, status);
+    }
+}
+
+int __wrap_pam_authenticate(pam_handle_t * handle, int flags)
+{
+    if (nullptr == wfd_MockPam)
+    {
+        return __real_pam_authenticate(handle, flags);
+    }
+    else
+    {
+        return wfd_MockPam->authenticate(handle, flags);
+    }
+}
+
+int __wrap_pam_acct_mgmt(pam_handle_t * handle, int flags)
+{
+    if (nullptr == wfd_MockPam)
+    {
+        return __real_pam_acct_mgmt(handle, flags);
+    }
+    else
+    {
+        return wfd_MockPam->acct_mgmt(handle, flags);
+    }
+}
+
+char const * __wrap_pam_strerror(pam_handle_t * handle, int errnum)
+{
+    if (nullptr == wfd_MockPam)
+    {
+        return __real_pam_strerror(handle, errnum);
+    }
+    else
+    {
+        return wfd_MockPam->strerror(handle, errnum);
+    }
+}
+
+
+}
+
+namespace webfused_test
+{
+
+MockPam::MockPam()
+{
+    wfd_MockPam = this;
+}
+
+MockPam::~MockPam()
+{
+    wfd_MockPam = nullptr;
+}
+
+}

test/mock/pam.hpp

@@ -0,0 +1,45 @@
+#ifndef WFD_MOCK_PAM_HPP
+#define WFD_MOCK_PAM_HPP
+
+#include <security/pam_appl.h>
+#include <gmock/gmock.h>
+
+namespace webfused_test
+{
+
+class IPam
+{
+public:
+    virtual ~IPam() = default;
+    virtual int start(
+        char const * service_name,
+        char const * user,
+        struct pam_conv const * conversation,
+        pam_handle_t * * handle) = 0;
+    virtual int end(pam_handle_t * handle, int status) = 0;
+    virtual int authenticate(pam_handle_t * handle, int flags) = 0;
+    virtual int acct_mgmt(pam_handle_t * handle, int flags) = 0;
+    virtual char const * strerror(pam_handle_t * handle, int errnum) = 0;
+};
+
+class MockPam: public IPam
+{
+public:
+    MockPam();
+    ~MockPam() override;
+
+    MOCK_METHOD4(start, int (
+        char const * service_name,
+        char const * user,
+        struct pam_conv const * conversation,
+        pam_handle_t * * handle));
+    
+    MOCK_METHOD2(end, int(pam_handle_t * handle, int status));
+    MOCK_METHOD2(authenticate, int(pam_handle_t * handle, int flags));
+    MOCK_METHOD2(acct_mgmt, int (pam_handle_t * handle, int flags));
+    MOCK_METHOD2(strerror, char const * (pam_handle_t * handle, int errnum));
+};
+
+}
+
+#endif

test/mock/server.cc

@@ -0,0 +1,25 @@
+#include "mock/server.hpp"
+#include "util/wrap.hpp"
+
+extern "C"
+{
+static webfused_test::IServer * wfd_MockServer = nullptr;
+
+WFD_WRAP_FUNC1(wfd_MockServer, struct wf_server *, wf_server_create, struct wf_server_config *);
+
+}
+
+namespace webfused_test
+{
+
+MockServer::MockServer()
+{
+    wfd_MockServer = this;
+}
+
+MockServer::~MockServer()
+{
+    wfd_MockServer = nullptr;
+}
+
+}

test/mock/server.hpp

@@ -0,0 +1,28 @@
+#ifndef WFD_MOCK_SERVER_HPP
+#define WFD_MOCK_SERVER_HPP
+
+#include <webfuse/adapter/server.h>
+#include <gmock/gmock.h>
+
+namespace webfused_test
+{
+
+class IServer
+{
+public:
+    virtual ~IServer() = default;
+    virtual struct wf_server * wf_server_create(struct wf_server_config * config) = 0;
+};
+
+class MockServer: public IServer
+{
+public:
+    MockServer();
+    ~MockServer() override;
+    MOCK_METHOD1(wf_server_create, struct wf_server * (struct wf_server_config * config));
+};
+
+
+}
+
+#endif

test/mock/settings.cc

@@ -0,0 +1,87 @@
+#include "mock/settings.hpp"
+
+extern "C"
+{
+using webfused_test::ISettings;
+
+static ISettings * wfd_mock_settings = nullptr;
+
+extern char const *
+__real_wfd_settings_get_string(
+    struct wfd_settings * settings,
+    char const * key);
+
+extern char const *
+__real_wfd_settings_get_string_or_default(
+    struct wfd_settings * settings,
+    char const * key,
+    char const * default_value);
+
+extern bool
+__real_wfd_settings_get_bool(
+    struct wfd_settings * settings,
+    char const * key);
+
+char const *
+__wrap_wfd_settings_get_string(
+    struct wfd_settings * settings,
+    char const * key)
+{
+    if (nullptr == wfd_mock_settings)
+    {
+        return __real_wfd_settings_get_string(settings, key);
+    }
+    else
+    {
+        return wfd_mock_settings->getString(key);
+    }
+}
+
+char const *
+__wrap_wfd_settings_get_string_or_default(
+    struct wfd_settings * settings,
+    char const * key,
+    char const * default_value)
+{
+    if (nullptr == wfd_mock_settings)
+    {
+        return __real_wfd_settings_get_string_or_default(
+            settings, key, default_value);
+    }
+    else
+    {
+        return wfd_mock_settings->getStringOrDefault(key, default_value);
+    }
+}
+
+bool
+__wrap_wfd_settings_get_bool(
+    struct wfd_settings * settings,
+    char const * key)
+{
+    if (nullptr == wfd_mock_settings)
+    {
+        return __real_wfd_settings_get_bool(settings, key);
+    }
+    else
+    {
+        return wfd_mock_settings->getBool(key);
+    }
+}
+
+}
+
+namespace webfused_test
+{
+
+MockSettings::MockSettings()
+{
+    wfd_mock_settings = this;
+}
+
+MockSettings::~MockSettings()
+{
+    wfd_mock_settings = nullptr;
+}
+
+}

test/mock/settings.hpp

@@ -0,0 +1,33 @@
+#ifndef WFD_MOCK_AUTH_SETTINGS_HPP
+#define WFD_MOCK_AUTH_SETTINGS_HPP
+
+#include <gmock/gmock.h>
+#include "webfused/config/settings.h"
+
+namespace webfused_test
+{
+
+class ISettings
+{
+public:
+    virtual ~ISettings() = default;
+    virtual char const * getString(char const * key) = 0;
+    virtual char const * getStringOrDefault(char const * key, char const * default_value) = 0;
+    virtual bool getBool(char const * key) = 0;
+};
+
+class MockSettings: public ISettings
+{
+public:
+    MockSettings();
+    ~MockSettings() override;
+    MOCK_METHOD1(getString, char const * (char const * key));
+    MOCK_METHOD2(getStringOrDefault, char const * (char const * key, char const * default_value));
+    MOCK_METHOD1(getBool, bool (char const * key));
+};
+
+}
+
+
+
+#endif