IntenseFinance/gnucash
3
0
Fork 0
mirror of https://github.com/Gnucash/gnucash.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

More work on testing.

Browse Source 
git-svn-id: svn+ssh://svn.gnucash.org/repo/gnucash/trunk@5184 57a11ea4-9604-0410-9ed3-97b8803252fd
This commit is contained in:
Dave Peticolas 2001-08-18 20:33:51 +00:00
parent 33d1726882
commit a37d3aab41
15 changed files with 454 additions and 1080 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
src/backend/file/test/Makefile.am
View File

@ -1,7 +1,15 @@
TESTS = test-load-module test-dom-converters1 test-kvp-frames \
test-string-converters test-xml-account test-xml2-is-file \
test-load-xml2 test-load-example-account \
test-xml-commodity test-xml-transaction test-real-data.sh
TESTS = \
test-dom-converters1 \
test-kvp-frames \
test-load-example-account \
test-load-module \
test-load-xml2 \
test-real-data.sh \
test-string-converters \
test-xml-account \
test-xml-commodity \
test-xml-transaction \
test-xml2-is-file
TESTS_ENVIRONMENT = \
GNC_MODULE_PATH="${top_srcdir}/src/engine:${top_srcdir}/src/gnc-module:${top_srcdir}/src/backend/file" \
@ -9,39 +17,35 @@ TESTS_ENVIRONMENT = \
LTDL_LIBRARY_PATH=${top_srcdir}/src/gnc-module:${top_srcdir}/src/engine:${top_srcdir}/src/backend/file \
LD_LIBRARY_PATH=${top_srcdir}/src/gnc-module:${top_srcdir}/src/engine:${top_srcdir}/src/backend/file:${top_srcdir}/src/gnc-module/.libs:${top_srcdir}/src/engine/.libs:${top_srcdir}/src/backend/file/.libs
noinst_PROGRAMS = test-dom-converters1 test-kvp-frames \
test-string-converters test-xml-account test-xml2-is-file \
test-load-xml2 test-load-example-account \
test-xml-commodity test-xml-transaction test-save-in-lang
noinst_LTLIBRARIES = libgnc-test-file-stuff.la
LDADD = -L../../../engine -L../../../engine/.libs \
-L../../../gnc-module -L../../../gnc-module/.libs \
-L.. -L../.libs \
-lgncmodule \
libgnc_test_file_stuff_la_SOURCES = test-file-stuff.c
noinst_PROGRAMS = \
test-dom-converters1 \
test-kvp-frames \
test-load-example-account \
test-load-xml2 \
test-save-in-lang \
test-string-converters \
test-xml-account \
test-xml-commodity \
test-xml-transaction \
test-xml2-is-file
LDADD = -L${top_srcdir}/src/gnc-module -L${top_srcdir}/src/gnc-module/.libs \
-L${top_srcdir}/src/engine -L${top_srcdir}/src/engine/.libs \
${top_srcdir}/src/test-core/libgncmod-test.la \
-lgncmod-engine \
-lgncmod-backend-file
${top_srcdir}/src/gnc-module/libgncmodule.la \
${top_srcdir}/src/engine/libgncmod-engine.la \
${top_srcdir}/src/engine/test-core/libgncmod-test-engine.la \
../libgncmod-backend-file.la \
./libgnc-test-file-stuff.la
CFLAGS = ${GLIB_CFLAGS}
INCLUDES = -I${top_srcdir}/src/test-core -I../../../engine -I ../
test_kvp_frames_SOURCES = test-kvp-frames.c gnc-test-stuff.c
test_load_example_account_SOURCES = test-load-example-account.c gnc-test-stuff.c
test_dom_converters1_SOURCES = test-dom-converters1.c gnc-test-stuff.c
test_string_converters_SOURCES = test-string-converters.c gnc-test-stuff.c
test_xml_account_SOURCES = test-xml-account.c gnc-test-stuff.c
test_xml_commodity_SOURCES = test-xml-commodity.c gnc-test-stuff.c
test_xml_transaction_SOURCES = test-xml-transaction.c gnc-test-stuff.c
test_xml2_is_file_SOURCES = test-xml2-is-file.c gnc-test-stuff.c
test_load_xml2_SOURCES = test-load-xml2.c gnc-test-stuff.c
test_save_in_lang_SOURCES = test-save-in-lang.c gnc-test-stuff.c
INCLUDES = \
-I${top_srcdir}/src/test-core \
-I${top_srcdir}/src/engine \
-I${top_srcdir}/src/engine/test-core \
-I..

981
src/backend/file/test/gnc-test-stuff.c
View File

