test-engine-stuff.h File Reference

$brief This file declares testing functions for the engine. More...

#include <glib.h>
#include <stdlib.h>
#include <stdint.h>
#include "qof.h"
#include "Query.h"
#include "gnc-pricedb.h"
#include "SchedXaction.h"

Go to the source code of this file.

Data Structures
struct	bin_data

Enumerations
enum	TestQueryTypes {   RANDOM_QT = 0 , SIMPLE_QT = 1 << 0 , ACCOUNT_QT = 1 << 1 , SPLIT_KVP_QT = 1 << 2 ,   TRANS_KVP_QT = 1 << 3 , ACCOUNT_KVP_QT = 1 << 4 , GUID_QT = 1 << 5 , ALL_QT = (1 << 8) - 1 }

Functions
time64	get_random_time (void)
KvpValue *	get_random_kvp_value (int type)
bin_data *	get_random_binary_data (void)
KvpFrame *	get_random_kvp_frame (void)
gnc_numeric	get_random_gnc_numeric (int64_t)
GncGUID *	get_random_guid (void)
void	set_max_kvp_depth (gint max_kvp_depth)
void	set_max_kvp_frame_elements (gint max_kvp_frame_elements)
void	set_max_account_tree_depth (gint max_tree_depth)
void	set_max_accounts_per_level (gint max_accounts)
GNCPrice *	get_random_price (QofBook *book)
gboolean	make_random_pricedb (QofBook *book, GNCPriceDB *pdb)
GNCPriceDB *	get_random_pricedb (QofBook *book)
Account *	get_random_account_tree (QofBook *book)
Account *	get_random_account (QofBook *book)
Split *	get_random_split (QofBook *book, Account *account, Transaction *trn)
Transaction *	get_random_transaction (QofBook *book)
Transaction *	get_random_transaction_with_currency (QofBook *book, gnc_commodity *currency, GList *account_list)
gnc_commodity *	get_random_commodity (QofBook *book)
const char *	get_random_commodity_namespace (void)
QofQuery *	get_random_query (void)
QofQuery *	make_trans_query (Transaction *trans, TestQueryTypes query_types)
TestQueryTypes	get_random_query_type (void)
void	trans_query_include_price (gboolean include_amounts)
QofBook *	get_random_book (void)
QofSession *	get_random_session (void)
void	add_random_transactions_to_book (QofBook *book, gint num_transactions)
void	make_random_changes_to_commodity (gnc_commodity *com)
void	make_random_changes_to_commodity_table (gnc_commodity_table *table)
void	make_random_changes_to_price (QofBook *book, GNCPrice *price)
void	make_random_changes_to_pricedb (QofBook *book, GNCPriceDB *pdb)
void	make_random_changes_to_split (Split *split)
void	make_random_changes_to_transaction (QofBook *book, Transaction *trans)
void	make_random_changes_to_transaction_and_splits (QofBook *book, Transaction *trans, GList *accounts)
void	make_random_changes_to_account (QofBook *book, Account *account)
void	make_random_changes_to_level (QofBook *book, Account *parent)
void	make_random_changes_to_book (QofBook *book)
void	make_random_changes_to_session (QofSession *session)
SchedXaction *	add_daily_sx (const gchar *name, const GDate *start, const GDate *end, const GDate *last_occur)
SchedXaction *	add_once_sx (const gchar *name, const GDate *when)
void	remove_sx (SchedXaction *sx)

Detailed Description

$brief This file declares testing functions for the engine.

Definition in file test-engine-stuff.h.

Enumeration Type Documentation

TestQueryTypes

enum TestQueryTypes

Definition at line 84 of file test-engine-stuff.h.

{
    RANDOM_QT      = 0,
    SIMPLE_QT      = 1 << 0,
    ACCOUNT_QT     = 1 << 1,
    SPLIT_KVP_QT   = 1 << 2,
    TRANS_KVP_QT   = 1 << 3,
    ACCOUNT_KVP_QT = 1 << 4,
    GUID_QT        = 1 << 5,
    ALL_QT         = (1 << 8) - 1
} TestQueryTypes;

Function Documentation

add_daily_sx()

SchedXaction * add_daily_sx	(	const gchar *	name,
		const GDate *	start,
		const GDate *	end,
		const GDate *	last_occur
	)

Definition at line 2080 of file test-engine-stuff.cpp.

{
    return add_sx(name, start, end, last_occur, daily_freq(start, 1));
}

add_once_sx()

SchedXaction * add_once_sx	(	const gchar *	name,
		const GDate *	when
	)

Definition at line 2087 of file test-engine-stuff.cpp.

{
    return add_sx(name, when, NULL, NULL, once_freq(when));
}

add_random_transactions_to_book()

void add_random_transactions_to_book	(	QofBook *	book,
		gint	num_transactions
	)

Definition at line 1827 of file test-engine-stuff.cpp.

{
    gnc_commodity_table *table;
    GList *accounts;
 
    if (num_transactions <= 0) return;
 
    g_return_if_fail (book);
 
    accounts = gnc_account_get_descendants (gnc_book_get_root_account (book));
    g_return_if_fail (accounts);
 
    table = gnc_commodity_table_get_table (book);
 
    while (num_transactions--)
    {
        gnc_commodity *com;
 
        com = get_random_commodity_from_table (table);
        get_random_transaction_with_currency (book, com, accounts);
    }
    g_list_free (accounts);
}

get_random_account()

Account * get_random_account

(

QofBook *

book

)

Definition at line 1136 of file test-engine-stuff.cpp.

