gboolean write_book_parts(FILE *out, QofBook *book) { xmlNodePtr domnode; domnode = guid_to_dom_tree(book_id_string, qof_book_get_guid(book)); xmlElemDump(out, NULL, domnode); xmlFreeNode (domnode); if (ferror(out) || fprintf(out, "\n") < 0) return FALSE; if (qof_instance_get_slots (QOF_INSTANCE (book))) { xmlNodePtr kvpnode = kvp_frame_to_dom_tree(book_slots_string, qof_instance_get_slots (QOF_INSTANCE (book))); if (kvpnode) { xmlElemDump(out, NULL, kvpnode); xmlFreeNode(kvpnode); if (ferror(out) || fprintf(out, "\n") < 0) return FALSE; } } return TRUE; }
static gboolean sx_defer_inst_handler( xmlNodePtr node, gpointer sx_pdata ) { struct sx_pdata *pdata = sx_pdata; SchedXaction *sx = pdata->sx; SXTmpStateData *tsd; g_return_val_if_fail( node, FALSE ); tsd = g_new0( SXTmpStateData, 1 ); g_assert( sx_defer_dom_handlers != NULL ); if ( !dom_tree_generic_parse( node, sx_defer_dom_handlers, tsd ) ) { xmlElemDump(stdout, NULL, node); g_free( tsd ); tsd = NULL; return FALSE; } /* We assume they were serialized in sorted order, here. */ sx->deferredList = g_list_append( sx->deferredList, tsd ); return TRUE; }
Transaction * dom_tree_to_transaction( xmlNodePtr node, QofBook *book ) { Transaction *trn; gboolean successful; struct trans_pdata pdata; g_return_val_if_fail(node, NULL); g_return_val_if_fail(book, NULL); trn = xaccMallocTransaction(book); g_return_val_if_fail(trn, NULL); xaccTransBeginEdit(trn); pdata.trans = trn; pdata.book = book; successful = dom_tree_generic_parse(node, trn_dom_handlers, &pdata); xaccTransCommitEdit(trn); if ( !successful ) { xmlElemDump(stdout, NULL, node); xaccTransBeginEdit(trn); xaccTransDestroy(trn); xaccTransCommitEdit(trn); trn = NULL; } return trn; }
void xml_parser_element_dump(FILE * f, WsXmlDocH doc, WsXmlNodeH node) { xmlNodePtr n = (xmlNodePtr) node; xmlDocPtr d = (xmlDocPtr) doc; xmlElemDump(f, d, n); }
/** * xslDbgCatToFile: * @node : Is valid * @file : Is valid * * Send the results of cat command in @node to @file */ void xslDbgCatToFile(xmlNodePtr node, FILE * file) { if (!node || !file) return; /* assume that HTML usage is enabled */ if (node->doc->type == XML_HTML_DOCUMENT_NODE) { if (node->type == XML_HTML_DOCUMENT_NODE) htmlDocDump(file, (htmlDocPtr) node); else htmlNodeDumpFile(file, node->doc, node); } else if (node->type == XML_DOCUMENT_NODE) { /* turn off encoding for the moment and just dump UTF-8 * which will be converted by xsldbgGeneralErrorFunc */ xmlDocPtr doc = (xmlDocPtr) node; const xmlChar *encoding = doc->encoding; if (encoding) { xsldbgGenericErrorFunc(i18n("Information: Temporarily setting document's encoding to UTF-8. Previously was %1.\n").arg(xsldbgText(encoding))); } doc->encoding = (xmlChar *) "UTF-8"; xmlDocDump(file, (xmlDocPtr) node); doc->encoding = encoding; } else { xmlElemDump(file, node->doc, node); } }
int main() { xmlDoc *doc = NULL; xmlNode *root = NULL, *node; const char **next; int a; doc = xmlNewDoc("1.0"); root = xmlNewNode(NULL, "CharacterRemarks"); xmlDocSetRootElement(doc, root); for(next = names, a = 0; *next != NULL; next++, a++) { node = xmlNewNode(NULL, "Character"); (void)xmlNewProp(node, "name", *next); xmlAddChild(node, xmlNewText(remarks[a])); xmlAddChild(root, node); } xmlElemDump(stdout, doc, root); xmlFreeDoc(doc); xmlCleanupParser(); return EXIT_SUCCESS; }
static void test_dom_tree_to_timespec(void) { int i; for (i = 0; i < 20; i++) { Timespec *test_spec1; Timespec test_spec2; xmlNodePtr test_node; test_spec1 = get_random_timespec(); test_node = timespec_to_dom_tree("test-spec", test_spec1); test_spec2 = dom_tree_to_timespec(test_node); if (!dom_tree_valid_timespec(&test_spec2, (const xmlChar*)"test-spec")) { failure_args("dom_tree_to_timespec", __FILE__, __LINE__, "NULL return"); printf("Node looks like:\n"); xmlElemDump(stdout, NULL, test_node); printf("\n"); } else if (timespec_cmp(test_spec1, &test_spec2) == 0) { success("dom_tree_to_timespec"); } else { failure("dom_tree_to_timespec"); printf("Node looks like:\n"); xmlElemDump(stdout, NULL, test_node); printf("\n"); printf("Secs are %" G_GUINT64_FORMAT " vs %" G_GUINT64_FORMAT " :: ", test_spec1->tv_sec, test_spec2.tv_sec); printf("NSecs are %ld vs %ld\n", test_spec1->tv_nsec, test_spec2.tv_nsec); } g_free(test_spec1); xmlFreeNode(test_node); } }
/* * call-seq: * node.debug_dump -> (true|nil) * * Dump this node to stdout, including any debugging * information. */ VALUE ruby_xml_node_debug_dump(VALUE self) { xmlNodePtr xnode; Data_Get_Struct(self, xmlNode, xnode); if (xnode->doc == NULL) return(Qnil); xmlElemDump(stdout, xnode->doc, xnode); return(Qtrue); }
void write_dom_node_to_file(xmlNodePtr node, int fd) { FILE *out; out = fdopen(fd, "w"); xmlElemDump(out, NULL, node); fclose(out); }
gboolean print_dom_tree(gpointer data_for_children, GSList* data_from_children, GSList* sibling_data, gpointer parent_data, gpointer global_data, gpointer *result, const gchar *tag) { if (parent_data == NULL) { xmlElemDump((FILE*)global_data, NULL, (xmlNodePtr)data_for_children); xmlFreeNode(static_cast<xmlNodePtr>(data_for_children)); } return TRUE; }
static gboolean gnc_commodity_end_handler(gpointer data_for_children, GSList* data_from_children, GSList* sibling_data, gpointer parent_data, gpointer global_data, gpointer *result, const gchar *tag) { gnc_commodity *com, *old_com; xmlNodePtr achild; xmlNodePtr tree = (xmlNodePtr)data_for_children; gxpf_data *gdata = (gxpf_data*)global_data; QofBook *book = static_cast<decltype(book)>(gdata->bookdata); if (parent_data) { return TRUE; } /* OK. For some messed up reason this is getting called again with a NULL tag. So we ignore those cases */ if (!tag) { return TRUE; } g_return_val_if_fail(tree, FALSE); com = gnc_commodity_new(book, NULL, NULL, NULL, NULL, 0); old_com = gnc_commodity_find_currency(book, tree); if (old_com) gnc_commodity_copy(com, old_com); for (achild = tree->xmlChildrenNode; achild; achild = achild->next) { set_commodity_value(achild, com); } if (!valid_commodity(com)) { PWARN("Invalid commodity parsed"); xmlElemDump(stdout, NULL, tree); printf("\n"); fflush(stdout); gnc_commodity_destroy(com); return FALSE; } gdata->cb(tag, gdata->parsedata, com); xmlFreeNode(tree); return TRUE; }
static void xml_add_billterm (QofInstance *term_p, gpointer out_p) { xmlNodePtr node; GncBillTerm *term = (GncBillTerm *) term_p; FILE *out = out_p; if (ferror(out)) return; node = billterm_dom_tree_create (term); xmlElemDump(out, NULL, node); xmlFreeNode (node); if (ferror(out) || fprintf(out, "\n") < 0) return; }
static void xml_add_taxtable (QofInstance * table_p, gpointer out_p) { xmlNodePtr node; GncTaxTable *table = (GncTaxTable *) table_p; FILE *out = out_p; if (ferror(out)) return; node = taxtable_dom_tree_create (table); xmlElemDump(out, NULL, node); xmlFreeNode (node); if (ferror(out) || fprintf(out, "\n") < 0) return; }
static void xml_add_order (QofInstance * order_p, gpointer out_p) { xmlNodePtr node; GncOrder *order = (GncOrder *) order_p; FILE *out = out_p; if (ferror(out)) return; if (!order_should_be_saved (order)) return; node = order_dom_tree_create (order); xmlElemDump(out, NULL, node); xmlFreeNode (node); if (ferror(out) || fprintf(out, "\n") < 0) return; }
static void xml_add_job (QofInstance * job_p, gpointer out_p) { xmlNodePtr node; GncJob *job = (GncJob *) job_p; FILE *out = out_p; if (ferror(out)) return; if (!job_should_be_saved (job)) return; node = job_dom_tree_create (job); xmlElemDump(out, NULL, node); xmlFreeNode (node); if (ferror(out) || fprintf(out, "\n") < 0) return; }
static void xml_add_vendor (QofInstance* vendor_p, gpointer out_p) { xmlNodePtr node; GncVendor* vendor = (GncVendor*) vendor_p; FILE* out = static_cast<decltype (out)> (out_p); if (ferror (out)) return; if (!vendor_should_be_saved (vendor)) return; node = vendor_dom_tree_create (vendor); xmlElemDump (out, NULL, node); xmlFreeNode (node); if (ferror (out) || fprintf (out, "\n") < 0) return; }
static void xml_add_employee (QofInstance * employee_p, gpointer out_p) { xmlNodePtr node; GncEmployee *employee = (GncEmployee *) employee_p; FILE *out = out_p; if (ferror(out)) return; if (!employee_should_be_saved (employee)) return; node = employee_dom_tree_create (employee); xmlElemDump(out, NULL, node); xmlFreeNode (node); if (ferror(out) || fprintf(out, "\n") < 0) return; }
static void xml_add_invoice (QofInstance* invoice_p, gpointer out_p) { xmlNodePtr node; GncInvoice* invoice = (GncInvoice*) invoice_p; FILE* out = static_cast<decltype (out)> (out_p); if (ferror (out)) return; if (!invoice_should_be_saved (invoice)) return; node = invoice_dom_tree_create (invoice); xmlElemDump (out, NULL, node); xmlFreeNode (node); if (ferror (out) || fprintf (out, "\n") < 0) return; }
static void xml_add_customer (QofInstance * cust_p, gpointer out_p) { xmlNodePtr node; GncCustomer *cust = (GncCustomer *) cust_p; FILE *out = out_p; if (ferror(out)) return; if (!customer_should_be_saved (cust)) return; node = customer_dom_tree_create (cust); xmlElemDump(out, NULL, node); xmlFreeNode (node); if (ferror(out) || fprintf(out, "\n") < 0) return; }
/** * function get_math_xhtml(xhtml) * * return the xml math tags from memory written in 'xhtml' */ std::vector<std::string> get_math_xhtml(const string& xhtml, const string& url) { const xmlChar *xpath = (const xmlChar*) "//m:math/m:semantics/m:annotation-xml[@encoding='MathML-Content']/*"; vector<string> harvest_exprs; xmlDocPtr doc = get_XMLDoc(xhtml.c_str()); xmlXPathObjectPtr result = get_XMLNodeset(doc, xpath); if (result != nullptr) { xmlNodeSetPtr nodeset = result->nodesetval; for (int i = 0; i < nodeset->nodeNr; ++i) { char* buf; size_t sz; FILE* stream = open_memstream(&buf, &sz); xmlChar* id = xmlGetProp( nodeset->nodeTab[i]->parent->parent->parent, (xmlChar*)"id"); fprintf(stream, "<mws:expr url=\"%s#%s\">\n", url.c_str(), id); xmlElemDump(stream, doc, nodeset->nodeTab[i]); fprintf(stream, "</mws:expr>\n"); fclose(stream); string str = (string)buf; if (is_good_xml(str)) { harvest_exprs.push_back(str); } xmlFree(id); free(buf); } xmlXPathFreeObject(result); } xmlFreeDoc(doc); // xmlCleanupParser(); should be called only at the end return harvest_exprs; }
static void xml_add_entry (QofInstance * entry_p, gpointer out_p) { xmlNodePtr node; GncEntry *entry = (GncEntry *) entry_p; FILE *out = out_p; if (ferror(out)) return; /* Don't save non-attached entries! */ if (!(gncEntryGetOrder (entry) || gncEntryGetInvoice (entry) || gncEntryGetBill (entry))) return; node = entry_dom_tree_create (entry); xmlElemDump(out, NULL, node); xmlFreeNode (node); if (ferror(out) || fprintf(out, "\n") < 0) return; }
static void test_dom_tree_to_text(void) { int i; for (i = 0; i < 20; i++) { gchar *test_string1; gchar *test_string2; xmlNodePtr test_node; test_node = xmlNewNode(NULL, BAD_CAST "test-node"); test_string1 = get_random_string(); xmlNodeAddContent(test_node, BAD_CAST test_string1); test_string2 = dom_tree_to_text(test_node); if (!test_string2) { failure_args("dom_tree_to_text", __FILE__, __LINE__, "null return from dom_tree_to_text"); xmlElemDump(stdout, NULL, test_node); } else if (g_strcmp0(test_string1, test_string2) == 0) { success_args("dom_tree_to_text", __FILE__, __LINE__, "with string %s", test_string1); } else { failure_args("dom_tree_to_text", __FILE__, __LINE__, "with string %s", test_string1); } xmlFreeNode(test_node); g_free(test_string1); if (test_string2) g_free(test_string2); } }
static gboolean gnc_schedXaction_end_handler(gpointer data_for_children, GSList* data_from_children, GSList* sibling_data, gpointer parent_data, gpointer global_data, gpointer *result, const gchar *tag) { SchedXaction *sx; gboolean successful = FALSE; xmlNodePtr tree = (xmlNodePtr)data_for_children; gxpf_data *gdata = (gxpf_data*)global_data; struct sx_pdata sx_pdata; if ( parent_data ) { return TRUE; } if ( !tag ) { return TRUE; } g_return_val_if_fail( tree, FALSE ); sx = xaccSchedXactionMalloc( gdata->bookdata ); memset(&sx_pdata, 0, sizeof(sx_pdata)); sx_pdata.sx = sx; sx_pdata.book = gdata->bookdata; g_assert( sx_dom_handlers != NULL ); successful = dom_tree_generic_parse( tree, sx_dom_handlers, &sx_pdata ); if (!successful) { g_critical("failed to parse scheduled xaction"); xmlElemDump( stdout, NULL, tree ); gnc_sx_begin_edit( sx ); xaccSchedXactionDestroy( sx ); goto done; } if (tree->properties) { gchar *sx_name = xaccSchedXactionGetName(sx); xmlAttr *attr; for (attr = tree->properties; attr != NULL; attr = attr->next) { xmlChar *attr_value = attr->children->content; g_debug("sx attribute name[%s] value[%s]", attr->name, attr_value); if (strcmp((const char *)attr->name, "version") != 0) { g_warning("unknown sx attribute [%s]", attr->name); continue; } // if version == 1.0.0: ensure freqspec, no recurrence // if version == 2.0.0: ensure recurrence, no freqspec. if (strcmp((const char *)attr_value, schedxaction_version_string) == 0) { if (!sx_pdata.saw_freqspec) g_critical("did not see freqspec in version 1 sx [%s]", sx_name); if (sx_pdata.saw_recurrence) g_warning("saw recurrence in supposedly version 1 sx [%s]", sx_name); } if (strcmp((const char *)attr_value, schedxaction_version2_string) == 0) { if (sx_pdata.saw_freqspec) g_warning("saw freqspec in version 2 sx [%s]", sx_name); if (!sx_pdata.saw_recurrence) g_critical("did not find recurrence in version 2 sx [%s]", sx_name); } } } // generic_callback -> book_callback: insert the SX in the book gdata->cb( tag, gdata->parsedata, sx ); /* FIXME: this should be removed somewhere near 1.8 release time. */ if ( sx->template_acct == NULL ) { Account *ra = NULL; const char *id = NULL; Account *acct = NULL; sixtp_gdv2 *sixdata = gdata->parsedata; QofBook *book; book = sixdata->book; /* We're dealing with a pre-200107<near-end-of-month> rgmerk change re: storing template accounts. */ /* Fix: get account with name of our GncGUID from the template accounts. Make that our template_acct pointer. */ /* THREAD-UNSAFE */ id = guid_to_string( xaccSchedXactionGetGUID( sx ) ); ra = gnc_book_get_template_root(book); if ( ra == NULL ) { g_warning( "Error getting template root account from being-parsed Book." ); xmlFreeNode( tree ); return FALSE; } acct = gnc_account_lookup_by_name( ra, id ); if ( acct == NULL ) { g_warning("no template account with name [%s]", id); xmlFreeNode( tree ); return FALSE; } g_debug("template account name [%s] for SX with GncGUID [%s]", xaccAccountGetName( acct ), id ); /* FIXME: free existing template account. * HUH????? We only execute this if there isn't * currently an existing template account, don't we? * <rgmerk> */ sx->template_acct = acct; } done: xmlFreeNode( tree ); return successful; }
static gboolean gnc_template_transaction_end_handler(gpointer data_for_children, GSList* data_from_children, GSList* sibling_data, gpointer parent_data, gpointer global_data, gpointer *result, const gchar *tag) { gboolean successful = FALSE; xmlNodePtr tree = data_for_children; gxpf_data *gdata = global_data; QofBook *book = gdata->bookdata; GList *n; gnc_template_xaction_data txd; txd.book = book; txd.accts = NULL; txd.transactions = NULL; /* the DOM tree will have an account tree [the template accounts] and a list of transactions [which will be members of the template account]. we want to parse through the dom trees for each, placing the null-parent account in the book's template-group slot, the others under it, and the transactions as normal. */ if ( parent_data ) { return TRUE; } if ( !tag ) { return TRUE; } g_return_val_if_fail( tree, FALSE ); successful = dom_tree_generic_parse( tree, tt_dom_handlers, &txd ); if ( successful ) { gdata->cb( tag, gdata->parsedata, &txd ); } else { g_warning("failed to parse template transaction"); xmlElemDump( stdout, NULL, tree ); } /* cleanup */ for ( n = txd.accts; n; n = n->next ) { n->data = NULL; } for ( n = txd.transactions; n; n = n->next ) { n->data = NULL; } g_list_free( txd.accts ); g_list_free( txd.transactions ); xmlFreeNode( tree ); return successful; }
static void test_transaction(void) { int i; for (i = 0; i < 50; i++) { Transaction *ran_trn; Account *root; xmlNodePtr test_node; gnc_commodity *com, *new_com; gchar *compare_msg; gchar *filename1; int fd; /* The next line exists for its side effect of creating the * account tree. */ root = get_random_account_tree(book); ran_trn = get_random_transaction(book); new_com = get_random_commodity( book ); if (!ran_trn) { failure_args("transaction_xml", __FILE__, __LINE__, "get_random_transaction returned NULL"); return; } { /* xaccAccountInsertSplit can reorder the splits. */ GList * list = g_list_copy(xaccTransGetSplitList (ran_trn)); GList * node = list; for ( ; node; node = node->next) { Split * s = node->data; Account * a = xaccMallocAccount(book); xaccAccountBeginEdit (a); xaccAccountSetCommodity( a, new_com ); xaccAccountSetCommoditySCU (a, xaccSplitGetAmount (s).denom); xaccAccountInsertSplit (a, s); xaccAccountCommitEdit (a); } g_list_free(list); } com = xaccTransGetCurrency (ran_trn); test_node = gnc_transaction_dom_tree_create(ran_trn); if (!test_node) { failure_args("transaction_xml", __FILE__, __LINE__, "gnc_transaction_dom_tree_create returned NULL"); really_get_rid_of_transaction(ran_trn); continue; } if ((compare_msg = node_and_transaction_equal(test_node, ran_trn)) != NULL) { failure_args("transaction_xml", __FILE__, __LINE__, "node and transaction were not equal: %s", compare_msg); xmlElemDump(stdout, NULL, test_node); printf("\n"); fflush(stdout); xmlFreeNode(test_node); really_get_rid_of_transaction(ran_trn); continue; } else { success_args("transaction_xml", __FILE__, __LINE__, "%d", i ); } filename1 = g_strdup_printf("test_file_XXXXXX"); fd = g_mkstemp(filename1); write_dom_node_to_file(test_node, fd); close(fd); { GList * node = xaccTransGetSplitList (ran_trn); for ( ; node; node = node->next) { Split * s = node->data; Account * a1 = xaccSplitGetAccount(s); Account * a2 = xaccMallocAccount(book); xaccAccountBeginEdit (a2); xaccAccountSetCommoditySCU (a2, xaccAccountGetCommoditySCU (a1)); xaccAccountSetGUID (a2, xaccAccountGetGUID (a1)); xaccAccountCommitEdit (a2); } } { sixtp *parser; tran_data data; data.trn = ran_trn; data.com = com; data.value = i; g_print(" There will follow a bunch of CRIT scrub errors about the account not having a commodity. There isn't an account in the XML, so of course not. Ignore the errors\n"); parser = gnc_transaction_sixtp_parser_create(); if (!gnc_xml_parse_file(parser, filename1, test_add_transaction, (gpointer)&data, book)) { failure_args("gnc_xml_parse_file returned FALSE", __FILE__, __LINE__, "%d", i); } else really_get_rid_of_transaction (data.new_trn); /* no handling of circular data structures. We'll do that later */ /* sixtp_destroy(parser); */ } g_unlink(filename1); g_free(filename1); really_get_rid_of_transaction(ran_trn); xmlFreeNode(test_node); } }
static void test_account (int i, Account* test_act) { xmlNodePtr test_node; gchar* filename1; gchar* compare_msg; int fd; test_node = gnc_account_dom_tree_create (test_act, FALSE, TRUE); if (!test_node) { failure_args ("account_xml", __FILE__, __LINE__, "gnc_account_dom_tree_create returned NULL"); return; } if ((compare_msg = node_and_account_equal (test_node, test_act)) != NULL) { failure_args ("account_xml", __FILE__, __LINE__, "node and account were not equal: %s", compare_msg); xmlElemDump (stdout, NULL, test_node); fprintf (stdout, "\n"); xmlFreeNode (test_node); g_free (compare_msg); return; } else { success ("account_xml"); } filename1 = g_strdup_printf ("test_file_XXXXXX"); fd = g_mkstemp (filename1); write_dom_node_to_file (test_node, fd); close (fd); { sixtp* parser; act_data data; data.act = test_act; data.value = i; parser = gnc_account_sixtp_parser_create (); if (!gnc_xml_parse_file (parser, filename1, test_add_account, &data, sixbook)) { failure_args ("gnc_xml_parse_file returned FALSE", __FILE__, __LINE__, "%d", i); } /* no handling of circular data structures. We'll do that later */ /* sixtp_destroy(parser); */ } g_unlink (filename1); g_free (filename1); xmlFreeNode (test_node); }
static void test_transaction (void) { int i; for (i = 0; i < 50; i++) { Transaction* ran_trn; xmlNodePtr test_node; gnc_commodity* com, *new_com; gchar* filename1; int fd; /* The next line exists for its side effect of creating the * account tree. */ get_random_account_tree (book); ran_trn = get_random_transaction (book); new_com = get_random_commodity (book); if (!ran_trn) { failure_args ("transaction_xml", __FILE__, __LINE__, "get_random_transaction returned NULL"); return; } { /* xaccAccountInsertSplit can reorder the splits. */ GList* list = g_list_copy (xaccTransGetSplitList (ran_trn)); GList* node = list; for (; node; node = node->next) { Split* s = static_cast<decltype (s)> (node->data); Account* a = xaccMallocAccount (book); xaccAccountBeginEdit (a); xaccAccountSetCommodity (a, new_com); xaccAccountSetCommoditySCU (a, xaccSplitGetAmount (s).denom); xaccAccountInsertSplit (a, s); xaccAccountCommitEdit (a); } g_list_free (list); } com = xaccTransGetCurrency (ran_trn); test_node = gnc_transaction_dom_tree_create (ran_trn); if (!test_node) { failure_args ("transaction_xml", __FILE__, __LINE__, "gnc_transaction_dom_tree_create returned NULL"); really_get_rid_of_transaction (ran_trn); continue; } auto compare_msg = node_and_transaction_equal (test_node, ran_trn); if (compare_msg != nullptr) { failure_args ("transaction_xml", __FILE__, __LINE__, "node and transaction were not equal: %s", compare_msg); xmlElemDump (stdout, NULL, test_node); printf ("\n"); fflush (stdout); xmlFreeNode (test_node); really_get_rid_of_transaction (ran_trn); continue; } else { success_args ("transaction_xml", __FILE__, __LINE__, "%d", i); } filename1 = g_strdup_printf ("test_file_XXXXXX"); fd = g_mkstemp (filename1); write_dom_node_to_file (test_node, fd); close (fd); { GList* node = xaccTransGetSplitList (ran_trn); for (; node; node = node->next) { Split* s = static_cast<decltype (s)> (node->data); Account* a1 = xaccSplitGetAccount (s); Account* a2 = xaccMallocAccount (book); xaccAccountBeginEdit (a2); xaccAccountSetCommoditySCU (a2, xaccAccountGetCommoditySCU (a1)); xaccAccountSetGUID (a2, xaccAccountGetGUID (a1)); xaccAccountCommitEdit (a2); } } { sixtp* parser; tran_data data; const char* msg = "[xaccAccountScrubCommodity()] Account \"\" does not have a commodity!"; const char* logdomain = "gnc.engine.scrub"; GLogLevelFlags loglevel = static_cast<decltype (loglevel)> (G_LOG_LEVEL_CRITICAL); TestErrorStruct check = { loglevel, const_cast<char*> (logdomain), const_cast<char*> (msg) }; g_log_set_handler (logdomain, loglevel, (GLogFunc)test_checked_handler, &check); data.trn = ran_trn; data.com = com; data.value = i; parser = gnc_transaction_sixtp_parser_create (); if (!gnc_xml_parse_file (parser, filename1, test_add_transaction, (gpointer)&data, book)) { failure_args ("gnc_xml_parse_file returned FALSE", __FILE__, __LINE__, "%d", i); } else really_get_rid_of_transaction (data.new_trn); } /* no handling of circular data structures. We'll do that later */ /* sixtp_destroy(parser); */ g_unlink (filename1); g_free (filename1); really_get_rid_of_transaction (ran_trn); xmlFreeNode (test_node); } }
static void test_generation (void) { int i; for (i = 0; i < 20; i++) { gnc_commodity* ran_com; xmlNodePtr test_node; gchar* filename1; int fd; ran_com = get_random_commodity (book); test_node = gnc_commodity_dom_tree_create (ran_com); if (!test_node) { failure_args ("commodity_xml", __FILE__, __LINE__, "gnc_commodity_dom_tree_create returned NULL"); gnc_commodity_destroy (ran_com); continue; } auto compare_msg = node_and_commodity_equal (test_node, ran_com); if (compare_msg != nullptr) { failure_args ("commodity_xml", __FILE__, __LINE__, "node and commodity were not equal: %s", compare_msg); xmlElemDump (stdout, NULL, test_node); xmlFreeNode (test_node); gnc_commodity_destroy (ran_com); continue; } else { success_args ("commodity_xml", __FILE__, __LINE__, "%d", i); } filename1 = g_strdup_printf ("test_file_XXXXXX"); fd = g_mkstemp (filename1); write_dom_node_to_file (test_node, fd); close (fd); { sixtp* parser; com_data data; data.com = ran_com; data.value = i; parser = gnc_commodity_sixtp_parser_create (); if (!gnc_xml_parse_file (parser, filename1, test_add_commodity, (gpointer)&data, book)) { failure_args ("gnc_xml_parse_file returned FALSE", __FILE__, __LINE__, "%d", i); } /* no handling of circular data structures. We'll do that later */ /* sixtp_destroy(parser); */ } g_unlink (filename1); g_free (filename1); gnc_commodity_destroy (ran_com); xmlFreeNode (test_node); } }