@ -1,981 +0,0 @@
#include "config.h"
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "gnc-engine-util.h"
#include "gnc-test-stuff.h"
#include "sixtp-dom-parsers.h"
#include "sixtp-parsers.h"
#include "test-stuff.h"
#include "io-gncxml-gen.h"
#include "sixtp-utils.h"
/***********************************************************************/
static int
files_return(int ret, const char* msg)
{
printf(msg);
return ret;
}
int
files_compare(const gchar* f1, const gchar* f2)
{
gchar buf1[512];
gchar buf2[512];
int fd1, fd2;
int amount_read1, amount_read2;
fd1 = open(f1, O_RDONLY);
fd2 = open(f2, O_RDONLY);
do
{
int memcmp_ret;
amount_read1 = read(fd1, buf1, 512);
amount_read2 = read(fd2, buf2, 512);
if(amount_read1 > amount_read2)
return files_return(1, "read1 > read2");
if(amount_read1 < amount_read2)
return files_return(-1, "read1 < read2");
if((memcmp_ret = memcmp(buf1, buf2, amount_read1)) != 0)
{
return files_return(memcmp_ret, "memcmp return");
}
} while(amount_read1 == 512);
return 0;
}
void
write_dom_node_to_file(xmlNodePtr node, int fd)
{
FILE *out;
out = fdopen(fd, "w");
xmlElemDump(out, NULL, node);
fclose(out);
}
gboolean
print_dom_tree(gpointer data_for_children, GSList* data_from_children,
GSList* sibling_data, gpointer parent_data,
gpointer global_data, gpointer *result, const gchar *tag)
{
if (parent_data == NULL)
{
xmlElemDump((FILE*)global_data, NULL, (xmlNodePtr)data_for_children);
xmlFreeNode(data_for_children);
}
return TRUE;
}
/***********************************************************************/
Timespec*
get_random_timespec(void)
{
Timespec *ret;
ret = g_new(Timespec, 1);
ret->tv_sec = rand();
ret->tv_nsec = rand();
return ret;
}
gnc_numeric
get_random_gnc_numeric(void)
{
return gnc_numeric_create(get_random_gint64(), rand());
}
const char *types[] =
{
"NASDAQ",
"NYSE",
"EUREX",
"FUND",
"AMEX",
NULL
};
const char*
get_random_commodity_namespace(void)
{
return get_random_string_in_array(types);
}
gnc_commodity*
get_random_gnc_commodity_ref(void)
{
const gchar *name;
gchar *mnemonic;
gnc_commodity *ret;
name = get_random_commodity_namespace();
mnemonic = get_random_string();
if(!name || !mnemonic)
{
return NULL;
}
ret = gnc_commodity_new("", name, mnemonic, "", 0);
g_free(mnemonic);
return ret;
}
GNCPrice *
get_random_price(void)
{
GNCPrice *p;
Timespec *ts;
char *string;
p = gnc_price_create ();
gnc_price_set_commodity (p, get_random_gnc_commodity_ref ());
gnc_price_set_currency (p, get_random_gnc_commodity_ref ());
ts = get_random_timespec ();
gnc_price_set_time (p, *ts);
g_free (ts);
string = get_random_string ();
gnc_price_set_source (p, string);
g_free (string);
string = get_random_string ();
gnc_price_set_type (p, string);
g_free (string);
gnc_price_set_value (p, get_random_gnc_numeric ());
return p;
}
GUID*
get_random_guid(void)
{
GUID *ret;
ret = g_new(GUID, 1);
guid_new(ret);
return ret;
}
GList*
get_random_glist(void)
{
GList *ret = NULL;
int i;
int count = get_random_int_in_range(1, 5);
for(i = 0; i < count; i++)
{
ret = g_list_prepend(ret, (gpointer)get_random_kvp_value(-2));
}
return ret;
}
bin_data*
get_random_binary_data(void)
{
int len;
bin_data *ret;
len = get_random_int_in_range(20,100);
ret = g_new(bin_data, 1);
ret->data = g_new(char, len);
ret->len = len;
for(len--; len >= 0; len--)
{
ret->data[len] = (char)get_random_int_in_range(0,255);
}
return ret;
}
kvp_frame*
get_random_kvp_frame(void)
{
kvp_frame *ret;
int vals_to_add;
ret = kvp_frame_new();
vals_to_add = get_random_int_in_range(1,10);
for(;vals_to_add > 0; vals_to_add--)
{
gchar *key;
kvp_value *val;
key = get_random_string();
val = get_random_kvp_value(-1);
if(!key)
{
return NULL;
}
kvp_frame_set_slot_nc(ret, key, val);
g_free(key);
}
return ret;
}
kvp_value*
get_random_kvp_value(int type)
{
int datype = type;
if(datype == -1)
{
datype = get_random_int_in_range(KVP_TYPE_GINT64, KVP_TYPE_FRAME + 1);
}
if(datype == -2)
{
datype = get_random_int_in_range(KVP_TYPE_GINT64, KVP_TYPE_FRAME);
}
switch(datype)
{
case KVP_TYPE_GINT64:
return kvp_value_new_gint64(get_random_gint64());
break;
case KVP_TYPE_DOUBLE:
return kvp_value_new_double(get_random_double());
break;
case KVP_TYPE_NUMERIC:
return kvp_value_new_gnc_numeric(get_random_gnc_numeric());
break;
case KVP_TYPE_STRING:
{
gchar *tmp_str;
kvp_value *ret;
tmp_str = get_random_string();
if(!tmp_str)
{
return NULL;
}
ret = kvp_value_new_string(tmp_str);
g_free(tmp_str);
return ret;
}
break;
case KVP_TYPE_GUID:
{
GUID *tmp_guid;
kvp_value *ret;
tmp_guid = get_random_guid();
ret = kvp_value_new_guid(tmp_guid);
g_free(tmp_guid);
return ret;
}
break;
case KVP_TYPE_BINARY:
{
bin_data *tmp_data;
kvp_value *ret;
tmp_data = get_random_binary_data();
ret = kvp_value_new_binary(tmp_data->data, tmp_data->len);
g_free(tmp_data->data);
g_free(tmp_data);
return ret;
}
break;
case KVP_TYPE_GLIST:
return kvp_value_new_glist_nc(get_random_glist());
break;
case KVP_TYPE_FRAME:
{
kvp_frame *tmp_frame;
kvp_value *ret;
tmp_frame = get_random_kvp_frame();
ret = kvp_value_new_frame(tmp_frame);
kvp_frame_delete(tmp_frame);
return ret;
}
break;
default:
return NULL;
break;
}
}
static void
set_account_random_string(Account* act,
void(*func)(Account *act, const gchar*str))
{
gchar *tmp_str = get_random_string();
if(tmp_str)
{
(func)(act, tmp_str);
g_free(tmp_str);
}
}
Account*
get_random_account(void)
{
Account *ret;
int tmp_int;
ret = xaccMallocAccount();
xaccAccountBeginEdit(ret);
set_account_random_string(ret, xaccAccountSetName);
tmp_int = get_random_int_in_range(BANK, CREDITLINE);
xaccAccountSetType(ret, tmp_int);
set_account_random_string(ret, xaccAccountSetCode);
set_account_random_string(ret, xaccAccountSetDescription);
xaccAccountSetCommodity(ret, get_random_gnc_commodity_ref());
xaccAccountSetSlots_nc(ret, get_random_kvp_frame());
xaccAccountCommitEdit(ret);
return ret;
}
static void
set_split_random_string(Split *spl,
void(*func)(Split *act, const gchar*str))
{
gchar *tmp_str = get_random_string();
if(tmp_str)
{
(func)(spl, tmp_str);
g_free(tmp_str);
}
}
static char possible_chars[] = { 'c', 'y', 'f', 'n' };
Split*
get_random_split(gnc_numeric num)
{
Split *ret;
gnc_numeric oneVal;
ret = xaccMallocSplit();
set_split_random_string(ret, xaccSplitSetMemo);
set_split_random_string(ret, xaccSplitSetAction);
xaccSplitSetReconcile(ret, possible_chars[get_random_int_in_range(0, 4)]);
xaccSplitSetDateReconciledTS(ret, get_random_timespec());
xaccSplitSetValue(ret, num);
xaccSplitSetAmount(ret, num);
oneVal = gnc_numeric_create(1,1);
xaccSplitSetSharePrice(ret, oneVal);
xaccSplitSetSlots_nc(ret, get_random_kvp_frame());
{
GUID *ranguid = get_random_guid();
xaccSplitSetAccountGUID(ret, *ranguid);
g_free(ranguid);
}
return ret;
}
static void
set_tran_random_string(Transaction* trn,
void(*func)(Transaction *act, const gchar*str))
{
gchar *tmp_str = get_random_string();
if(tmp_str)
{
(func)(trn, tmp_str);
g_free(tmp_str);
}
}
static void
add_random_splits(Transaction *trn)
{
gnc_numeric num = get_random_gnc_numeric();
xaccTransAppendSplit(trn, get_random_split(num));
xaccTransAppendSplit(trn, get_random_split(gnc_numeric_neg(num)));
}
static void
trn_add_ran_timespec(Transaction *trn, void (*func)(Transaction*,
const Timespec*))
{
Timespec *to_set;
to_set = get_random_timespec();
func(trn, to_set);
g_free(to_set);
}
Transaction*
get_random_transaction(void)
{
Transaction* ret;
ret = xaccMallocTransaction();
xaccTransBeginEdit(ret);
xaccTransSetCurrency(ret, get_random_gnc_commodity_ref());
set_tran_random_string(ret, xaccTransSetNum);
trn_add_ran_timespec(ret, xaccTransSetDatePostedTS);
trn_add_ran_timespec(ret, xaccTransSetDateEnteredTS);
set_tran_random_string(ret, xaccTransSetDescription);
xaccTransSetSlots_nc(ret, get_random_kvp_frame());
add_random_splits(ret);
xaccTransCommitEdit(ret);
return ret;
}
gnc_commodity*
get_random_commodity(void)
{
gnc_commodity *ret;
gchar *name;
const gchar *space;
gchar *mn;
gchar *xcode;
int ran_int;
name = get_random_string();
space = get_random_commodity_namespace();
mn = get_random_string();
xcode = get_random_string();
ran_int = get_random_int_in_range(1, 100000);
ret = gnc_commodity_new(name, space, mn, xcode, ran_int);
g_free(name);
g_free(mn);
g_free(xcode);
return ret;
}
static GList *
get_random_guids(int max)
{
GList *guids = NULL;
int num_guids;
if (max < 1) return NULL;
num_guids = get_random_int_in_range (1, max);
while (num_guids-- > 0)
g_list_prepend (guids, get_random_guid ());
return guids;
}
static void
free_random_guids(GList *guids)
{
GList *node;
for (node = guids; node; node = node->next)
g_free (node->data);
g_list_free (guids);
}
static QueryOp
get_random_queryop(void)
{
return get_random_int_in_range (1, QUERY_XOR);
}
Query *
get_random_query(void)
{
Query *q;
Query *temp_q;
int num_terms;
num_terms = get_random_int_in_range (1, 4);
q = xaccMallocQuery ();
while (num_terms-- > 0)
{
pr_type_t pr_type;
Timespec *start;
Timespec *end;
GList *guids;
char *string;
GUID *guid;
pr_type = get_random_int_in_range (1, 20);
switch (pr_type)
{
case PR_ACCOUNT:
guids = get_random_guids (10);
xaccQueryAddAccountGUIDMatch
(q,
guids,
get_random_int_in_range (1, ACCT_MATCH_NONE),
get_random_queryop ());
free_random_guids (guids);
break;
case PR_ACTION:
string = get_random_string ();
xaccQueryAddActionMatch (q,
string,
get_random_boolean (),
get_random_boolean (),
get_random_queryop ());
g_free (string);
break;
case PR_AMOUNT:
DxaccQueryAddAmountMatch
(q,
get_random_double (),
get_random_int_in_range (1, AMT_SGN_MATCH_DEBIT),
get_random_int_in_range (1, AMT_MATCH_EXACTLY),
get_random_queryop ());
break;
case PR_BALANCE:
xaccQueryAddBalanceMatch
(q,
get_random_int_in_range (1, BALANCE_UNBALANCED),
get_random_queryop ());
break;
case PR_CLEARED:
xaccQueryAddClearedMatch
(q,
get_random_int_in_range (1, CLEARED_FROZEN),
get_random_queryop ());
break;
case PR_DATE:
start = get_random_timespec ();
end = get_random_timespec ();
xaccQueryAddDateMatchTS (q,
get_random_boolean (),
*start,
get_random_boolean (),
*end,
get_random_queryop ());
g_free (start);
g_free (end);
break;
case PR_DESC:
string = get_random_string ();
xaccQueryAddDescriptionMatch (q,
string,
get_random_boolean (),
get_random_boolean (),
get_random_queryop ());
g_free (string);
break;
case PR_GUID:
guid = get_random_guid ();
xaccQueryAddGUIDMatch (q, guid, get_random_queryop ());
g_free (guid);
break;
case PR_MEMO:
string = get_random_string ();
xaccQueryAddMemoMatch (q,
string,
get_random_boolean (),
get_random_boolean (),
get_random_queryop ());
g_free (string);
break;
case PR_NUM:
string = get_random_string ();
xaccQueryAddNumberMatch (q,
string,
get_random_boolean (),
get_random_boolean (),
get_random_queryop ());
g_free (string);
break;
case PR_PRICE:
DxaccQueryAddSharePriceMatch
(q,
get_random_double (),
get_random_int_in_range (1, AMT_MATCH_EXACTLY),
get_random_queryop ());
break;
case PR_SHRS:
DxaccQueryAddSharesMatch
(q,
get_random_double (),
get_random_int_in_range (1, AMT_MATCH_EXACTLY),
get_random_queryop ());
break;
case PR_MISC: /* PR_MISC shouldn't be used anyway :) */
default:
num_terms++;
break;
}
}
xaccQuerySetSortOrder (q,
get_random_int_in_range (1, BY_NONE),
get_random_int_in_range (1, BY_NONE),
get_random_int_in_range (1, BY_NONE));
xaccQuerySetSortIncreasing (q,
get_random_boolean (),
get_random_boolean (),
get_random_boolean ());
xaccQuerySetMaxSplits (q, get_random_int_in_range (-50000, 50000));
return q;
}
/***********************************************************************/
gboolean
check_dom_tree_version(xmlNodePtr node, gchar *verstr)
{
char *verteststr;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(verstr, FALSE);
g_return_val_if_fail(node->properties, FALSE);
g_return_val_if_fail(node->properties->xmlAttrPropertyValue, FALSE);
g_return_val_if_fail(node->properties->xmlAttrPropertyValue->content,
FALSE);
verteststr = node->properties->xmlAttrPropertyValue->content;
if(safe_strcmp(verstr, verteststr) == 0)
{
return TRUE;
}
else
{
return FALSE;
}
}
gboolean
equals_node_val_vs_string(xmlNodePtr node, const gchar* str)
{
gchar *cmp1;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(str, FALSE);
cmp1 = dom_tree_to_text(node);
if(!cmp1)
{
return FALSE;
}
else if(safe_strcmp(cmp1, str) == 0)
{
g_free(cmp1);
return TRUE;
}
else
{
printf("Differing types: node:`%s' vs string:`%s'\n", cmp1, str);
g_free(cmp1);
return FALSE;
}
}
gboolean
equals_node_val_vs_int(xmlNodePtr node, gint64 val)
{
gchar *text;
gint64 test_val;
g_return_val_if_fail(node, FALSE);
text = dom_tree_to_text(node);
if(!string_to_gint64(text, &test_val))
{
g_free(text);
return FALSE;
}
g_free(text);
return val == test_val;
}
gboolean
equals_node_val_vs_guid(xmlNodePtr node, const GUID *id)
{
GUID *cmpid;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(id, FALSE);
cmpid = dom_tree_to_guid(node);
g_return_val_if_fail(cmpid, FALSE);
if(guid_compare(cmpid, id) == 0)
{
g_free(cmpid);
return TRUE;
}
else
{
g_free(cmpid);
return FALSE;
}
}
gboolean
equals_node_val_vs_commodity(xmlNodePtr node, const gnc_commodity *com)
{
gnc_commodity *cmpcom;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(com, FALSE);
cmpcom = dom_tree_to_commodity_ref_no_engine(node);
g_return_val_if_fail(cmpcom, FALSE);
if(gnc_commodity_equiv(com, cmpcom))
{
gnc_commodity_destroy(cmpcom);
return TRUE;
}
else
{
gnc_commodity_destroy(cmpcom);
return TRUE;
}
}
gboolean
equals_node_val_vs_kvp_frame(xmlNodePtr node, const kvp_frame *frm)
{
kvp_frame *cmpfrm;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(frm, FALSE);
cmpfrm = dom_tree_to_kvp_frame(node);
g_return_val_if_fail(cmpfrm, FALSE);
if(kvp_frame_compare(frm, cmpfrm) == 0)
{
kvp_frame_delete(cmpfrm);
return TRUE;
}
else
{
gchar *frm1str;
gchar *frm2str;
frm1str = kvp_frame_to_string(frm);
frm2str = kvp_frame_to_string(cmpfrm);
printf("%s vs %s\n", frm1str, frm2str);
g_free(frm1str);
g_free(frm2str);
kvp_frame_delete(cmpfrm);
return FALSE;
}
}
gboolean
equals_node_val_vs_date(xmlNodePtr node, const Timespec tm)
{
Timespec *tm_test = dom_tree_to_timespec(node);
if(tm_test->tv_sec == tm.tv_sec && tm_test->tv_nsec == tm.tv_nsec)
{
return TRUE;
}
else
{
return TRUE;
}
}
/***********************************************************************/
static gboolean
just_dom_tree_end_handler(gpointer data_for_children,
GSList* data_from_children, GSList* sibling_data,
gpointer parent_data, gpointer global_data,
gpointer *result, const gchar *tag)
{
Transaction *trn = NULL;
gboolean successful = FALSE;
xmlNodePtr achild;
xmlNodePtr tree = (xmlNodePtr)data_for_children;
xmlNodePtr *globaldata = (xmlNodePtr*)global_data;
if(parent_data)
{
return TRUE;
}
/* OK. For some messed up reason this is getting called again with a
NULL tag. So we ignore those cases */
if(!tag)
{
return TRUE;
}
g_return_val_if_fail(tree, FALSE);
*globaldata = tree;
return TRUE;
}
static xmlNodePtr
grab_file_doc(const char *filename)
{
sixtp *parser;
xmlNodePtr ret;
gpointer parse_result = NULL;
parser = sixtp_dom_parser_new(just_dom_tree_end_handler, NULL, NULL);
sixtp_parse_file(parser, filename, NULL, &ret, &parse_result);
return ret;
}
static void
test_load_file(const char *filename, gxpf_callback cb,
sixtp *parser, const char *parser_tag)
{
xmlNodePtr node;
sixtp *main_parser;
sixtp *top_parser;
node = grab_file_doc(filename);
if(!node)
{
failure_args("failure of libxml to parse file", __FILE__, __LINE__,
"%s", filename);
return;
}
top_parser = sixtp_new();
main_parser = sixtp_new();
if(!sixtp_add_some_sub_parsers(
top_parser, TRUE,
"gnc-v2", main_parser,
NULL, NULL))
{
return;
}
if(!sixtp_add_some_sub_parsers(
main_parser, TRUE,
parser_tag, parser,
NULL, NULL))
{
return;
}
if(!gnc_xml_parse_file(top_parser, filename, cb, (gpointer)(node->childs)))
{
failure_args("failure to parse file", __FILE__, __LINE__,
"%s", filename);
}
xmlFreeNode(node);
}
void
test_files_in_dir(int argc, char **argv, gxpf_callback cb,
sixtp *parser, const char *parser_tag)
{
int count;
for(count = 1; count < argc; count++)
{
struct stat file_info;
const char *to_open = argv[count];
if(stat(to_open, &file_info) != 0)
{
failure("unable to stat file");
}
else
{
if(!S_ISDIR(file_info.st_mode))
{
test_load_file(to_open, cb, parser, parser_tag);
}
}
}
}