{
    Account *root, *ret;
    int tmp_int;
 
    ret = xaccMallocAccount(book);
 
    xaccAccountBeginEdit(ret);
 
    set_account_random_string_from_array(ret, xaccAccountSetName,
                                         sane_account_names);
 
    tmp_int = get_random_int_in_range(ACCT_TYPE_BANK, NUM_ACCOUNT_TYPES - 1);
    xaccAccountSetType(ret, static_cast<GNCAccountType>(tmp_int));
 
    set_account_random_string(ret, xaccAccountSetCode);
    set_account_random_string(ret, xaccAccountSetDescription);
 
    xaccAccountSetCommodity(ret, get_random_commodity(book));
 
    qof_instance_set_slots(QOF_INSTANCE(ret), get_random_kvp_frame());
 
    root = gnc_book_get_root_account (book);
    if (!root)
    {
        root = xaccMallocAccount (book);
        gnc_book_set_root_account (book, root);
    }
    gnc_account_append_child (root, ret);
    xaccAccountCommitEdit(ret);
 
    return ret;
}

get_random_account_tree()

Account * get_random_account_tree

(

QofBook *

book

)

Definition at line 831 of file test-engine-stuff.cpp.

{
    Account * root;
 
    g_return_val_if_fail (book, NULL);
 
    root = gnc_book_get_root_account (book);
    if (!root)
    {
        root = xaccMallocAccount (book);
        gnc_book_set_root_account (book, root);
    }
 
    make_random_account_tree (book, root);
 
    return root;
}

get_random_book()

QofBook * get_random_book

(

void

)

Definition at line 1802 of file test-engine-stuff.cpp.

{
    QofBook *book;
 
    book = qof_book_new ();
 
    get_random_account_tree (book);
    get_random_pricedb (book);
 
    return book;
}

get_random_commodity()

gnc_commodity * get_random_commodity

(

QofBook *

book

)

Definition at line 481 of file test-engine-stuff.cpp.

{
    gnc_commodity *ret;
    gchar *name;
    const gchar *space;
    gchar *mn;
    gchar *cusip;
    int ran_int;
    gnc_commodity_table *table;
 
    table = gnc_commodity_table_get_table (book);
 
#if 0
    if (table &&
            (gnc_commodity_table_get_size (table) > 0) &&
            get_random_int_in_range (1, 5) < 5)
        return get_random_commodity_from_table (table);
#endif
 
    mn = get_random_string_length_in_range(1, 3);
    space = get_random_commodity_namespace();
 
    if (table)
    {
        ret = gnc_commodity_table_lookup (table, space, mn);
 
        if (ret)
        {
            g_free (mn);
            return ret;
        }
    }
 
    name = get_random_string();
    cusip = get_random_string();
 
    ran_int = get_random_int_in_range(min_scu, max_scu);
 
    ret = gnc_commodity_new(book, name, space, mn, cusip, ran_int);
 
    g_free(mn);
    g_free(name);
    g_free(cusip);
 
    if (table)
        ret = gnc_commodity_table_insert (table, ret);
 
    return ret;
}

get_random_commodity_namespace()

const char * get_random_commodity_namespace

(

void

)

Definition at line 441 of file test-engine-stuff.cpp.

{
    return get_random_string_in_array(types);
}

get_random_gnc_numeric()

gnc_numeric get_random_gnc_numeric

(

int64_t

deno

)

Definition at line 366 of file test-engine-stuff.cpp.

{
    gint64 numer;
    int64_t limit;
    if (deno == GNC_DENOM_AUTO)
    {
        if (RAND_MAX / 8 > rand())
        {
            /* Random number between 1 and 6000 */
            deno = RAND_IN_RANGE(6000ULL);
        }
        else
        {
            gint64 norm = RAND_IN_RANGE (11ULL);
 
            /* multiple of 10, between 1 and 100 billion */
            deno = 1;
            while (norm)
            {
                deno *= 10;
                norm --;
            }
        }
    }
    /* Make sure we have a non-zero denominator */
    if (0 == deno) deno = 1;
 
    /* Arbitrary random numbers can cause pointless overflow during
     * calculations, in particular the revaluing in xaccSplitSetValue where an
     * input gnc_numeric is converted to use a new denominator. To prevent that,
     * the numerator is clamped to the larger of num_limit / deno or num_limit /
     * max_denom_mult.
     */
    limit = num_limit / (max_denom_mult / deno == 0 ? max_denom_mult : max_denom_mult / deno);
    numer = get_random_gint64 ();
    if (numer > limit)
    {
         int64_t num = numer % limit;
    if (num)
        numer = num;
    else
             numer = limit;
    }
    if (0 == numer) numer = 1;
    g_log("test.engine.suff", G_LOG_LEVEL_INFO, "New GncNumeric %" PRIu64 " / %" PRIu64 " !\n", numer, deno);
    return gnc_numeric_create(numer, deno);
}

get_random_guid()

GncGUID * get_random_guid

(

void

)

Definition at line 207 of file test-engine-stuff.cpp.

{
    return guid_new();
}

get_random_kvp_frame()

KvpFrame * get_random_kvp_frame

(

void

)

Definition at line 349 of file test-engine-stuff.cpp.

{
    return get_random_kvp_frame_depth (0);
}

get_random_kvp_value()

KvpValue * get_random_kvp_value

(

int

type

)

Definition at line 355 of file test-engine-stuff.cpp.

{
    return get_random_kvp_value_depth (type, 0);
}

get_random_price()

GNCPrice * get_random_price

(

QofBook *

book

)

Definition at line 630 of file test-engine-stuff.cpp.

