/* * 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); }