4
src/backend/file/test/test-dom-converters1.c
View File

@ -5,7 +5,9 @@
#include <glib.h>
#include "gnc-test-stuff.h"
#include "test-stuff.h"
#include "test-engine-stuff.h"
#include "test-file-stuff.h"
#include "gnc-xml-helper.h"
#include "gnc-engine-util.h"

371
src/backend/file/test/test-file-stuff.c Normal file
View File

@ -0,0 +1,371 @@
#include "config.h"
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "gnc-engine-util.h"
#include "sixtp-dom-parsers.h"
#include "sixtp-parsers.h"
#include "test-file-stuff.h"
#include "test-stuff.h"
#include "io-gncxml-gen.h"
#include "sixtp-utils.h"
/***********************************************************************/
static int
files_return(int ret, const char* msg)
{
printf(msg);
return ret;
}
int
files_compare(const gchar* f1, const gchar* f2)
{
gchar buf1[512];
gchar buf2[512];
int fd1, fd2;
int amount_read1, amount_read2;
fd1 = open(f1, O_RDONLY);
fd2 = open(f2, O_RDONLY);
do
{
int memcmp_ret;
amount_read1 = read(fd1, buf1, 512);
amount_read2 = read(fd2, buf2, 512);
if(amount_read1 > amount_read2)
return files_return(1, "read1 > read2");
if(amount_read1 < amount_read2)
return files_return(-1, "read1 < read2");
if((memcmp_ret = memcmp(buf1, buf2, amount_read1)) != 0)
{
return files_return(memcmp_ret, "memcmp return");
}
} while(amount_read1 == 512);
return 0;
}
void
write_dom_node_to_file(xmlNodePtr node, int fd)
{
FILE *out;
out = fdopen(fd, "w");
xmlElemDump(out, NULL, node);
fclose(out);
}
gboolean
print_dom_tree(gpointer data_for_children, GSList* data_from_children,
GSList* sibling_data, gpointer parent_data,
gpointer global_data, gpointer *result, const gchar *tag)
{
if (parent_data == NULL)
{
xmlElemDump((FILE*)global_data, NULL, (xmlNodePtr)data_for_children);
xmlFreeNode(data_for_children);
}
return TRUE;
}
gboolean
check_dom_tree_version(xmlNodePtr node, gchar *verstr)
{
char *verteststr;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(verstr, FALSE);
g_return_val_if_fail(node->properties, FALSE);
g_return_val_if_fail(node->properties->xmlAttrPropertyValue, FALSE);
g_return_val_if_fail(node->properties->xmlAttrPropertyValue->content,
FALSE);
verteststr = node->properties->xmlAttrPropertyValue->content;
if(safe_strcmp(verstr, verteststr) == 0)
{
return TRUE;
}
else
{
return FALSE;
}
}
gboolean
equals_node_val_vs_string(xmlNodePtr node, const gchar* str)
{
gchar *cmp1;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(str, FALSE);
cmp1 = dom_tree_to_text(node);
if(!cmp1)
{
return FALSE;
}
else if(safe_strcmp(cmp1, str) == 0)
{
g_free(cmp1);
return TRUE;
}
else
{
printf("Differing types: node:`%s' vs string:`%s'\n", cmp1, str);
g_free(cmp1);
return FALSE;
}
}
gboolean
equals_node_val_vs_int(xmlNodePtr node, gint64 val)
{
gchar *text;
gint64 test_val;
g_return_val_if_fail(node, FALSE);
text = dom_tree_to_text(node);
if(!string_to_gint64(text, &test_val))
{
g_free(text);
return FALSE;
}
g_free(text);
return val == test_val;
}
gboolean
equals_node_val_vs_guid(xmlNodePtr node, const GUID *id)
{
GUID *cmpid;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(id, FALSE);
cmpid = dom_tree_to_guid(node);
g_return_val_if_fail(cmpid, FALSE);
if(guid_compare(cmpid, id) == 0)
{
g_free(cmpid);
return TRUE;
}
else
{
g_free(cmpid);
return FALSE;
}
}
gboolean
equals_node_val_vs_commodity(xmlNodePtr node, const gnc_commodity *com)
{
gnc_commodity *cmpcom;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(com, FALSE);
cmpcom = dom_tree_to_commodity_ref_no_engine(node);
g_return_val_if_fail(cmpcom, FALSE);
if(gnc_commodity_equiv(com, cmpcom))
{
gnc_commodity_destroy(cmpcom);
return TRUE;
}
else
{
gnc_commodity_destroy(cmpcom);
return TRUE;
}
}
gboolean
equals_node_val_vs_kvp_frame(xmlNodePtr node, const kvp_frame *frm)
{
kvp_frame *cmpfrm;
g_return_val_if_fail(node, FALSE);
g_return_val_if_fail(frm, FALSE);
cmpfrm = dom_tree_to_kvp_frame(node);
g_return_val_if_fail(cmpfrm, FALSE);
if(kvp_frame_compare(frm, cmpfrm) == 0)
{
kvp_frame_delete(cmpfrm);
return TRUE;
}
else
{
gchar *frm1str;
gchar *frm2str;
frm1str = kvp_frame_to_string(frm);
frm2str = kvp_frame_to_string(cmpfrm);
printf("%s vs %s\n", frm1str, frm2str);
g_free(frm1str);
g_free(frm2str);
kvp_frame_delete(cmpfrm);
return FALSE;
}
}
gboolean
equals_node_val_vs_date(xmlNodePtr node, const Timespec tm)
{
Timespec *tm_test = dom_tree_to_timespec(node);
if(tm_test->tv_sec == tm.tv_sec && tm_test->tv_nsec == tm.tv_nsec)
{
return TRUE;
}
else
{
return TRUE;
}
}
/***********************************************************************/
static gboolean
just_dom_tree_end_handler(gpointer data_for_children,
GSList* data_from_children, GSList* sibling_data,
gpointer parent_data, gpointer global_data,
gpointer *result, const gchar *tag)
{
Transaction *trn = NULL;
gboolean successful = FALSE;
xmlNodePtr achild;
xmlNodePtr tree = (xmlNodePtr)data_for_children;
xmlNodePtr *globaldata = (xmlNodePtr*)global_data;
if(parent_data)
{
return TRUE;
}
/* OK. For some messed up reason this is getting called again with a
NULL tag. So we ignore those cases */
if(!tag)
{
return TRUE;
}
g_return_val_if_fail(tree, FALSE);
*globaldata = tree;
return TRUE;
}
static xmlNodePtr
grab_file_doc(const char *filename)
{
sixtp *parser;
xmlNodePtr ret;
gpointer parse_result = NULL;
parser = sixtp_dom_parser_new(just_dom_tree_end_handler, NULL, NULL);
sixtp_parse_file(parser, filename, NULL, &ret, &parse_result);
return ret;
}
static void
test_load_file(const char *filename, gxpf_callback cb,
sixtp *parser, const char *parser_tag)
{
xmlNodePtr node;
sixtp *main_parser;
sixtp *top_parser;
node = grab_file_doc(filename);
if(!node)
{
failure_args("failure of libxml to parse file", __FILE__, __LINE__,
"%s", filename);
return;
}
top_parser = sixtp_new();
main_parser = sixtp_new();
if(!sixtp_add_some_sub_parsers(
top_parser, TRUE,
"gnc-v2", main_parser,
NULL, NULL))
{
return;
}
if(!sixtp_add_some_sub_parsers(
main_parser, TRUE,
parser_tag, parser,
NULL, NULL))
{
return;
}
if(!gnc_xml_parse_file(top_parser, filename, cb, (gpointer)(node->childs)))
{
failure_args("failure to parse file", __FILE__, __LINE__,
"%s", filename);
}
xmlFreeNode(node);
}
void
test_files_in_dir(int argc, char **argv, gxpf_callback cb,
sixtp *parser, const char *parser_tag)
{
int count;
for(count = 1; count < argc; count++)
{
struct stat file_info;
const char *to_open = argv[count];
if(stat(to_open, &file_info) != 0)
{
failure("unable to stat file");
}
else
{
if(!S_ISDIR(file_info.st_mode))
{
test_load_file(to_open, cb, parser, parser_tag);
}
}
}
}