{
    GNCPrice *p;
 
    p = gnc_price_create (book);
    if (!p)
    {
        failure_args("engine-stuff", __FILE__, __LINE__,
                     "get_random_price failed");
        return NULL;
    }
 
    make_random_changes_to_price (book, p);
    if (!p)
    {
        failure_args("engine-stuff", __FILE__, __LINE__,
                     "make_random_changes_to_price failed");
        return NULL;
    }
 
    return p;
}

get_random_pricedb()

GNCPriceDB * get_random_pricedb

(

QofBook *

book

)

Definition at line 688 of file test-engine-stuff.cpp.

{
    GNCPriceDB *db;
 
    db = gnc_pricedb_get_db (book);
    if (!db)
    {
        failure_args("engine-stuff", __FILE__, __LINE__,
                     "gnc_pricedb_get_db failed");
        return NULL;
    }
    if (!make_random_pricedb (book, db))
    {
        return NULL;
    }
 
    return db;
}

get_random_query()

QofQuery * get_random_query

(

void

)

Definition at line 1636 of file test-engine-stuff.cpp.

{
    QofQuery *q;
    int num_terms;
 
    num_terms = get_random_int_in_range (1, 3);
    if (gnc_engine_debug_random) printf("num_terms = %d", num_terms);
 
    q = qof_query_create_for(GNC_ID_SPLIT);
 
    while (num_terms-- > 0)
    {
        gint pr_type;
        time64 start;
        time64 end;
        GList *guids;
        char *string;
        GncGUID *guid;
 
        pr_type = get_random_int_in_range (1, 20);
        if (gnc_engine_debug_random) printf("\n pr_type = %d ", pr_type);
 
        switch (pr_type)
        {
        case 1: /*PR_ACCOUNT */
            guids = get_random_guids (10);
            xaccQueryAddAccountGUIDMatch
            (q,
             guids,
             compare_param<QofGuidMatch>(QOF_GUID_MATCH_NONE),
             get_random_queryop ());
            free_guids (guids);
            break;
 
        case 2: /*PR_ACTION */
            string = get_random_string_without ("\\");
            xaccQueryAddActionMatch (q,
                                     string,
                                     get_random_boolean (),
                                     get_random_boolean (),
                                     compare_param<QofQueryCompare>(QOF_COMPARE_CONTAINS),
                                     get_random_queryop ());
            g_free (string);
            break;
 
        case 3: /* PR_BALANCE */
            xaccQueryAddBalanceMatch
            (q,
             compare_param<QofQueryCompare> (1),
             get_random_queryop ());
            break;
 
        case 4: /* PR_CLEARED */
            xaccQueryAddClearedMatch
            (q,
             static_cast<cleared_match_t>(get_random_int_in_range (1,
                                      CLEARED_NO |
                                      CLEARED_CLEARED |
                                      CLEARED_RECONCILED |
                                      CLEARED_FROZEN |
                                                                   CLEARED_VOIDED)),
             get_random_queryop ());
            break;
 
        case 5: /* PR_DATE */
            start = get_random_time ();
            end = get_random_time ();
            xaccQueryAddDateMatchTT (q,
                                     get_random_boolean (),
                                     start,
                                     get_random_boolean (),
                                     end,
                                     get_random_queryop ());
            break;
 
        case 6: /* PR_DESC */
            string = get_random_string_without ("\\");
            xaccQueryAddDescriptionMatch (q,
                                          string,
                                          get_random_boolean (),
                                          get_random_boolean (),
                                          compare_param<QofQueryCompare>(QOF_COMPARE_CONTAINS),
                                          get_random_queryop ());
            g_free (string);
            break;
 
        case 7: /* PR_GUID */
            guid = get_random_guid ();
            xaccQueryAddGUIDMatch (q,
                                   guid,
                                   get_random_id_type (),
                                   get_random_queryop ());
            guid_free (guid);
            break;
 
        case 8: /* PR_KVP */
            break;
 
        case 9: /* PR_MEMO */
            string = get_random_string_without ("\\");
            xaccQueryAddMemoMatch (q,
                                   string,
                                   get_random_boolean (),
                                   get_random_boolean (),
                                   compare_param<QofQueryCompare>(QOF_COMPARE_CONTAINS),
                                   get_random_queryop ());
            g_free (string);
            break;
 
        case 10: /* PR_NUM */
            string = get_random_string_without ("\\");
            xaccQueryAddNumberMatch (q,
                                     string,
                                     get_random_boolean (),
                                     get_random_boolean (),
                                     compare_param<QofQueryCompare>(QOF_COMPARE_CONTAINS),
                                     get_random_queryop ());
            g_free (string);
            break;
 
        case 11: /*  PR_PRICE */
            xaccQueryAddSharePriceMatch
            (q,
             get_random_gnc_numeric (GNC_DENOM_AUTO),
             compare_param<QofQueryCompare> (QOF_COMPARE_NEQ),
             get_random_queryop ());
            break;
 
        case 12: /* PR_SHRS */
            xaccQueryAddSharesMatch
            (q,
             get_random_gnc_numeric (GNC_DENOM_AUTO),
             compare_param<QofQueryCompare> (QOF_COMPARE_NEQ),
             get_random_queryop ());
            break;
 
        case 13: /* PR_VALUE */
            xaccQueryAddValueMatch
            (q,
             get_random_gnc_numeric (GNC_DENOM_AUTO),
             compare_param<QofNumericMatch> (QOF_NUMERIC_MATCH_ANY),
             compare_param<QofQueryCompare> (QOF_COMPARE_NEQ),
             get_random_queryop ());
            break;
 
        default:
            if (gnc_engine_debug_random) printf("ignored..");
            num_terms++;
            break;
        }
    }
 
    if (gnc_engine_debug_random) printf ("\n");
    set_query_sort (q, compare_param<sort_type_t>(BY_NONE));
 
    qof_query_set_sort_increasing (q,
                                   get_random_boolean (),
                                   get_random_boolean (),
                                   get_random_boolean ());
 
    qof_query_set_max_results (q, get_random_int_in_range (-50000, 50000));
 
    return q;
}

