/* Copyright (c) 2007 Eric Scott Albright
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef __ENCHANTBROKERTESTFIXTURE
#define __ENCHANTBROKERTESTFIXTURE
#include "EnchantTestFixture.h"
#include "mock_provider.h"
#include <stack>
#include <stdio.h>
#include <gmodule.h>
#include <assert.h>
//////////////////////////////////////
// Mock provider functions
static void
MockProviderDispose(EnchantProvider *me)
{
g_free(me);
}
static int
MockEnGbAndQaaProviderDictionaryExists (EnchantProvider *,
const char *const tag)
{
return (strcmp(tag, "en_GB")==0 || strcmp(tag, "qaa") ==0);
}
static EnchantDict*
MockEnGbAndQaaProviderRequestDictionary(EnchantProvider * me, const char *tag)
{
EnchantDict *dict = NULL;
if(MockEnGbAndQaaProviderDictionaryExists(me, tag)){
dict = g_new0 (EnchantDict, 1);
}
return dict;
}
static void
MockProviderDisposeDictionary (EnchantProvider *, EnchantDict * dict)
{
g_free(dict);
}
static const char *
MockProviderIdentify (EnchantProvider *)
{
return "mock";
}
static const char *
MockProviderDescribe (EnchantProvider *)
{
return "Mock Provider";
}
static char **
MockEnGbAndQaaProviderListDictionaries (EnchantProvider *,
size_t * out_n_dicts)
{
*out_n_dicts = 2;
char** out_list = g_new0 (char *, *out_n_dicts + 1);
out_list[0] = g_strdup ("en_GB");
out_list[1] = g_strdup ("qaa");
return out_list;
}
static char **
MockEnGbProviderListDictionaries (EnchantProvider *,
size_t * out_n_dicts)
{
*out_n_dicts = 1;
char** out_list = g_new0 (char *, *out_n_dicts + 1);
out_list[0] = g_strdup ("en_GB");
return out_list;
}
typedef void (*SET_CONFIGURE)(ConfigureHook);
struct EnchantBrokerTestFixture : EnchantTestFixture
{
EnchantBroker* _broker;
GModule *hModule, *hModule2;
//Setup
EnchantBrokerTestFixture(ConfigureHook userConfiguration=NULL,
ConfigureHook user2Configuration=NULL,
bool includeNullProviders = false)
{
userMockProviderConfiguration = userConfiguration;
userMockProvider2Configuration = user2Configuration;
CopyProvider("enchant_mock_provider", "enchant_mock_provider");
hModule = g_module_open(LIBDIR_SUBDIR "/enchant-" ENCHANT_MAJOR_VERSION "/enchant_mock_provider", (GModuleFlags) 0);
if(hModule!=NULL){
SET_CONFIGURE sc;
assert(g_module_symbol(hModule, "set_configure", (gpointer *)&sc));
(sc)(ConfigureMockProvider);
}
hModule2 = NULL;
if(user2Configuration != NULL){
CopyProvider("enchant_mock_provider2", "enchant_mock_provider2");
hModule2 = g_module_open(LIBDIR_SUBDIR "/enchant-" ENCHANT_MAJOR_VERSION "/enchant_mock_provider2", (GModuleFlags) 0);
if(hModule2!=NULL){
SET_CONFIGURE sc;
assert(g_module_symbol(hModule2, "set_configure", (gpointer *)&sc));
(sc)(ConfigureMockProvider2);
}
}
if(includeNullProviders){
CopyProvider("enchant_null_provider", "null_provider");
CopyProvider("enchant_null_identify", "null_identify");
CopyProvider("enchant_null_describe", "null_describe");
CopyProvider("enchant-" ENCHANT_MAJOR_VERSION, "enchant-" ENCHANT_MAJOR_VERSION); //not a provider
}
InitializeBroker();
}
//Teardown
~EnchantBrokerTestFixture(){
if(hModule!=NULL){
g_module_close(hModule);
}
if(hModule2!=NULL){
g_module_close(hModule2);
}
if(_broker){
enchant_broker_free (_broker);
}
while(!pwlFilenames.empty())
{
DeleteFile(pwlFilenames.top());
pwlFilenames.pop();
}
}
void InitializeBroker()
{
_broker = enchant_broker_init ();
}
void CopyProvider(const std::string& sourceProviderName, const std::string& destinationProviderName)
{
std::string prefix =
// FIXME: Get this information from libtool
#if defined(__MSYS__)
"msys-"
#elif defined(__CYGWIN__)
"cyg"
#else
"lib"
#endif
;
std::string sourceName = prefix + sourceProviderName + "." + G_MODULE_SUFFIX;
std::string destinationName = destinationProviderName + "." + G_MODULE_SUFFIX;
std::string destinationDir = AddToPath(LIBDIR_SUBDIR, "enchant-" ENCHANT_MAJOR_VERSION);
CreateDirectory(destinationDir);
std::string destinationPath = AddToPath(destinationDir, destinationName);
gchar * contents;
gsize length;
if(g_file_get_contents(sourceName.c_str(), &contents, &length, NULL)){
g_file_set_contents(destinationPath.c_str(), contents, length, NULL);
g_free(contents);
}
}
EnchantProvider* GetMockProvider(){
return mock_provider;
}
void SetErrorOnMockProvider(const std::string& error)
{
EnchantProvider* provider = GetMockProvider();
if(provider != NULL)
{
enchant_provider_set_error(provider, error.c_str());
}
}
EnchantDict* RequestDictionary(const std::string& tag){
return enchant_broker_request_dict(_broker, tag.c_str());
}
EnchantDict* RequestPersonalDictionary()
{
std::string pwlFileName = GetTemporaryFilename("epwl");
CreateFile(pwlFileName);
pwlFilenames.push(pwlFileName);
return enchant_broker_request_pwl_dict(_broker, pwlFileName.c_str());
}
std::string GetLastPersonalDictionaryFileName()
{
return pwlFilenames.top();
}
void FreeDictionary(EnchantDict* dictionary){
if(dictionary != NULL){
enchant_broker_free_dict(_broker, dictionary);
}
}
private:
std::stack<std::string> pwlFilenames;
static EnchantProvider * mock_provider;
static ConfigureHook userMockProviderConfiguration;
static ConfigureHook userMockProvider2Configuration;
static void ConfigureMockProvider (EnchantProvider * me, const char * dir_name)
{
mock_provider = me;
if(userMockProviderConfiguration){
userMockProviderConfiguration(me, dir_name);
}
}
static void ConfigureMockProvider2 (EnchantProvider * me, const char * dir_name)
{
mock_provider = me;
if(userMockProvider2Configuration){
userMockProvider2Configuration(me, dir_name);
}
}
};
struct DictionaryDescription
{
std::string LanguageTag;
std::string Name;
std::string Description;
std::string DllFile;
DictionaryDescription()
{}
DictionaryDescription(const char* const language_tag,
const char * const provider_name,
const char * const provider_desc,
const char * const provider_file):
LanguageTag(language_tag),
Name(provider_name),
Description(provider_desc),
DllFile(provider_file)
{}
DictionaryDescription(const DictionaryDescription& d):
LanguageTag(d.LanguageTag),
Name(d.Name),
Description(d.Description),
DllFile(d.DllFile)
{}
bool DataIsComplete()
{
return (LanguageTag.length() &&
Name.length() &&
Description.length() &&
DllFile.length());
}
};
#endif