53
src/backend/file/test/gnc-test-stuff.h → src/backend/file/test/test-file-stuff.h
View File

@ -1,61 +1,24 @@
/* Created by bstanley 20010323
* moved contents from test-stuff.h
*
* This file declares testing functions which rely on other parts
* of gnucash.
/* This file declares testing functions for xml files.
*
*/
#ifndef GNC_TEST_STUFF_H
#define GNC_TEST_STUFF_H
#ifndef TEST_FILE_STUFF_H
#define TEST_FILE_STUFF_H
#include "config.h"
#include <glib.h>
#include <stdlib.h>
#include "test-stuff.h"
#include "date.h"
#include "gnc-commodity.h"
#include "gnc-xml-helper.h"
#include "guid.h"
#include "io-gncxml-gen.h"
#include "kvp_frame.h"
#include "sixtp.h"
#include "gnc-commodity.h"
#include "gnc-pricedb.h"
#include "guid.h"
#include "kvp_frame.h"
#include "date.h"
#include "Account.h"
#include "Query.h"
Timespec* get_random_timespec(void);
kvp_value* get_random_kvp_value(int type);
struct _bin_data
{
guchar *data;
int len;
};
typedef struct _bin_data bin_data;
bin_data* get_random_binary_data(void);
kvp_frame* get_random_kvp_frame(void);
gnc_numeric get_random_gnc_numeric(void);
gnc_commodity* get_random_gnc_commodity_ref(void);
GUID* get_random_guid(void);
GList* get_random_glist(void);
GNCPrice * get_random_price(void);
Account* get_random_account(void);
Split* get_random_split(gnc_numeric num);
Transaction* get_random_transaction(void);
gnc_commodity* get_random_commodity(void);
const char *get_random_commodity_namespace(void);
Query* get_random_query(void);
/**/
void write_dom_node_to_file(xmlNodePtr node, int fd);
int files_compare(const gchar* f1, const gchar* f2);
@ -79,4 +42,4 @@ void
test_files_in_dir(int argc, char **argv, gxpf_callback cb,
sixtp *parser, const char *parser_tag);
#endif /* GNC_TEST_STUFF_H */
#endif