get_random_query_type()

TestQueryTypes get_random_query_type

(

void

)

Definition at line 1888 of file test-engine-stuff.cpp.

{
    switch (get_random_int_in_range (0, 1))
    {
    case 0:
        return SIMPLE_QT;
    case 1:
        return GUID_QT;
    default:
        return SIMPLE_QT;
    }
}

get_random_session()

QofSession * get_random_session

(

void

)

Definition at line 1815 of file test-engine-stuff.cpp.

{
    auto book = qof_book_new ();
    auto session = qof_session_new (book);
 
    get_random_account_tree (book);
    get_random_pricedb (book);
 
    return session;
}

get_random_split()

Split * get_random_split	(	QofBook *	book,
		Account *	account,
		Transaction *	trn
	)

Definition at line 1210 of file test-engine-stuff.cpp.

{
    Split *ret;
    gnc_numeric amt = {0, 1}, val = {0, 1}, rate = {0, 0};
    const gchar *str;
    gnc_commodity *com;
    int scu, denom;
    time64 time;
 
    com = xaccTransGetCurrency (trn);
    scu = gnc_commodity_get_fraction(com);
 
    ret = xaccMallocSplit(book);
 
    str = get_random_string_in_array(sane_descriptions);
    xaccSplitSetMemo(ret, str);
    str = get_random_string_in_array(sane_actions);
    xaccSplitSetAction(ret, str);
 
    xaccSplitSetReconcile(ret, possible_chars[get_random_int_in_range(0, 3)]);
 
    time = get_random_time();
    xaccSplitSetDateReconciledSecs (ret, time);
 
    /* Split must be in an account before we can set an amount */
    /* and in a transaction before it can be added to an account. */
    xaccTransBeginEdit(trn);
    xaccSplitSetParent(ret, trn);
    xaccSplitSetAccount(ret, acct);
 
    do
    {
        val = get_random_gnc_numeric (scu);
        if (val.num == 0)
            fprintf(stderr, "get_random_split: Created split with zero value: %p\n", ret);
 
        if (!do_bork())
/* Another overflow-prevention measure. A numerator near the overflow limit can
 * be made too large by replacing the denominator with a smaller scu.
 */
        {
            if (val.denom > scu && val.num > num_limit / (max_denom_mult / scu))
            {
                int64_t new_num = val.num / (val.denom / scu);
                g_log("test.engine.suff", G_LOG_LEVEL_DEBUG,
              "Adjusting val.denom from %" PRIu64 " to %" PRIu64 "\n",
              val.num, new_num);
                val.num = new_num;
            }
            val.denom = scu;
        }
    }
    while (gnc_numeric_check(val) != GNC_ERROR_OK);
    g_log ("test.engine.suff", G_LOG_LEVEL_DEBUG,
       "Random split value: %" PRIu64 " / %" PRIu64 ", scu %d\n",
       val.num, val.denom, scu);
    xaccSplitSetValue(ret, val);
 
    /* If the currencies are the same, the split amount should equal
     * the split value (unless we bork it on purpose) */
    denom = gnc_commodity_get_fraction(xaccAccountGetCommodity(
                                           xaccSplitGetAccount(ret)));
    if (gnc_commodity_equal (xaccTransGetCurrency(trn),
                             xaccAccountGetCommodity(acct)) &&
            (!do_bork()))
    {
        amt = val;
    }
    else
    {
        do
        {
            rate = get_random_rate ();
            amt = gnc_numeric_div(val, rate, denom, GNC_HOW_RND_ROUND_HALF_UP);
        }
        while (gnc_numeric_check(amt) != GNC_ERROR_OK);
    }
    g_log ("test.engine.suff", G_LOG_LEVEL_DEBUG, "Random split amount: %"
       PRIu64 " / %" PRIu64 ", rate %" PRIu64 " / %" PRIu64 "\n",
       amt.num, amt.denom, rate.num, rate.denom);
 
 
     xaccSplitSetAmount(ret, amt);
 
    /* Make sure val and amt have the same sign. Note that amt is
       also allowed to be zero, because that is caused by a small
       rate. */
    if (gnc_numeric_positive_p(val))
        g_assert_true(!gnc_numeric_negative_p(amt)); /* non-negative amt */
    else
        g_assert_true(!gnc_numeric_positive_p(amt)); /* non-positive amt */
 
//    g_assert_true(amt.num < (2LL << 56));
    qof_instance_set_slots(QOF_INSTANCE (ret), get_random_kvp_frame());
    xaccTransCommitEdit(trn);
 
    return ret;
}

get_random_time()

time64 get_random_time

(

void

)

Definition at line 198 of file test-engine-stuff.cpp.

{
    time64 ret {0};
    while (ret <= 0)
        ret = rand();
    return ret;
}

get_random_transaction()

Transaction * get_random_transaction

(

QofBook *

book

)

Definition at line 1435 of file test-engine-stuff.cpp.

{
    Transaction *ret;
 
    g_return_val_if_fail(book, NULL);
    ret = get_random_transaction_with_currency (book, NULL, NULL);
    if (!ret)
    {
        failure_args("engine-stuff", __FILE__, __LINE__,
                     "get_random_transaction failed");
        return NULL;
    }
    return ret;
}

