/*
* visorchannel_create() - creates the struct visorchannel abstraction for a
* data area in memory, but does NOT modify this data
* area
* @physaddr: physical address of start of channel
* @gfp: gfp_t to use when allocating memory for the data struct
* @guid: GUID that identifies channel type;
* @needs_lock: must specify true if you have multiple threads of execution
* that will be calling visorchannel methods of this
* visorchannel at the same time
*
* Return: pointer to visorchannel that was created if successful,
* otherwise NULL
*/
struct visorchannel *visorchannel_create(u64 physaddr, gfp_t gfp,
const guid_t *guid, bool needs_lock)
{
struct visorchannel *channel;
int err;
size_t size = sizeof(struct channel_header);
if (physaddr == 0)
return NULL;
channel = kzalloc(sizeof(*channel), gfp);
if (!channel)
return NULL;
channel->needs_lock = needs_lock;
spin_lock_init(&channel->insert_lock);
spin_lock_init(&channel->remove_lock);
/*
* Video driver constains the efi framebuffer so it will get a conflict
* resource when requesting its full mem region. Since we are only
* using the efi framebuffer for video we can ignore this. Remember that
* we haven't requested it so we don't try to release later on.
*/
channel->requested = request_mem_region(physaddr, size, VISOR_DRV_NAME);
if (!channel->requested && !guid_equal(guid, &visor_video_guid))
/* we only care about errors if this is not the video channel */
goto err_destroy_channel;
channel->mapped = memremap(physaddr, size, MEMREMAP_WB);
if (!channel->mapped) {
release_mem_region(physaddr, size);
goto err_destroy_channel;
}
channel->physaddr = physaddr;
channel->nbytes = size;
err = visorchannel_read(channel, 0, &channel->chan_hdr, size);
if (err)
goto err_destroy_channel;
size = (ulong)channel->chan_hdr.size;
memunmap(channel->mapped);
if (channel->requested)
release_mem_region(channel->physaddr, channel->nbytes);
channel->mapped = NULL;
channel->requested = request_mem_region(channel->physaddr, size,
VISOR_DRV_NAME);
if (!channel->requested && !guid_equal(guid, &visor_video_guid))
/* we only care about errors if this is not the video channel */
goto err_destroy_channel;
channel->mapped = memremap(channel->physaddr, size, MEMREMAP_WB);
if (!channel->mapped) {
release_mem_region(channel->physaddr, size);
goto err_destroy_channel;
}
channel->nbytes = size;
guid_copy(&channel->guid, guid);
return channel;
err_destroy_channel:
visorchannel_destroy(channel);
return NULL;
}
static void test_null_guid(void)
{
GncGUID g;
GncGUID *gp;
g = guid_new_return();
gp = guid_new();
do_test(guid_equal(guid_null(), guid_null()), "null guids equal");
do_test(!guid_equal(&g, gp), "two guids equal");
guid_free(gp);
}
gboolean
gnc_tree_model_budget_get_iter_for_budget(GtkTreeModel *tm, GtkTreeIter *iter,
GncBudget *bgt)
{
GValue gv = { 0 };
const GncGUID *guid1;
GncGUID *guid2;
g_return_val_if_fail(GNC_BUDGET(bgt), FALSE);
guid1 = gnc_budget_get_guid(bgt);
if (!gtk_tree_model_get_iter_first(tm, iter))
return FALSE;
while (gtk_list_store_iter_is_valid(GTK_LIST_STORE(tm), iter))
{
gtk_tree_model_get_value(tm, iter, BUDGET_GUID_COLUMN, &gv);
guid2 = (GncGUID *) g_value_get_pointer(&gv);
g_value_unset(&gv);
if (guid_equal(guid1, guid2))
return TRUE;
if (!gtk_tree_model_iter_next(tm, iter))
return FALSE;
}
return FALSE;
}
static gboolean
spl_account_handler(xmlNodePtr node, gpointer data)
{
struct split_pdata *pdata = data;
GncGUID *id = dom_tree_to_guid(node);
Account *account;
g_return_val_if_fail(id, FALSE);
account = xaccAccountLookup (id, pdata->book);
if (!account && gnc_transaction_xml_v2_testing &&
!guid_equal (id, guid_null ()))
{
account = xaccMallocAccount (pdata->book);
xaccAccountSetGUID (account, id);
xaccAccountSetCommoditySCU (account,
xaccSplitGetAmount (pdata->split).denom);
}
xaccAccountInsertSplit (account, pdata->split);
g_free(id);
return TRUE;
}
GList*
gnc_sx_get_sxes_referencing_account(QofBook *book, Account *acct)
{
GList *rtn = NULL;
const GncGUID *acct_guid = qof_entity_get_guid(QOF_INSTANCE(acct));
GList *sx_list;
SchedXactions *sxactions = gnc_book_get_schedxactions(book);
g_return_val_if_fail( sxactions != NULL, rtn);
for (sx_list = sxactions->sx_list; sx_list != NULL; sx_list = sx_list->next)
{
SchedXaction *sx = (SchedXaction*)sx_list->data;
GList *splits = xaccSchedXactionGetSplits(sx);
for (; splits != NULL; splits = splits->next)
{
Split *s = (Split*)splits->data;
GncGUID *guid = NULL;
qof_instance_get (QOF_INSTANCE (s), "sx-account", &guid, NULL);
if (guid_equal(acct_guid, guid))
{
rtn = g_list_append(rtn, sx);
}
}
}
return rtn;
}
static void
test_dom_tree_to_guid(void)
{
int i;
for (i = 0; i < 20; i++)
{
GncGUID *test_guid1;
GncGUID *test_guid2;
xmlNodePtr test_node;
test_guid1 = get_random_guid();
if (!(test_node = guid_to_dom_tree("test-guid", test_guid1)))
{
failure_args("guid_to_dom_tree", __FILE__, __LINE__,
"conversion to dom tree failed");
}
test_guid2 = dom_tree_to_guid(test_node);
do_test(guid_equal(test_guid1, test_guid2),
"dom_tree_to_guid" );
xmlFreeNode(test_node);
g_free(test_guid1);
g_free(test_guid2);
}
}
static gboolean
find_handler (gpointer find_data, gpointer user_data)
{
const GncGUID *employee_guid = find_data;
EmployeeWindow *ew = user_data;
return(ew && guid_equal(&ew->employee_guid, employee_guid));
}
static gboolean
find_handler (gpointer find_data, gpointer user_data)
{
const GncGUID *job_guid = find_data;
JobWindow *jw = user_data;
return(jw && guid_equal(&jw->job_guid, job_guid));
}
static gboolean
find_handler (gpointer find_data, gpointer user_data)
{
const GncGUID *customer_guid = find_data;
CustomerWindow *cw = user_data;
return(cw && guid_equal(&cw->customer_guid, customer_guid));
}
/***********************************************************
* gnc_ui_custom_report_edit_name
*
* open the custom report dialog and highlight the given
* report's name for editing.
***********************************************************/
void
gnc_ui_custom_report_edit_name (GncMainWindow * window, SCM scm_guid)
{
SCM is_custom_report;
CustomReportDialog *crd = gnc_ui_custom_report_internal (window);
GtkTreeModel *model;
GtkTreeIter iter;
GncGUID *guid;
gchar *guid_str;
gboolean valid_iter;
is_custom_report = scm_c_eval_string ("gnc:report-template-is-custom/template-guid?");
if (scm_is_false (scm_call_1 (is_custom_report, scm_guid)))
return;
guid = guid_malloc ();
guid_str = scm_to_utf8_string (scm_guid);
if (!string_to_guid (guid_str, guid))
goto cleanup;
/* Look up the row for the requested guid */
model = gtk_tree_view_get_model (GTK_TREE_VIEW (crd->reportview));
valid_iter = gtk_tree_model_get_iter_first (model, &iter);
while (valid_iter)
{
GValue value = { 0, };
GncGUID *row_guid;
gtk_tree_model_get_value (model, &iter, COL_NUM, &value);
row_guid = (GncGUID *) g_value_get_pointer (&value);
if (guid_equal (guid, row_guid))
{
/* We found the row for the requested guid
* Now let's set the report's name cell in edit mode
* so the user can edit the name.
*/
GtkTreePath *path;
GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (crd->reportview));
gtk_tree_selection_select_iter (selection, &iter);
path = gtk_tree_model_get_path (model, &iter);
g_object_set(G_OBJECT(crd->namerenderer), "editable", TRUE, NULL);
gtk_tree_view_set_cursor_on_cell (GTK_TREE_VIEW (crd->reportview),
path, crd->namecol,
crd->namerenderer, TRUE);
break;
}
g_value_unset (&value);
valid_iter = gtk_tree_model_iter_next (model, &iter);
}
cleanup:
guid_free (guid);
}
inline static gboolean
kvp_match_guid (KvpValue *v, const char *key, const GncGUID *guid)
{
if (v->get_type() != KvpValue::Type::FRAME)
return FALSE;
auto frame = v->get<KvpFrame*>();
auto val = frame->get_slot(key);
if (val == nullptr || val->get_type() != KvpValue::Type::GUID)
return FALSE;
auto this_guid = val->get<GncGUID*>();
return guid_equal (this_guid, guid);
}
static /*@ null @*/ Split*
load_single_split( GncSqlBackend* be, GncSqlRow* row )
{
const GncGUID* guid;
GncGUID split_guid;
Split* pSplit = NULL;
gboolean bad_guid = FALSE;
g_return_val_if_fail( be != NULL, NULL );
g_return_val_if_fail( row != NULL, NULL );
guid = gnc_sql_load_guid( be, row );
if ( guid == NULL ) return NULL;
if (guid_equal(guid, guid_null()))
{
PWARN("Bad GUID, creating new");
bad_guid = TRUE;
split_guid = guid_new_return();
}
else
{
split_guid = *guid;
pSplit = xaccSplitLookup( &split_guid, be->book );
}
if ( pSplit == NULL )
{
pSplit = xaccMallocSplit( be->book );
}
/* If the split is dirty, don't overwrite it */
if ( !qof_instance_is_dirty( QOF_INSTANCE(pSplit) ) )
{
gnc_sql_load_object( be, row, GNC_ID_SPLIT, pSplit, split_col_table );
}
/*# -ifempty */
if (pSplit != xaccSplitLookup( &split_guid, be->book ))
{
gchar guidstr[GUID_ENCODING_LENGTH+1];
guid_to_string_buff(qof_instance_get_guid(pSplit), guidstr);
PERR("A malformed split with id %s was found in the dataset.", guidstr);
qof_backend_set_error( &be->be, ERR_BACKEND_DATA_CORRUPT);
pSplit = NULL;
}
return pSplit;
}
static gboolean
have_session (const char *session_auth_string)
{
GncGUID guid;
GList *next = logged_in_users;
string_to_guid (session_auth_string, &guid);
while (next)
{
if (guid_equal (&guid, next->data)) return TRUE;
next = next->next;
}
/* guid was not found */
return FALSE;
}
static xmlNodePtr
find_appropriate_node (xmlNodePtr node, Split* spl)
{
xmlNodePtr mark;
for (mark = node->xmlChildrenNode; mark; mark = mark->next)
{
gboolean account_guid_good = FALSE;
gboolean amount_good = FALSE;
xmlNodePtr mark2;
for (mark2 = mark->xmlChildrenNode; mark2; mark2 = mark2->next)
{
if (g_strcmp0 ((char*)mark2->name, "split:value") == 0)
{
gnc_numeric* num = dom_tree_to_gnc_numeric (mark2);
if (gnc_numeric_equal (*num, xaccSplitGetValue (spl)))
{
amount_good = TRUE;
}
g_free (num);
}
else if (g_strcmp0 ((char*)mark2->name, "split:account") == 0)
{
GncGUID* accid = dom_tree_to_guid (mark2);
Account* account = xaccSplitGetAccount (spl);
if (guid_equal (accid, xaccAccountGetGUID (account)))
{
account_guid_good = TRUE;
}
g_free (accid);
}
if (account_guid_good && amount_good)
{
return mark;
}
}
}
return NULL;
}
/**
* Commits a split to the database
*
* @param be SQL backend
* @param inst Split
* @return TRUE if successful, FALSE if error
*/
static gboolean
commit_split( GncSqlBackend* be, QofInstance* inst )
{
gint op;
gboolean is_infant;
gboolean is_ok;
GncGUID *guid = (GncGUID*)qof_instance_get_guid(inst);
g_return_val_if_fail( inst != NULL, FALSE );
g_return_val_if_fail( be != NULL, FALSE );
is_infant = qof_instance_get_infant( inst );
if ( qof_instance_get_destroying( inst ) )
{
op = OP_DB_DELETE;
}
else if ( be->is_pristine_db || is_infant )
{
op = OP_DB_INSERT;
}
else
{
op = OP_DB_UPDATE;
}
if (guid_equal (guid, guid_null ()))
{
*guid = guid_new_return ();
qof_instance_set_guid (inst, guid);
}
is_ok = gnc_sql_do_db_operation( be, op, SPLIT_TABLE, GNC_ID_SPLIT,
inst, split_col_table );
if ( is_ok && !qof_instance_get_destroying (inst))
{
is_ok = gnc_sql_slots_save( be,
guid,
is_infant,
qof_instance_get_slots( inst ) );
}
return is_ok;
}
void
qof_instance_set_guid (gpointer ptr, const GncGUID *guid)
{
QofInstancePrivate *priv;
QofInstance *inst;
QofCollection *col;
g_return_if_fail(QOF_IS_INSTANCE(ptr));
inst = QOF_INSTANCE(ptr);
priv = GET_PRIVATE(inst);
if (guid_equal (guid, &priv->guid))
return;
col = priv->collection;
qof_collection_remove_entity(inst);
priv->guid = *guid;
qof_collection_insert_entity(col, inst);
}
static gboolean
spl_lot_handler(xmlNodePtr node, gpointer data)
{
struct split_pdata *pdata = data;
GncGUID *id = dom_tree_to_guid(node);
GNCLot *lot;
g_return_val_if_fail(id, FALSE);
lot = gnc_lot_lookup (id, pdata->book);
if (!lot && gnc_transaction_xml_v2_testing &&
!guid_equal (id, guid_null ()))
{
lot = gnc_lot_new (pdata->book);
gnc_lot_set_guid (lot, *id);
}
gnc_lot_add_split (lot, pdata->split);
g_free(id);
return TRUE;
}
GList*
gnc_sx_get_sxes_referencing_account(QofBook *book, Account *acct)
{
GList *rtn = NULL;
const GncGUID *acct_guid = qof_entity_get_guid(QOF_INSTANCE(acct));
GList *sx_list = gnc_book_get_schedxactions(book)->sx_list;
for (; sx_list != NULL; sx_list = sx_list->next)
{
SchedXaction *sx = (SchedXaction*)sx_list->data;
GList *splits = xaccSchedXactionGetSplits(sx);
for (; splits != NULL; splits = splits->next)
{
Split *s = (Split*)splits->data;
KvpFrame *frame = kvp_frame_get_frame(xaccSplitGetSlots(s), GNC_SX_ID);
GncGUID *sx_split_acct_guid = kvp_frame_get_guid(frame, GNC_SX_ACCOUNT);
if (guid_equal(acct_guid, sx_split_acct_guid))
{
rtn = g_list_append(rtn, sx);
}
}
}
return rtn;
}
static void
test_employee (void)
{
QofBook *book;
GncEmployee *employee;
book = qof_book_new();
/* Test creation/destruction */
{
do_test (gncEmployeeCreate (NULL) == NULL, "employee create NULL");
employee = gncEmployeeCreate (book);
do_test (employee != NULL, "employee create");
do_test (qof_instance_get_book(QOF_INSTANCE(employee)) == book,
"getbook");
gncEmployeeBeginEdit (employee);
gncEmployeeDestroy (employee);
success ("create/destroy");
}
/* Test setting/getting routines; does the active flag get set right? */
{
GncGUID guid;
test_string_fcn (book, "Id", gncEmployeeSetID, gncEmployeeGetID);
test_string_fcn (book, "Username", gncEmployeeSetUsername, gncEmployeeGetUsername);
test_string_fcn (book, "Language", gncEmployeeSetLanguage, gncEmployeeGetLanguage);
test_string_fcn (book, "Acl", gncEmployeeSetAcl, gncEmployeeGetAcl);
test_numeric_fcn (book, "Workday", gncEmployeeSetWorkday, gncEmployeeGetWorkday);
test_numeric_fcn (book, "Rate", gncEmployeeSetRate, gncEmployeeGetRate);
test_bool_fcn (book, "Active", gncEmployeeSetActive, gncEmployeeGetActive);
do_test (gncEmployeeGetAddr (employee) != NULL, "Addr");
guid_replace (&guid);
employee = gncEmployeeCreate (book);
count++;
gncEmployeeSetGUID (employee, &guid);
do_test (guid_equal (&guid, qof_instance_get_guid(QOF_INSTANCE(employee))), "guid compare");
}
{
GList *list;
list = gncBusinessGetList (book, GNC_EMPLOYEE_MODULE_NAME, TRUE);
do_test (list != NULL, "getList all");
do_test (g_list_length (list) == count, "correct length: all");
g_list_free (list);
list = gncBusinessGetList (book, GNC_EMPLOYEE_MODULE_NAME, FALSE);
do_test (list != NULL, "getList active");
do_test (g_list_length (list) == 1, "correct length: active");
g_list_free (list);
}
{
const char *str = get_random_string();
const char *res;
GncAddress *addr;
addr = gncEmployeeGetAddr (employee);
gncAddressSetName (addr, str);
res = qof_object_printable (GNC_ID_EMPLOYEE, employee);
do_test (res != NULL, "Printable NULL?");
do_test (g_strcmp0 (str, res) == 0, "Printable equals");
}
qof_book_destroy (book);
}
static void
test_vendor (void)
{
QofBook *book;
GncVendor *vendor;
book = qof_book_new();
/* Test creation/destruction */
{
do_test (gncVendorCreate (NULL) == NULL, "vendor create NULL");
vendor = gncVendorCreate (book);
do_test (vendor != NULL, "vendor create");
do_test (qof_instance_get_book (QOF_INSTANCE(vendor)) == book,
"getbook");
gncVendorBeginEdit (vendor);
gncVendorDestroy (vendor);
success ("create/destroy");
}
/* Test setting/getting routines; does the active flag get set right? */
{
GncGUID guid;
test_string_fcn (book, "Id", gncVendorSetID, gncVendorGetID);
test_string_fcn (book, "Name", gncVendorSetName, gncVendorGetName);
test_string_fcn (book, "Notes", gncVendorSetNotes, gncVendorGetNotes);
//test_string_fcn (book, "Terms", gncVendorSetTerms, gncVendorGetTerms);
//test_bool_fcn (book, "TaxIncluded", gncVendorSetTaxIncluded, gncVendorGetTaxIncluded);
test_bool_fcn (book, "Active", gncVendorSetActive, gncVendorGetActive);
do_test (gncVendorGetAddr (vendor) != NULL, "Addr");
guid_new (&guid);
vendor = gncVendorCreate (book);
count++;
gncVendorSetGUID (vendor, &guid);
do_test (guid_equal (&guid, qof_instance_get_guid(QOF_INSTANCE(vendor))), "guid compare");
}
{
GList *list;
list = gncBusinessGetList (book, GNC_ID_VENDOR, TRUE);
do_test (list != NULL, "getList all");
do_test (g_list_length (list) == count, "correct length: all");
g_list_free (list);
list = gncBusinessGetList (book, GNC_ID_VENDOR, FALSE);
do_test (list != NULL, "getList active");
do_test (g_list_length (list) == 1, "correct length: active");
g_list_free (list);
}
{
const char *str = get_random_string();
const char *res;
gncVendorSetName (vendor, str);
res = qof_object_printable (GNC_ID_VENDOR, vendor);
do_test (res != NULL, "Printable NULL?");
do_test (g_strcmp0 (str, res) == 0, "Printable equals");
}
qof_book_destroy (book);
}
static void
test_employee (void)
{
QofBackend *be;
QofBook *book;
QofSession *session;
GncEmployee *employee;
session = qof_session_new();
qof_session_begin(session, QOF_STDOUT, FALSE, FALSE);
book = qof_session_get_book(session);
/* The book *must* have a backend to pass the test of the 'dirty' flag */
/* See the README file for details */
be = qof_book_get_backend (book);
/* Test creation/destruction */
{
do_test (gncEmployeeCreate (NULL) == NULL, "employee create NULL");
employee = gncEmployeeCreate (book);
do_test (employee != NULL, "employee create");
do_test (qof_instance_get_book(QOF_INSTANCE(employee)) == book,
"getbook");
gncEmployeeBeginEdit (employee);
gncEmployeeDestroy (employee);
success ("create/destroy");
}
/* Test setting/getting routines; does the active flag get set right? */
{
GncGUID guid;
test_string_fcn (book, "Id", gncEmployeeSetID, gncEmployeeGetID);
test_string_fcn (book, "Username", gncEmployeeSetUsername, gncEmployeeGetUsername);
test_string_fcn (book, "Language", gncEmployeeSetLanguage, gncEmployeeGetLanguage);
test_string_fcn (book, "Acl", gncEmployeeSetAcl, gncEmployeeGetAcl);
test_numeric_fcn (book, "Workday", gncEmployeeSetWorkday, gncEmployeeGetWorkday);
test_numeric_fcn (book, "Rate", gncEmployeeSetRate, gncEmployeeGetRate);
test_bool_fcn (book, "Active", gncEmployeeSetActive, gncEmployeeGetActive);
do_test (gncEmployeeGetAddr (employee) != NULL, "Addr");
guid_new (&guid);
employee = gncEmployeeCreate (book);
count++;
gncEmployeeSetGUID (employee, &guid);
do_test (guid_equal (&guid, qof_instance_get_guid(QOF_INSTANCE(employee))), "guid compare");
}
#if 0
{
GList *list;
list = gncBusinessGetList (book, GNC_EMPLOYEE_MODULE_NAME, TRUE);
do_test (list != NULL, "getList all");
do_test (g_list_length (list) == count, "correct length: all");
g_list_free (list);
list = gncBusinessGetList (book, GNC_EMPLOYEE_MODULE_NAME, FALSE);
do_test (list != NULL, "getList active");
do_test (g_list_length (list) == 1, "correct length: active");
g_list_free (list);
}
#endif
{
const char *str = get_random_string();
const char *res;
GncAddress *addr;
addr = gncEmployeeGetAddr (employee);
gncAddressSetName (addr, str);
res = qof_object_printable (GNC_ID_EMPLOYEE, employee);
do_test (res != NULL, "Printable NULL?");
do_test (safe_strcmp (str, res) == 0, "Printable equals");
}
}
static void
cper_estatus_print_section(const char *pfx, struct acpi_hest_generic_data *gdata,
int sec_no)
{
guid_t *sec_type = (guid_t *)gdata->section_type;
__u16 severity;
char newpfx[64];
if (acpi_hest_get_version(gdata) >= 3)
cper_print_tstamp(pfx, (struct acpi_hest_generic_data_v300 *)gdata);
severity = gdata->error_severity;
printk("%s""Error %d, type: %s\n", pfx, sec_no,
cper_severity_str(severity));
if (gdata->validation_bits & CPER_SEC_VALID_FRU_ID)
printk("%s""fru_id: %pUl\n", pfx, gdata->fru_id);
if (gdata->validation_bits & CPER_SEC_VALID_FRU_TEXT)
printk("%s""fru_text: %.20s\n", pfx, gdata->fru_text);
snprintf(newpfx, sizeof(newpfx), "%s ", pfx);
if (guid_equal(sec_type, &CPER_SEC_PROC_GENERIC)) {
struct cper_sec_proc_generic *proc_err = acpi_hest_get_payload(gdata);
printk("%s""section_type: general processor error\n", newpfx);
if (gdata->error_data_length >= sizeof(*proc_err))
cper_print_proc_generic(newpfx, proc_err);
else
goto err_section_too_small;
} else if (guid_equal(sec_type, &CPER_SEC_PLATFORM_MEM)) {
struct cper_sec_mem_err *mem_err = acpi_hest_get_payload(gdata);
printk("%s""section_type: memory error\n", newpfx);
if (gdata->error_data_length >=
sizeof(struct cper_sec_mem_err_old))
cper_print_mem(newpfx, mem_err,
gdata->error_data_length);
else
goto err_section_too_small;
} else if (guid_equal(sec_type, &CPER_SEC_PCIE)) {
struct cper_sec_pcie *pcie = acpi_hest_get_payload(gdata);
printk("%s""section_type: PCIe error\n", newpfx);
if (gdata->error_data_length >= sizeof(*pcie))
cper_print_pcie(newpfx, pcie, gdata);
else
goto err_section_too_small;
#if defined(CONFIG_ARM64) || defined(CONFIG_ARM)
} else if (guid_equal(sec_type, &CPER_SEC_PROC_ARM)) {
struct cper_sec_proc_arm *arm_err = acpi_hest_get_payload(gdata);
printk("%ssection_type: ARM processor error\n", newpfx);
if (gdata->error_data_length >= sizeof(*arm_err))
cper_print_proc_arm(newpfx, arm_err);
else
goto err_section_too_small;
#endif
#if defined(CONFIG_UEFI_CPER_X86)
} else if (guid_equal(sec_type, &CPER_SEC_PROC_IA)) {
struct cper_sec_proc_ia *ia_err = acpi_hest_get_payload(gdata);
printk("%ssection_type: IA32/X64 processor error\n", newpfx);
if (gdata->error_data_length >= sizeof(*ia_err))
cper_print_proc_ia(newpfx, ia_err);
else
goto err_section_too_small;
#endif
} else {
const void *err = acpi_hest_get_payload(gdata);
printk("%ssection type: unknown, %pUl\n", newpfx, sec_type);
printk("%ssection length: %#x\n", newpfx,
gdata->error_data_length);
print_hex_dump(newpfx, "", DUMP_PREFIX_OFFSET, 16, 4, err,
gdata->error_data_length, true);
}
return;
err_section_too_small:
pr_err(FW_WARN "error section length is too small\n");
}
gint
guid_g_hash_table_equal (gconstpointer guid_a, gconstpointer guid_b)
{
return guid_equal (static_cast<const GncGUID*>(guid_a),
static_cast<const GncGUID*>(guid_b));
}
static const char*
equals_node_val_vs_split_internal (xmlNodePtr node, Split* spl)
{
xmlNodePtr mark;
for (mark = node->children; mark != NULL; mark = mark->next)
{
if (g_strcmp0 ((char*)mark->name, "split:id") == 0)
{
GncGUID* id = dom_tree_to_guid (mark);
if (!guid_equal (id, xaccSplitGetGUID (spl)))
{
g_free (id);
return "ids differ";
}
g_free (id);
}
else if (g_strcmp0 ((char*)mark->name, "split:memo") == 0)
{
char* memo = dom_tree_to_text (mark);
if (g_strcmp0 (memo, xaccSplitGetMemo (spl)) != 0)
{
g_free (memo);
return "memos differ";
}
g_free (memo);
}
else if (g_strcmp0 ((char*)mark->name, "split:reconciled-state") == 0)
{
char* rs = dom_tree_to_text (mark);
if (rs[0] != xaccSplitGetReconcile (spl))
{
g_free (rs);
return "states differ";
}
g_free (rs);
}
else if (g_strcmp0 ((char*)mark->name, "split:value") == 0)
{
gnc_numeric* num = dom_tree_to_gnc_numeric (mark);
gnc_numeric val = xaccSplitGetValue (spl);
if (!gnc_numeric_equal (*num, val))
{
g_free (num);
return g_strdup_printf ("values differ: %" G_GINT64_FORMAT "/%"
G_GINT64_FORMAT " v %" G_GINT64_FORMAT
"/%" G_GINT64_FORMAT,
(*num).num, (*num).denom,
val.num, val.denom);
}
g_free (num);
}
else if (g_strcmp0 ((char*)mark->name, "split:quantity") == 0)
{
gnc_numeric* num = dom_tree_to_gnc_numeric (mark);
gnc_numeric val = xaccSplitGetAmount (spl);
if (!gnc_numeric_equal (*num, val))
{
return g_strdup_printf ("quantities differ under _equal: %"
G_GINT64_FORMAT "/%" G_GINT64_FORMAT
" v %" G_GINT64_FORMAT "/%"
G_GINT64_FORMAT,
(*num).num, (*num).denom,
val.num, val.denom);
}
if (!gnc_numeric_equal (*num, val))
{
g_free (num);
return g_strdup_printf ("quantities differ: %" G_GINT64_FORMAT
"/%" G_GINT64_FORMAT " v %"
G_GINT64_FORMAT "/%" G_GINT64_FORMAT,
(*num).num, (*num).denom,
val.num, val.denom);
}
g_free (num);
}
else if (g_strcmp0 ((char*)mark->name, "split:account") == 0)
{
GncGUID* id = dom_tree_to_guid (mark);
Account* account = xaccSplitGetAccount (spl);
if (!guid_equal (id, xaccAccountGetGUID (account)))
{
g_free (id);
return "accounts differ";
}
g_free (id);
}
}
return NULL;
}
gint
guid_g_hash_table_equal (gconstpointer guid_a, gconstpointer guid_b)
{
return guid_equal (reinterpret_cast<const GncGUID*> (guid_a),
reinterpret_cast<const GncGUID*> (guid_b));
}
static void
test_customer (void)
{
QofBook *book;
GncCustomer *customer;
book = qof_book_new ();
/* Test creation/destruction */
{
do_test (gncCustomerCreate (NULL) == NULL, "customer create NULL");
customer = gncCustomerCreate (book);
do_test (customer != NULL, "customer create");
do_test (gncCustomerGetBook (customer) == book, "getbook");
gncCustomerBeginEdit (customer);
gncCustomerDestroy (customer);
success ("create/destroy");
}
/* Test setting/getting routines; does the active flag get set right? */
{
GncGUID guid;
test_string_fcn (book, "Id", gncCustomerSetID, gncCustomerGetID);
test_string_fcn (book, "Name", gncCustomerSetName, gncCustomerGetName);
test_string_fcn (book, "Notes", gncCustomerSetNotes, gncCustomerGetNotes);
//test_string_fcn (book, "Terms", gncCustomerSetTerms, gncCustomerGetTerms);
test_numeric_fcn (book, "Discount", gncCustomerSetDiscount, gncCustomerGetDiscount);
test_numeric_fcn (book, "Credit", gncCustomerSetCredit, gncCustomerGetCredit);
test_bool_fcn (book, "Active", gncCustomerSetActive, gncCustomerGetActive);
do_test (gncCustomerGetAddr (customer) != NULL, "Addr");
do_test (gncCustomerGetShipAddr (customer) != NULL, "ShipAddr");
guid_replace (&guid);
customer = gncCustomerCreate (book);
count++;
gncCustomerSetGUID (customer, &guid);
do_test (guid_equal (&guid, gncCustomerGetGUID (customer)), "guid compare");
}
{
GList *list;
list = gncBusinessGetList (book, GNC_ID_CUSTOMER, TRUE);
do_test (list != NULL, "getList all");
do_test (g_list_length (list) == count, "correct length: all");
g_list_free (list);
list = gncBusinessGetList (book, GNC_ID_CUSTOMER, FALSE);
do_test (list != NULL, "getList active");
do_test (g_list_length (list) == 1, "correct length: active");
g_list_free (list);
}
{
const char *str = get_random_string();
const char *res;
res = NULL;
gncCustomerBeginEdit(customer);
gncCustomerSetName (customer, str);
gncCustomerCommitEdit(customer);
res = qof_object_printable (GNC_ID_CUSTOMER, customer);
do_test (res != NULL, "Printable NULL?");
do_test (g_strcmp0 (str, res) == 0, "Printable equals");
}
do_test (gncCustomerGetJoblist (customer, TRUE) == NULL, "joblist empty");
/* Test the Entity Table */
{
const GncGUID *guid;
guid = gncCustomerGetGUID (customer);
do_test (gncCustomerLookup (book, guid) == customer, "Entity Table");
}
/* Note: JobList is tested from the Job tests */
qof_book_destroy (book);
}