4
src/backend/file/test/test-kvp-frames.c
View File

@ -2,7 +2,9 @@
#include <stdlib.h>
#include "gnc-test-stuff.h"
#include "test-stuff.h"
#include "test-engine-stuff.h"
#include "test-file-stuff.h"
#include "kvp_frame.h"

4
src/backend/file/test/test-load-example-account.c
View File

@ -14,7 +14,9 @@
#include "io-example-account.h"
#include "gnc-test-stuff.h"
#include "test-stuff.h"
#include "test-engine-stuff.h"
#include "test-file-stuff.h"
static const gchar *da_ending = ".gnucash-xea";

4
src/backend/file/test/test-load-xml2.c
View File

@ -15,7 +15,9 @@
#include "Backend.h"
#include "TransLog.h"
#include "gnc-test-stuff.h"
#include "test-stuff.h"
#include "test-engine-stuff.h"
#include "test-file-stuff.h"
static void
remove_files_pattern(const char *begining, const char *ending)

4
src/backend/file/test/test-save-in-lang.c
View File

@ -7,8 +7,10 @@
#include <stdlib.h>
#include <string.h>
#include "gnc-test-stuff.h"
#include "test-stuff.h"
#include "test-engine-stuff.h"
#include "test-file-stuff.h"
#include "gnc-book.h"
#include "gnc-engine.h"
#include "TransLog.h"