get_random_transaction_with_currency()

Transaction * get_random_transaction_with_currency	(	QofBook *	book,
		gnc_commodity *	currency,
		GList *	account_list
	)

Definition at line 1374 of file test-engine-stuff.cpp.

{
    Transaction* trans;
    KvpFrame *f;
 
    if (!account_list)
    {
        account_list = gnc_account_get_descendants (gnc_book_get_root_account (book));
    }
 
    /* Gotta have at least two different accounts */
    if (1 >= g_list_length (account_list))
    {
        failure_args("engine-stuff", __FILE__, __LINE__,
                     "get_random_transaction_with_currency: account_list too short");
        return NULL;
    }
 
    trans = xaccMallocTransaction(book);
 
    xaccTransBeginEdit(trans);
 
    xaccTransSetCurrency (trans,
                          currency ? currency :
                          get_random_commodity (book));
 
    gint num = get_random_int_in_range (1, max_trans_num);
    auto numstr = std::to_string(num);
    xaccTransSetNum(trans, numstr.c_str());
 
    set_tran_random_string_from_array(trans, xaccTransSetDescription,
                                      sane_descriptions);
    trn_add_ran_time(trans, xaccTransSetDatePostedSecs);
    trn_add_ran_time(trans, xaccTransSetDateEnteredSecs);
 
    f = get_random_kvp_frame();
    qof_instance_set_slots (QOF_INSTANCE (trans), f);
 
    add_random_splits(book, trans, account_list);
 
    if (get_random_int_in_range (1, 10) == 1)
    {
        char *reason = get_random_string ();
        xaccTransVoid (trans, reason);
        g_free (reason);
    }
 
    xaccTransCommitEdit(trans);
    if (!trans)
    {
        failure_args("engine-stuff", __FILE__, __LINE__,
                     "get_random_transaction_with_currency failed");
        return NULL;
    }
 
    return trans;
}

make_random_changes_to_account()

void make_random_changes_to_account	(	QofBook *	book,
		Account *	account
	)

Definition at line 1171 of file test-engine-stuff.cpp.

{
    int tmp_int;
 
    g_return_if_fail (account);
 
    xaccAccountBeginEdit (account);
 
    set_account_random_string (account, xaccAccountSetName);
 
    tmp_int = get_random_int_in_range (ACCT_TYPE_BANK, NUM_ACCOUNT_TYPES - 1);
    xaccAccountSetType (account, static_cast<GNCAccountType>(tmp_int));
 
    set_account_random_string (account, xaccAccountSetCode);
    set_account_random_string (account, xaccAccountSetDescription);
 
    xaccAccountSetCommodity (account, get_random_commodity(book));
 
    qof_instance_set_slots(QOF_INSTANCE(account), get_random_kvp_frame());
 
    xaccAccountCommitEdit (account);
}

make_random_changes_to_book()

void make_random_changes_to_book

(

QofBook *

book

)

Definition at line 1852 of file test-engine-stuff.cpp.

{
    g_return_if_fail (book);
 
    make_random_changes_to_level (book, gnc_book_get_root_account (book));
    make_random_changes_to_pricedb (book, gnc_pricedb_get_db (book));
 
#if 0
    make_random_changes_to_commodity_table (gnc_commodity_table_get_table (book));
#endif
}

make_random_changes_to_commodity()

void make_random_changes_to_commodity

(

gnc_commodity *

com

)

Definition at line 532 of file test-engine-stuff.cpp.

{
    char *str;
 
    g_return_if_fail (com);
 
    str = get_random_string ();
    gnc_commodity_set_namespace (com, str);
    g_free (str);
 
    str = get_random_string ();
    gnc_commodity_set_mnemonic (com, str);
    g_free (str);
 
    str = get_random_string ();
    gnc_commodity_set_fullname (com, str);
    g_free (str);
 
    str = get_random_string ();
    gnc_commodity_set_cusip (com, str);
    g_free (str);
 
    gnc_commodity_set_fraction (com, get_random_int_in_range (1, 100000));
}

make_random_changes_to_commodity_table()

void make_random_changes_to_commodity_table

(

gnc_commodity_table *

table

)

Definition at line 558 of file test-engine-stuff.cpp.

{
    GList *namespaces;
    GList *node;
 
    g_return_if_fail (table);
 
    namespaces = gnc_commodity_table_get_namespaces (table);
 
    for (node = namespaces; node; node = node->next)
    {
        auto ns = static_cast<const char *>(node->data);
        GList *commodities;
        GList *com_node;
 
        if (gnc_commodity_namespace_is_iso (ns))
            continue;
 
        commodities = gnc_commodity_table_get_commodities (table, ns);
 
        for (com_node = commodities; com_node; com_node = com_node->next)
        {
            auto com = static_cast<gnc_commodity *>(com_node->data);
 
            gnc_commodity_table_remove (table, com);
            make_random_changes_to_commodity (com);
            gnc_commodity_table_insert (table, com);
        }
 
        g_list_free (commodities);
    }
 
    g_list_free (namespaces);
}

make_random_changes_to_level()

void make_random_changes_to_level	(	QofBook *	book,
		Account *	parent
	)

Definition at line 1008 of file test-engine-stuff.cpp.

{
    Account *new_account;
    Account *account;
    GList *accounts;
    GList *transes;
    GList *splits;
    GList *node;
 
    g_return_if_fail (parent && book);
 
    accounts = gnc_account_get_descendants (parent);
 
    /* Add a new account */
    new_account = get_random_account (book);
 
    if (get_random_boolean () || !accounts)
        gnc_account_append_child (parent, new_account);
    else
    {
        account = static_cast<Account*>(get_random_list_element (accounts));
 
        gnc_account_append_child (account, new_account);
    }
 
    g_list_free (accounts);
    accounts = gnc_account_get_descendants (parent);
 
    /* Add some new transactions */
    add_random_transactions_to_book (book, get_random_int_in_range (1, 6));
 
    /* Mess with the accounts */
    for (node = accounts; node; node = node->next)
    {
        auto account = static_cast<Account *>(node->data);
 
        if (get_random_boolean ())
            make_random_changes_to_account (book, account);
    }
 
    /* Mess with the transactions & splits */
    transes = NULL;
    xaccAccountTreeForEachTransaction (parent, add_trans_helper, &transes);
 
    for (node = transes; node; node = node->next)
    {
        auto ti = static_cast<TransInfo *>(node->data);
        Transaction *trans = xaccTransLookup (&ti->guid, book);
 
        if (!trans)
            continue;
 
        make_random_changes_to_transaction_and_splits (book, trans, accounts);
    }
 
    for (node = transes; node; node = node->next)
    {
        auto ti = static_cast<TransInfo *>(node->data);
 
        g_free (ti);
    }
    g_list_free (transes);
    transes = NULL;
 
    /* delete an account */
    account = static_cast<Account*>(get_random_list_element (accounts));
 
    splits = xaccAccountGetSplitList (account);
 
    for (node = splits; node; node = node->next)
    {
        auto split = static_cast<Split *>(node->data);
 
        do
        {
            new_account = static_cast<Account*>(get_random_list_element (accounts));
        }
        while (new_account == account);
 
        xaccAccountInsertSplit (new_account, split);
    }
 
    xaccAccountBeginEdit (account);
    xaccAccountDestroy (account);
 
    g_list_free (splits);
    g_list_free (accounts);
 
    accounts = gnc_account_get_descendants (parent);
 
    /* move some accounts around */
    if (accounts && (g_list_length (accounts) > 1))
    {
        int i = get_random_int_in_range (1, 4);
 
        while (i--)
        {
            Account *a2;
 
            auto a1 = static_cast<Account*>(get_random_list_element (accounts));
 
            if (get_random_boolean ())
                a2 = static_cast<Account*>(get_random_list_element (accounts));
            else
                a2 = NULL;
 
            if (!a2)
            {
                gnc_account_append_child (parent, a1);
                continue;
            }
 
            if (a1 == a2 ||
                    xaccAccountHasAncestor (a1, a2) ||
                    xaccAccountHasAncestor (a2, a1))
            {
                i++;
                continue;
            }
 
            gnc_account_append_child (a2, a1);
        }
    }
 
    g_list_free (accounts);
}

make_random_changes_to_price()

void make_random_changes_to_price	(	QofBook *	book,
		GNCPrice *	price
	)

Definition at line 596 of file test-engine-stuff.cpp.

{
    time64 time;
    PriceSource ps;
    char *string;
    gnc_commodity *c;
 
    g_return_if_fail (book && p);
 
    gnc_price_begin_edit (p);
 
    c = get_random_commodity (book);
    gnc_price_set_commodity (p, c);
 
    c = get_random_commodity (book);
    gnc_price_set_currency (p, c);
 
    time = get_random_time ();
    gnc_price_set_time64 (p, time);
 
    ps = (PriceSource)get_random_int_in_range((int)PRICE_SOURCE_EDIT_DLG,
                                              (int)PRICE_SOURCE_INVALID);
    gnc_price_set_source (p, ps);
 
    string = get_random_string ();
    gnc_price_set_typestr (p, string);
    g_free (string);
 
    gnc_price_set_value (p, get_random_gnc_numeric (GNC_DENOM_AUTO));
 
    gnc_price_commit_edit (p);
}

make_random_changes_to_pricedb()

void make_random_changes_to_pricedb	(	QofBook *	book,
		GNCPriceDB *	pdb
	)

Definition at line 718 of file test-engine-stuff.cpp.

{
    GList *list = NULL;
    GList *node;
 
    g_return_if_fail (pdb);
 
    gnc_pricedb_foreach_price (pdb, price_accumulator, &list, FALSE);
 
    for (node = list; node; node = node->next)
    {
        auto p = static_cast<GNCPrice *>(node->data);
 
        switch (get_random_int_in_range (0, 5))
        {
        case 0: /* Delete */
            gnc_pricedb_remove_price (pdb, p);
            break;
 
        case 1:
        case 2: /* Change */
            make_random_changes_to_price (book, p);
            break;
 
        default: /* nothing */
            break;
        }
    }
 
    g_list_free (list);
 
    /* Add a few new ones */
    {
        int i = get_random_int_in_range (1, 5);
 
        while (i--)
        {
            GNCPrice *p = get_random_price (book);
 
            gnc_pricedb_add_price (pdb, p);
 
            gnc_price_unref (p);
        }
    }
}

make_random_changes_to_session()

void make_random_changes_to_session

(

QofSession *

session

)

Definition at line 1865 of file test-engine-stuff.cpp.

{
    g_return_if_fail (session);
 
    make_random_changes_to_book (qof_session_get_book (session));
}

make_random_changes_to_split()

void make_random_changes_to_split

(

Split *

split

)

Definition at line 1310 of file test-engine-stuff.cpp.