4
src/backend/file/test/test-string-converters.c
View File

@ -7,7 +7,9 @@
#include "gnc-engine-util.h"
#include "gnc-test-stuff.h"
#include "test-stuff.h"
#include "test-engine-stuff.h"
#include "test-file-stuff.h"
#include "guid.h"
#include "date.h"

4
src/backend/file/test/test-xml-account.c
View File

@ -13,7 +13,9 @@
#include "sixtp-parsers.h"
#include "sixtp-dom-parsers.h"
#include "gnc-test-stuff.h"
#include "test-stuff.h"
#include "test-engine-stuff.h"
#include "test-file-stuff.h"
#include "Account.h"
#include "GNCIdP.h"

4
src/backend/file/test/test-xml-commodity.c
View File

@ -16,7 +16,9 @@
#include "io-gncxml-gen.h"
#include "gnc-test-stuff.h"
#include "test-stuff.h"
#include "test-engine-stuff.h"
#include "test-file-stuff.h"
#include "Account.h"

4
src/backend/file/test/test-xml-transaction.c
View File

@ -19,7 +19,9 @@
#include "TransLog.h"
#include "io-gncxml-gen.h"
#include "gnc-test-stuff.h"
#include "test-stuff.h"
#include "test-engine-stuff.h"
#include "test-file-stuff.h"
#include "Transaction.h"
#include "GNCIdP.h"

5
src/backend/file/test/test-xml2-is-file.c
View File

@ -1,7 +1,10 @@
#include <stdlib.h>
#include "io-gncxml-v2.h"
#include "gnc-test-stuff.h"
#include "test-stuff.h"
#include "test-engine-stuff.h"
#include "test-file-stuff.h"
int
main(int argc, char **argv)

14
src/engine/test-core/test-engine-stuff.h
View File

@ -1,13 +1,8 @@
/* Created by bstanley 20010323
* moved contents from test-stuff.h
*
* This file declares testing functions which rely on other parts
* of gnucash.
*
/* This file declares testing functions for the engine.
*/
#ifndef GNC_TEST_STUFF_H
#define GNC_TEST_STUFF_H
#ifndef TEST_ENGINE_STUFF_H
#define TEST_ENGINE_STUFF_H
#include "config.h"
@ -49,4 +44,5 @@ const char *get_random_commodity_namespace(void);
Query* get_random_query(void);
#endif /* GNC_TEST_STUFF_H */
#endif