{
    Transaction *trans;
    time64 time;
 
    g_return_if_fail (split);
 
    trans = xaccSplitGetParent (split);
 
    xaccTransBeginEdit (trans);
 
    set_split_random_string (split, xaccSplitSetMemo);
    set_split_random_string (split, xaccSplitSetAction);
 
    xaccSplitSetReconcile (split, possible_chars[get_random_int_in_range(0, 3)]);
 
    time = get_random_time();
    xaccSplitSetDateReconciledSecs (split, time);
 
    qof_instance_set_slots (QOF_INSTANCE (split), get_random_kvp_frame());
 
    /* Don't change share values/prices here, since that would
     * throw transactions out of balance. Do that in the corresponding
     * change transaction function. */
 
    xaccTransCommitEdit (trans);
}

make_random_changes_to_transaction()

void make_random_changes_to_transaction	(	QofBook *	book,
		Transaction *	trans
	)

Definition at line 1451 of file test-engine-stuff.cpp.

{
    g_return_if_fail (trans && book);
 
    if (xaccTransGetVoidStatus (trans))
    {
        if (get_random_int_in_range (1, 2) == 1)
            xaccTransUnvoid (trans);
        return;
    }
 
    xaccTransBeginEdit (trans);
 
    xaccTransSetCurrency (trans, get_random_commodity (book));
 
    set_tran_random_string (trans, xaccTransSetNum);
 
    trn_add_ran_time (trans, xaccTransSetDatePostedSecs);
    trn_add_ran_time (trans, xaccTransSetDateEnteredSecs);
 
    set_tran_random_string (trans, xaccTransSetDescription);
 
    qof_instance_set_slots (QOF_INSTANCE (trans), get_random_kvp_frame());
 
    /* Do split manipulations in higher-level functions */
 
    xaccTransCommitEdit (trans);
}

make_random_changes_to_transaction_and_splits()

void make_random_changes_to_transaction_and_splits	(	QofBook *	book,
		Transaction *	trans,
		GList *	accounts
	)

Definition at line 914 of file test-engine-stuff.cpp.

{
    GList *splits;
    GList *node;
    Split *split;
 
    g_return_if_fail (book);
    g_return_if_fail (trans);
    g_return_if_fail (accounts);
 
    xaccTransBeginEdit (trans);
 
    make_random_changes_to_transaction (book, trans);
 
    switch (get_random_int_in_range (0, 3))
    {
    case 0: /* delete some splits, add some more */
        if (xaccTransGetVoidStatus (trans))
            break;
 
        do
        {
            split = xaccTransGetSplit (trans, 0);
 
            xaccSplitDestroy (split);
        }
        while (split);
 
        add_random_splits (book, trans, accounts);
 
        /* fall through */
 
    case 1: /* move the splits around */
        if (xaccTransGetVoidStatus (trans))
            break;
 
        splits = xaccTransGetSplitList (trans);
        for (node = splits; node; node = node->next)
        {
            auto split = static_cast<Split *>(node->data);
            auto account = static_cast<Account*>(get_random_list_element (accounts));
 
            xaccAccountInsertSplit (account, split);
        }
        break;
 
    case 2: /* destroy the transaction */
        xaccTransDestroy (trans);
        xaccTransCommitEdit (trans);
        return;
 
    default: /* do nothing */
        break;
    }
 
    if (xaccTransGetVoidStatus (trans))
    {
        xaccTransCommitEdit (trans);
        return;
    }
 
    /* mess with the splits */
    splits = xaccTransGetSplitList (trans);
    for (node = splits; node; node = node->next)
    {
        auto split = static_cast<Split *>(node->data);
 
        if (get_random_boolean ())
            make_random_changes_to_split (split);
    }
 
    if (get_random_boolean ())
        xaccTransCommitEdit (trans);
    else
        xaccTransRollbackEdit (trans);
}

make_random_pricedb()

gboolean make_random_pricedb	(	QofBook *	book,
		GNCPriceDB *	pdb
	)

Definition at line 654 of file test-engine-stuff.cpp.

{
    int num_prices;
 
    num_prices = get_random_int_in_range (1, 41);
    if (num_prices < 1) /* should be impossible */
    {
        failure_args("engine-stuff", __FILE__, __LINE__,
                     "get_random_int_in_range failed");
        return FALSE;
    }
 
    while (num_prices-- > 0)
    {
        GNCPrice *p;
 
        p = get_random_price (book);
        if (!p)
        {
            failure_args("engine-stuff", __FILE__, __LINE__,
                         "get_random_price failed");
            return FALSE;
        }
 
        if (!gnc_pricedb_add_price (db, p))
            /* probably the same date as another price, just try again. */
            ++num_prices;
 
        gnc_price_unref (p);
    }
    return TRUE;
}

make_trans_query()

QofQuery * make_trans_query	(	Transaction *	trans,
		TestQueryTypes	query_types
	)

Definition at line 1902 of file test-engine-stuff.cpp.

{
    Account *a;
    gnc_numeric n;
    QofQuery *q;
    Split *s;
 
    if (query_types == RANDOM_QT)
        query_types = get_random_query_type ();
 
    q = qof_query_create_for(GNC_ID_SPLIT);
 
    s = xaccTransGetSplit (trans, 0);
    a = xaccSplitGetAccount (s);
 
    if (query_types & SIMPLE_QT)
    {
        xaccQueryAddSingleAccountMatch (q, xaccSplitGetAccount (s), QOF_QUERY_AND);
 
        if (xaccTransGetDescription(trans) && *xaccTransGetDescription(trans) != '\0')
        {
            xaccQueryAddDescriptionMatch (q, xaccTransGetDescription (trans),
                                          TRUE, FALSE, QOF_COMPARE_CONTAINS, QOF_QUERY_AND);
        }
 
        if (xaccTransGetNum(trans) && *xaccTransGetNum(trans) != '\0')
        {
            xaccQueryAddNumberMatch (q, xaccTransGetNum (trans),
                                     TRUE, FALSE, QOF_COMPARE_CONTAINS, QOF_QUERY_AND);
        }
 
        if (xaccSplitGetAction(s) && *xaccSplitGetAction(s) != '\0')
        {
            xaccQueryAddActionMatch (q, xaccSplitGetAction (s),
                                     TRUE, FALSE, QOF_COMPARE_CONTAINS, QOF_QUERY_AND);
        }
 
        n = xaccSplitGetValue (s);
        xaccQueryAddValueMatch (q, n, QOF_NUMERIC_MATCH_ANY,
                                QOF_COMPARE_EQUAL, QOF_QUERY_AND);
 
        n = xaccSplitGetAmount (s);
        xaccQueryAddSharesMatch (q, n, QOF_COMPARE_EQUAL, QOF_QUERY_AND);
 
        if (include_price)
        {
            n = xaccSplitGetSharePrice (s);
            xaccQueryAddSharePriceMatch (q, n, QOF_COMPARE_EQUAL, QOF_QUERY_AND);
        }
 
        {
            time64 time = xaccTransRetDatePosted (trans);
            xaccQueryAddDateMatchTT (q, TRUE, time, TRUE, time, QOF_QUERY_AND);
        }
 
        if (xaccSplitGetMemo(s) && *xaccSplitGetMemo(s) != '\0')
        {
            xaccQueryAddMemoMatch (q, xaccSplitGetMemo (s), TRUE, FALSE, QOF_COMPARE_CONTAINS, QOF_QUERY_AND);
        }
 
        {
            cleared_match_t how;
 
            switch (xaccSplitGetReconcile (s))
            {
            case NREC:
                how = CLEARED_NO;
                break;
            case CREC:
                how = CLEARED_CLEARED;
                break;
            case YREC:
                how = CLEARED_RECONCILED;
                break;
            case FREC:
                how = CLEARED_FROZEN;
                break;
            case VREC:
                how = CLEARED_VOIDED;
                break;
            default:
                failure ("bad reconcile flag");
                qof_query_destroy (q);
                return NULL;
            }
 
            xaccQueryAddClearedMatch (q, how, QOF_QUERY_AND);
        }
    }
 
    if (query_types & ACCOUNT_QT)
    {
        GList * list;
        GList * node;
 
        /* QOF_GUID_MATCH_ALL */
        list = NULL;
        for (node = xaccTransGetSplitList (trans); node; node = node->next)
        {
            auto split = static_cast<Split * >(node->data);
            list = g_list_prepend (list, xaccSplitGetAccount (split));
        }
        xaccQueryAddAccountMatch (q, list, QOF_GUID_MATCH_ALL, QOF_QUERY_AND);
        g_list_free (list);
 
        /* QOF_GUID_MATCH_NONE */
        list = NULL;
        list = g_list_prepend (list, get_random_guid ());
        list = g_list_prepend (list, get_random_guid ());
        list = g_list_prepend (list, get_random_guid ());
        xaccQueryAddAccountGUIDMatch (q, list, QOF_GUID_MATCH_NONE, QOF_QUERY_AND);
 
        /* QOF_GUID_MATCH_ANY */
        {
            GncGUID * guid = get_random_guid ();
            *guid = *xaccAccountGetGUID (a);
            list = g_list_prepend (list, guid);
        }
        xaccQueryAddAccountGUIDMatch (q, list, QOF_GUID_MATCH_ANY, QOF_QUERY_AND);
 
        free_guids (list);
    }
 
    if (query_types & GUID_QT)
    {
        xaccQueryAddGUIDMatch (q, xaccSplitGetGUID (s),
                               GNC_ID_SPLIT, QOF_QUERY_AND);
 
        xaccQueryAddGUIDMatch (q, xaccTransGetGUID (trans),
                               GNC_ID_TRANS, QOF_QUERY_AND);
 
        xaccQueryAddGUIDMatch (q, xaccAccountGetGUID (a),
                               GNC_ID_ACCOUNT, QOF_QUERY_AND);
    }
 
    return q;
}

remove_sx()

void remove_sx

(

SchedXaction *

sx

)

Definition at line 2093 of file test-engine-stuff.cpp.

{
    QofBook *book = qof_session_get_book(gnc_get_current_session());
    SchedXactions *sxes = gnc_book_get_schedxactions(book);
    gnc_sxes_del_sx(sxes, sx);
}

set_max_account_tree_depth()

void set_max_account_tree_depth

(

gint

max_tree_depth

)

Definition at line 104 of file test-engine-stuff.cpp.

{
    max_tree_depth = MAX (max_tree_depth_in, 1);
}

set_max_accounts_per_level()

void set_max_accounts_per_level

(

gint

max_accounts

)

Definition at line 110 of file test-engine-stuff.cpp.

{
    max_level_accounts = MAX (max_level_accounts_in, 1);
}

set_max_kvp_depth()

void set_max_kvp_depth

(

gint

max_kvp_depth

)

Definition at line 116 of file test-engine-stuff.cpp.

{
    kvp_max_depth = MAX (max_kvp_depth, 1);
}

set_max_kvp_frame_elements()

void set_max_kvp_frame_elements

(

gint

max_kvp_frame_elements

)

Definition at line 122 of file test-engine-stuff.cpp.

{
    kvp_frame_max_elements = MAX (max_kvp_frame_elements, 1);
}

trans_query_include_price()

void trans_query_include_price

(

gboolean

include_amounts

)

Definition at line 1882 of file test-engine-stuff.cpp.

{
    include_price = include_price_in;
}