static void
test_dom_tree_to_commodity_ref(void)
{
int i;
for (i = 0; i < 20; i++)
{
gnc_commodity *test_com1;
gchar *test_str1;
gchar *test_str2;
gnc_commodity *test_com2;
xmlNodePtr test_node;
QofBook *book;
book = qof_book_new ();
test_str1 = get_random_string();
test_str2 = get_random_string();
test_com1 = gnc_commodity_new(book, NULL, test_str1, test_str2, NULL, 0);
test_node = commodity_ref_to_dom_tree("test-com", test_com1);
test_com2 = dom_tree_to_commodity_ref_no_engine(test_node, book);
do_test(gnc_commodity_equiv(test_com1, test_com2),
"dom_tree_to_commodity_ref_no_engine");
xmlFreeNode(test_node);
gnc_commodity_destroy(test_com1);
gnc_commodity_destroy(test_com2);
g_free(test_str1);
g_free(test_str2);
qof_book_destroy (book);
}
}
/// Test the blob name with corner characters.
TEST_FIXTURE(blob_test_base, corner_blob_name)
{
// Initialize the chareset to generate random blob name.
std::vector<utility::char_t> charset;
utility::string_t characters = _XPLATSTR("`~!@#$%^&*()_+[{]}|;:\'\",<>?");
for (size_t i = 0; i < characters.size(); ++i)
{
charset.push_back(characters[i]);
}
for (int i = 0; i < 16; ++i)
{
utility::string_t blob_name = get_random_string(charset, 20);
azure::storage::cloud_block_blob blob = m_container.get_block_blob_reference(blob_name);
auto content = get_random_string(charset, 20);
blob.upload_text(content);
// list the container to get the blob just created.
auto listing = list_all_blobs(blob_name, azure::storage::blob_listing_details::all, 0, azure::storage::blob_request_options());
CHECK(listing.size() == 1);
// check the consistance of blob content.
auto download_content = blob.download_text();
CHECK(content == download_content);
blob.delete_blob();
}
}
utility::string_t get_object_name(const utility::string_t& object_type_name)
{
utility::string_t object_name;
object_name.reserve(37U + object_type_name.size());
object_name.append(object_name_prefix);
object_name.append(object_type_name);
object_name.append(get_random_string());
return object_name;
}
static void test_create_ust_event_exclusion(void)
{
struct ltt_ust_event *event;
struct lttng_event ev;
char *name;
struct lttng_event_exclusion *exclusion;
memset(&ev, 0, sizeof(ev));
/* make a wildcarded event name */
name = get_random_string();
name[strlen(name) - 1] = '*';
strncpy(ev.name, name, LTTNG_SYMBOL_NAME_LEN);
ev.type = LTTNG_EVENT_TRACEPOINT;
ev.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
/* set up an exclusion set */
exclusion = zmalloc(sizeof(*exclusion) + LTTNG_SYMBOL_NAME_LEN);
if (!exclusion) {
PERROR("zmalloc");
}
ok(exclusion != NULL, "Create UST exclusion");
exclusion->count = 1;
strncpy((char *)(exclusion->names), get_random_string(), LTTNG_SYMBOL_NAME_LEN);
event = trace_ust_create_event(&ev, NULL, NULL, exclusion);
ok(event != NULL, "Create UST event with exclusion");
ok(event->enabled == 0 &&
event->attr.instrumentation == LTTNG_UST_TRACEPOINT &&
strcmp(event->attr.name, ev.name) == 0 &&
event->exclusion != NULL &&
event->exclusion->count == 1 &&
strcmp((char *)(event->exclusion->names), (char *)(exclusion->names)) == 0 &&
event->attr.name[LTTNG_UST_SYM_NAME_LEN - 1] == '\0',
"Validate UST event and exclusion");
trace_ust_destroy_event(event);
}
static void
test_string_fcn (GncAddress *address, const char *message,
void (*set) (GncAddress *, const char *str),
const char * (*get)(const GncAddress *))
{
char const *str = get_random_string ();
do_test (!gncAddressIsDirty (address), "test if start dirty");
set (address, str);
do_test (gncAddressIsDirty (address), "test dirty later");
do_test (g_strcmp0 (get (address), str) == 0, message);
gncAddressClearDirty (address);
}
pairs_st *pairs_generate(uint64_t number_of, size_t value_length)
{
unsigned int x;
pairs_st *pairs;
pairs= (pairs_st*)calloc((size_t)number_of + 1, sizeof(pairs_st));
if (!pairs)
goto error;
for (x= 0; x < number_of; x++)
{
pairs[x].key= (char *)calloc(100, sizeof(char));
if (!pairs[x].key)
goto error;
get_random_string(pairs[x].key, 100);
pairs[x].key_length= 100;
if (value_length)
{
pairs[x].value= (char *)calloc(value_length, sizeof(char));
if (!pairs[x].value)
goto error;
get_random_string(pairs[x].value, value_length);
pairs[x].value_length= value_length;
}
else
{
pairs[x].value= NULL;
pairs[x].value_length= 0;
}
}
return pairs;
error:
fprintf(stderr, "Memory Allocation failure in pairs_generate.\n");
exit(0);
}
// create max_files and fill with random data
// return list of {file name, content md5}
static GList *populate_file_list (gint max_files, GList *l_files, gchar *in_dir)
{
gint i;
gchar *out_dir;
GError *error = NULL;
FileData *fdata;
gchar *name;
FILE *f;
out_dir = g_dir_make_tmp (NULL, &error);
g_assert (out_dir);
LOG_debug (POOL_TEST, "In dir: %s Out dir: %s", in_dir, out_dir);
for (i = 0; i < max_files; i++) {
char *bytes;
size_t bytes_len;
fdata = g_new0 (FileData, 1);
fdata->checked = FALSE;
bytes_len = g_random_int_range (100000, 1000000);
bytes = g_malloc (bytes_len + 1);
RAND_pseudo_bytes ((unsigned char *)bytes, bytes_len);
*(bytes + bytes_len) = '\0';
name = get_random_string (15, TRUE);
fdata->in_name = g_strdup_printf ("%s/%s", in_dir, name);
f = fopen (fdata->in_name, "w");
fwrite (bytes, 1, bytes_len + 1, f);
fclose (f);
fdata->out_name = g_strdup_printf ("%s/%s", out_dir, name);
get_md5_sum (bytes, bytes_len + 1, &fdata->md5, NULL);
fdata->fout = fopen (fdata->out_name, "w");
g_assert (fdata->fout);
fdata->url = g_strdup_printf ("http://127.0.0.1:8011/%s", name);
g_assert (fdata->url);
LOG_debug (POOL_TEST, "%s -> %s, size: %u", fdata->in_name, fdata->md5, bytes_len);
l_files = g_list_append (l_files, fdata);
}
return l_files;
}
static void
test_string_fcn (QofBook *book, const char *message,
void (*set) (GncEmployee *, const char *str),
const char * (*get)(const GncEmployee *))
{
GncEmployee *employee = gncEmployeeCreate (book);
char const *str = get_random_string ();
do_test (!gncEmployeeIsDirty (employee), "test if start dirty");
gncEmployeeBeginEdit (employee);
set (employee, str);
do_test (gncEmployeeIsDirty (employee), "test dirty later");
gncEmployeeCommitEdit (employee);
do_test (gncEmployeeIsDirty (employee), "test dirty after commit");
do_test (safe_strcmp (get (employee), str) == 0, message);
gncEmployeeSetActive (employee, FALSE);
count++;
}
mychild*
child_create(QofBook *book)
{
mychild *g;
g_return_val_if_fail(book, NULL);
g = g_object_new(GNC_TYPE_MYCHILD, NULL);
qof_instance_init_data (&g->inst, CHILD_MODULE_NAME, book);
g->date = *get_random_timespec();
g->discount = get_random_double();
g->active = get_random_boolean();
g->version = get_random_int_in_range(1, 10000);
g->minor = get_random_int_in_range(100001, 99999999);
g->flag = get_random_character();
g->Name = get_random_string();
g->Amount = get_random_gnc_numeric();
qof_event_gen(&g->inst, QOF_EVENT_CREATE, NULL);
return g;
}
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 void test_create_ust_event(void)
{
struct ltt_ust_event *event;
struct lttng_event ev;
memset(&ev, 0, sizeof(ev));
strncpy(ev.name, get_random_string(), LTTNG_SYMBOL_NAME_LEN);
ev.type = LTTNG_EVENT_TRACEPOINT;
ev.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
event = trace_ust_create_event(&ev, NULL, NULL, NULL);
ok(event != NULL, "Create UST event");
ok(event->enabled == 0 &&
event->attr.instrumentation == LTTNG_UST_TRACEPOINT &&
strcmp(event->attr.name, ev.name) == 0 &&
event->attr.name[LTTNG_UST_SYM_NAME_LEN - 1] == '\0',
"Validate UST event");
trace_ust_destroy_event(event);
}
static void test_create_kernel_event(void)
{
struct ltt_kernel_event *event;
struct lttng_event ev;
memset(&ev, 0, sizeof(ev));
strncpy(ev.name, get_random_string(), LTTNG_KERNEL_SYM_NAME_LEN);
ev.type = LTTNG_EVENT_TRACEPOINT;
ev.loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
event = trace_kernel_create_event(&ev);
ok(event != NULL, "Create kernel event");
ok(event->fd == -1 &&
event->enabled == 1 &&
event->event->instrumentation == LTTNG_KERNEL_TRACEPOINT &&
strlen(event->event->name),
"Validate kernel event");
/* Init list in order to avoid sefaults from cds_list_del */
CDS_INIT_LIST_HEAD(&event->list);
trace_kernel_destroy_event(event);
}
static void
test_string_fcn (QofBook *book, const char *message,
void (*set) (GncEmployee *, const char *str),
const char * (*get)(const GncEmployee *))
{
GncEmployee *employee = gncEmployeeCreate (book);
char const *str = get_random_string ();
do_test (!gncEmployeeIsDirty (employee), "test if start dirty");
gncEmployeeBeginEdit (employee);
set (employee, str);
/* Employee record should be dirty */
do_test (gncEmployeeIsDirty (employee), "test dirty later");
gncEmployeeCommitEdit (employee);
/* Employee record should be not dirty */
/* Skip, because will always fail without a backend.
* It's not possible to load a backend in the engine code
* without having circular dependencies.
*/
// do_test (!gncEmployeeIsDirty (employee), "test dirty after commit");
do_test (g_strcmp0 (get (employee), str) == 0, message);
gncEmployeeSetActive (employee, FALSE);
count++;
}
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_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);
}
std::string http_client::build_post(std::string& content_type, const string_to_stringmap& postvars, const string_to_stringmap& filenames_in) const
{
if ( postvars.empty() && filenames_in.empty() )
return std::string();
string_to_stringmap filenames = filenames_in;
// sanitize the files
if ( !filenames.empty() )
{
string_to_stringmap::iterator var_names = filenames.begin();
while (var_names != filenames.end())
{
stringmap::iterator fnames = var_names->second.begin();
while( fnames != var_names->second.end() )
{
FILE *fp = ::fopen(fnames->second.c_str(), "rb");
if ( fp == NULL )
{
stringmap::iterator old_one = fnames++;
var_names->second.erase(old_one);
}
else
{
fclose(fp);
++fnames;
}
}
if ( fnames->second.empty() )
{
string_to_stringmap::iterator old_one = var_names++;
filenames.erase(old_one);
}
else
{
++var_names;
}
}
}
content_type = !filenames.empty() ? "multipart/form-data" : "application/x-www-form-urlencoded";
std::stringstream postBody;
if ( !filenames.empty() )
{
std::string mime_boundary = get_random_string(32);
// First add the form vars
for (string_to_stringmap::const_iterator ci = postvars.begin(); ci != postvars.end(); ++ci)
{
for (stringmap::const_iterator si = ci->second.begin(); si != ci->second.end(); ++si)
{
postBody << "--" << mime_boundary << "\r\n"
"Content-Disposition: form-data; name=\"" << ci->first << "\"\r\n\r\n"
<< si->second << "\r\n";
}
}
// Then add the files
for (string_to_stringmap::const_iterator ci = filenames.begin(); ci != filenames.end(); ++ci)
{
for (stringmap::const_iterator si = ci->second.begin(); si != ci->second.end(); ++si)
{
std::ifstream in(si->second.c_str());
postBody << "--" << mime_boundary << "\r\n"
"Content-Disposition: form-data; name=\"" << ci->first << "\"; filename=\"" << get_basename(si->second) << "\"\r\n\r\n"
<< in.rdbuf() << "\r\n";
}
}
postBody << "--" << mime_boundary << "--\r\n";
}
else
{
// No files...
for (string_to_stringmap::const_iterator ci = postvars.begin(); ci != postvars.end(); ++ci)
{
for (stringmap::const_iterator si = ci->second.begin(); si != ci->second.end(); ++si)
{
postBody << urlencode(ci->first) << '=' << urlencode(si->second) << '&';
}
}
// read the last '&'
char c;
postBody.read(&c, 1);
}
return postBody.str();
}
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);
}
void CDBConnection::execute(const TBiddingTxnInput* pIn, TBiddingTxnOutput* pOut){
pOut->status = CBaseTxnErr::SUCCESS;
char query[4096];
sql_result_t result;
int length;
char* val;
int r = 0;
string user_name;
string item_description;
string rec_description = get_random_string(128);
uint64_t bid;
uint64_t pid;
double cur_price;
double bid_price;
#ifndef QURO
sprintf(query, SELECT_ITEM, pIn->item_id);
//CLANG_PROFILE;
r = dbt5_sql_execute(query, &result, "GET_ITEM");
if(r==1 && result.result_set){
dbt5_sql_fetchrow(&result);
cur_price = atof(dbt5_sql_getvalue(&result, 0, length));
val = dbt5_sql_getvalue(&result, 1, length);
item_description.assign(val);
dbt5_sql_close_cursor(&result);
}else{
FAIL_MSG("GET_ITEM FAIL");
}
sprintf(query, GET_USER, pIn->user_id);
//CLANG_PROFILE;
r = dbt5_sql_execute(query, &result, "GET_USERS");
if(r==1 && result.result_set){
dbt5_sql_fetchrow(&result);
bid = atol(dbt5_sql_getvalue(&result, 0, length));
val = dbt5_sql_getvalue(&result, 1, length);
user_name.assign(val);
dbt5_sql_close_cursor(&result);
}else{
FAIL_MSG("GET_USER FAIL");
}
if(double(rand()%128)/128.0 < HIGHER_BID_THRESHOLD)
bid_price = cur_price + double(rand()%16)/16.0;
else
bid_price = cur_price - double(rand()%128)/128.0;
if(bid_price > cur_price){
BIDDING_UPDATE_ITEM;
}
BIDDING_UPDATE_USER;
BIDDING_INSERT_REC;
#else
sprintf(query, GET_USER, pIn->user_id);
//CLANG_PROFILE;
r = dbt5_sql_execute(query, &result, "GET_USERS");
if(r==1 && result.result_set){
dbt5_sql_fetchrow(&result);
bid = atol(dbt5_sql_getvalue(&result, 0, length));
val = dbt5_sql_getvalue(&result, 1, length);
user_name.assign(val);
dbt5_sql_close_cursor(&result);
}else{
FAIL_MSG("GET_USER FAIL");
}
BIDDING_UPDATE_USER;
sprintf(query, SELECT_ITEM, pIn->item_id);
//CLANG_PROFILE;
r = dbt5_sql_execute(query, &result, "GET_ITEM");
if(r==1 && result.result_set){
dbt5_sql_fetchrow(&result);
cur_price = atof(dbt5_sql_getvalue(&result, 0, length));
val = dbt5_sql_getvalue(&result, 1, length);
item_description.assign(val);
dbt5_sql_close_cursor(&result);
}else{
FAIL_MSG("GET_ITEM FAIL");
}
BIDDING_INSERT_REC;
if(bid_price > cur_price){
BIDDING_UPDATE_ITEM;
}
#endif
}
void test_random_perms()
{
for(int i = 0; i < 5; ++i)
{
options_t options;
std::vector<std::string> args;
args.push_back("osm2pgsql");
//pick a projection
options.projection.reset(reprojection::create_projection(get_random_proj(args)));
//pick a style file
std::string style = get_random_string(15);
options.style = style.c_str();
args.push_back("--style");
args.push_back(style);
add_arg_and_val_or_not("--cache", args, options.cache, rand() % 800);
add_arg_and_val_or_not("--database", args, options.database_options.db.c_str(), get_random_string(6));
if (options.database_options.username) {
add_arg_and_val_or_not("--username", args, options.database_options.username->c_str(), get_random_string(6));
}
if (options.database_options.host) {
add_arg_and_val_or_not("--host", args, options.database_options.host->c_str(), get_random_string(6));
}
//add_arg_and_val_or_not("--port", args, options.port, rand() % 9999);
//--hstore-match-only
//--hstore-column Add an additional hstore (key/value) column containing all tags that start with the specified string, eg --hstore-column "name:" will produce an extra hstore column that contains all name:xx tags
add_arg_or_not("--hstore-add-index", args, options.enable_hstore_index);
//--tablespace-index The name of the PostgreSQL tablespace where all indexes will be created. The following options allow more fine-grained control:
// --tablespace-main-data tablespace for main tables
// --tablespace-main-index tablespace for main table indexes
// --tablespace-slim-data tablespace for slim mode tables
// --tablespace-slim-index tablespace for slim mode indexes
// (if unset, use db's default; -i is equivalent to setting
// --tablespace-main-index and --tablespace-slim-index)
add_arg_and_val_or_not("--number-processes", args, options.num_procs, rand() % 12);
//add_arg_or_not("--disable-parallel-indexing", args, options.parallel_indexing);
add_arg_or_not("--unlogged", args, options.unlogged);
//--cache-strategy Specifies the method used to cache nodes in ram. Available options are: dense chunk sparse optimized
if (options.flat_node_file) {
add_arg_and_val_or_not("--flat-nodes", args, options.flat_node_file->c_str(), get_random_string(15));
}
//--expire-tiles [min_zoom-]max_zoom Create a tile expiry list.
add_arg_and_val_or_not("--expire-output", args, options.expire_tiles_filename.c_str(), get_random_string(15));
//--bbox Apply a bounding box filter on the imported data Must be specified as: minlon,minlat,maxlon,maxlat e.g. --bbox -0.5,51.25,0.5,51.75
add_arg_and_val_or_not("--prefix", args, options.prefix.c_str(), get_random_string(15));
//--input-reader Input frontend. auto, o5m, xml, pbf
if (options.tag_transform_script) {
add_arg_and_val_or_not("--tag-transform-script", args, options.tag_transform_script->c_str(), get_random_string(15));
}
add_arg_or_not("--extra-attributes", args, options.extra_attributes);
add_arg_or_not("--multi-geometry", args, options.enable_multi);
add_arg_or_not("--keep-coastlines", args, options.keep_coastlines);
add_arg_or_not("--exclude-invalid-polygon", args, options.excludepoly);
//add the input file
args.push_back("tests/liechtenstein-2013-08-03.osm.pbf");
const char** argv = new const char*[args.size() + 1];
argv[args.size()] = nullptr;
for(std::vector<std::string>::const_iterator arg = args.begin(); arg != args.end(); ++arg)
argv[arg - args.begin()] = arg->c_str();
options_t((int) args.size(), const_cast<char **>(argv));
delete[] argv;
}
}
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");
}
}
TEST_FIXTURE(file_directory_test_base, directory_list_files_and_directories)
{
m_directory.create_if_not_exists(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
azure::storage::list_file_and_diretory_result_iterator end_of_list;
for (auto iter = m_share.get_root_directory_reference().list_files_and_directories(); iter != end_of_list; ++iter)
{
CHECK_EQUAL(iter->is_directory(), true);
CHECK_EQUAL(iter->is_file(), false);
auto directory = iter->as_directory();
check_equal(directory, m_directory);
CHECK(directory.get_parent_share_reference().is_valid());
check_equal(m_share, directory.get_parent_share_reference());
CHECK(!directory.uri().primary_uri().is_empty());
CHECK(directory.metadata().empty());
CHECK(directory.properties().etag().empty());
CHECK(!directory.properties().last_modified().is_initialized());
}
// more complicated file structure.
const size_t size = 2;
std::vector<utility::string_t> directories;
std::vector<utility::string_t> files;
for (size_t i = 0; i < size; ++i)
{
directories.push_back(_XPLATSTR("directory") + get_random_string(10));
}
for (size_t i = 0; i < size; ++i)
{
files.push_back(_XPLATSTR("file") + get_random_string(10));
}
for (size_t i = 0; i < size; ++i)
{
auto directory = m_share.get_directory_reference(directories[i]);
directory.create_if_not_exists(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
for (size_t j = 0; j < size; ++j)
{
auto subdirectory = directory.get_subdirectory_reference(directories[j]);
subdirectory.create_if_not_exists(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
for (size_t k = 0; k < size; ++k)
{
auto file = subdirectory.get_file_reference(files[k]);
file.create_if_not_exists(512U, azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
}
}
for (size_t j = 0; j < size; ++j)
{
auto file = directory.get_file_reference(files[j]);
file.create_if_not_exists(512U, azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
}
auto file = m_share.get_root_directory_reference().get_file_reference(files[i]);
file.create_if_not_exists(512U, azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
}
auto direcotries_one = directories;
auto files_one = files;
for (auto iter = m_share.get_root_directory_reference().list_files_and_directories(); iter != end_of_list; ++iter)
{
if (iter->is_directory())
{
auto directory2 = iter->as_directory();
CHECK(directory2.get_parent_share_reference().is_valid());
check_equal(m_share, directory2.get_parent_share_reference());
CHECK(!directory2.uri().primary_uri().is_empty());
CHECK(directory2.metadata().empty());
CHECK(directory2.properties().etag().empty());
CHECK(!directory2.properties().last_modified().is_initialized());
auto found = false;
for (auto directory_name = direcotries_one.begin(); directory_name != direcotries_one.end(); directory_name++)
{
if (*directory_name == directory2.name())
{
direcotries_one.erase(directory_name);
found = true;
break;
}
}
auto direcotries_two = directories;
auto files_two = files;
for (auto iter2 = directory2.list_files_and_directories(); found && iter2 != end_of_list; ++iter2)
{
if (iter2->is_directory())
{
auto directory3 = iter2->as_directory();
CHECK(directory3.get_parent_share_reference().is_valid());
check_equal(m_share, directory3.get_parent_share_reference());
CHECK(!directory3.uri().primary_uri().is_empty());
CHECK(directory3.metadata().empty());
CHECK(directory3.properties().etag().empty());
CHECK(!directory3.properties().last_modified().is_initialized());
for (auto directory_name = direcotries_two.begin(); directory_name != direcotries_two.end(); directory_name++)
{
if (*directory_name == directory3.name())
{
direcotries_two.erase(directory_name);
break;
}
}
auto files_three = files;
for (auto iter3 = directory3.list_files_and_directories(); iter3 != end_of_list; ++iter3)
{
CHECK(iter3->is_file());
auto file = iter3->as_file();
CHECK(file.get_parent_share_reference().is_valid());
check_equal(m_share, file.get_parent_share_reference());
CHECK(!file.uri().primary_uri().is_empty());
CHECK(file.metadata().empty());
CHECK(file.properties().etag().empty());
CHECK(!file.properties().last_modified().is_initialized());
for (auto file_name = files_three.begin(); file_name != files_three.end(); file_name++)
{
if (*file_name == file.name())
{
files_three.erase(file_name);
break;
}
}
}
CHECK(files_three.empty());
}
else if (iter2->is_file())
{
auto file = iter2->as_file();
CHECK(file.get_parent_share_reference().is_valid());
check_equal(m_share, file.get_parent_share_reference());
CHECK(!file.uri().primary_uri().is_empty());
CHECK(file.metadata().empty());
CHECK(file.properties().etag().empty());
CHECK(!file.properties().last_modified().is_initialized());
for (auto file_name = files_two.begin(); file_name != files_two.end(); file_name++)
{
if (*file_name == file.name())
{
files_two.erase(file_name);
break;
}
}
}
}
CHECK(!found || direcotries_two.empty());
CHECK(!found || files_two.empty());
}
else if (iter->is_file())
{
auto file = iter->as_file();
CHECK(file.get_parent_share_reference().is_valid());
check_equal(m_share, file.get_parent_share_reference());
CHECK(!file.uri().primary_uri().is_empty());
CHECK(file.metadata().empty());
CHECK(file.properties().etag().empty());
CHECK(!file.properties().last_modified().is_initialized());
for (auto file_name = files_one.begin(); file_name != files_one.end(); file_name++)
{
if (*file_name == file.name())
{
files_one.erase(file_name);
break;
}
}
}
}
CHECK(direcotries_one.empty());
CHECK(files_one.empty());
}
void child_run(struct child_struct *child0, const char *loadfile)
{
int i;
char line[MAX_PARM_LEN], fname[MAX_PARM_LEN], fname2[MAX_PARM_LEN];
char **sparams, **params;
char *p;
const char *status;
gzFile *gzf;
pid_t parent = getppid();
double targett;
struct child_struct *child;
int have_random = 0;
unsigned loop_count = 0;
z_off_t loop_start = 0;
gzf = gzopen(loadfile, "r");
if (gzf == NULL) {
perror(loadfile);
exit(1);
}
for (child=child0;child<child0+options.clients_per_process;child++) {
child->line = 0;
asprintf(&child->cname,"client%d", child->id);
}
sparams = calloc(20, sizeof(char *));
for (i=0;i<20;i++) {
sparams[i] = malloc(MAX_PARM_LEN);
memset(sparams[i], 0, MAX_PARM_LEN);
}
again:
for (child=child0;child<child0+options.clients_per_process;child++) {
nb_time_reset(child);
}
while (gzgets(gzf, line, sizeof(line)-1)) {
unsigned repeat_count = 1;
for (child=child0;child<child0+options.clients_per_process;child++) {
if (child->done) goto done;
child->line++;
}
params = sparams;
if (kill(parent, 0) == -1) {
exit(1);
}
loop_again:
/* if this is a "LOOP <xxx>" line,
* remember the current file position and move to the next line
*/
if (strncmp(line, "LOOP", 4) == 0) {
if (sscanf(line, "LOOP %u\n", &loop_count) != 1) {
fprintf(stderr, "Incorrect LOOP at line %d\n", child0->line);
goto done;
}
for (child=child0;child<child0+options.clients_per_process;child++) {
child->line++;
}
loop_start = gztell(gzf);
gzgets(gzf, line, sizeof(line)-1);
goto loop_again;
}
if (strncmp(line, "ENDLOOP", 7) == 0) {
loop_count--;
gzgets(gzf, line, sizeof(line)-1);
if (loop_count > 0) {
gzseek(gzf, loop_start, SEEK_SET);
}
gzgets(gzf, line, sizeof(line)-1);
goto loop_again;
}
/* if this is a "REPEAT <xxx>" line, just replace the
* currently read line with the next line
*/
if (strncmp(line, "REPEAT", 6) == 0) {
if (sscanf(line, "REPEAT %u\n", &repeat_count) != 1) {
fprintf(stderr, "Incorrect REPEAT at line %d\n", child0->line);
goto done;
}
for (child=child0;child<child0+options.clients_per_process;child++) {
child->line++;
}
gzgets(gzf, line, sizeof(line)-1);
}
/* WRITEPATTERN */
if (strncmp(line, "WRITEPATTERN", 12) == 0) {
char *ptr = rw_buf;
int count = RWBUFSIZE;
while (count > 0) {
int len;
len = count;
if (len > strlen(line +13)) {
len = strlen(line +13);
}
memcpy(ptr, line+13, len);
ptr += len;
count -= len;
}
goto again;
}
/* RANDOMSTRING */
if (strncmp(line, "RANDOMSTRING", 12) == 0) {
have_random = 1;
if (parse_randomstring(line) != 0) {
fprintf(stderr, "Incorrect RANDOMSTRING at line %d\n", child0->line);
goto done;
}
goto again;
}
line[strlen(line)-1] = 0;
all_string_sub(line,"\\", "/");
all_string_sub(line," /", " ");
/* substitute all $<digit> stored strings */
while (have_random && (p = index(line, '$')) != NULL) {
char sstr[3], *nstr;
unsigned int idx;
idx = *(p+1) - '0';
if (idx >= MAX_RND_STR) {
fprintf(stderr, "$%d is an invalid filename/string\n", idx);
goto done;
}
sstr[0] = '$';
sstr[1] = idx+'0';
sstr[2] = '\0';
nstr = get_random_string(idx);
all_string_sub(line, sstr, nstr);
}
p = line;
for (i=0;
i<19 && next_token(&p, params[i], " ");
i++) ;
params[i][0] = 0;
if (i < 2 || params[0][0] == '#') continue;
if (!strncmp(params[0],"SMB", 3)) {
printf("ERROR: You are using a dbench 1 load file\n");
exit(1);
}
if (i > 0 && isdigit(params[0][0])) {
targett = strtod(params[0], NULL);
params++;
i--;
} else {
targett = 0.0;
}
if (strncmp(params[i-1], "NT_STATUS_", 10) != 0 &&
strncmp(params[i-1], "0x", 2) != 0 &&
strncmp(params[i-1], "SUCCESS", 7) != 0 &&
strncmp(params[i-1], "ERROR", 7) != 0 &&
strncmp(params[i-1], "*", 1) != 0) {
printf("Badly formed status at line %d\n", child->line);
continue;
}
status = params[i-1];
for (child=child0;child<child0+options.clients_per_process;child++) {
unsigned child_repeat_count = repeat_count;
int pcount = 1;
fname[0] = 0;
fname2[0] = 0;
if (i>1 && params[1][0] == '/') {
snprintf(fname, sizeof(fname), "%s%s", child->directory, params[1]);
all_string_sub(fname,"client1", child->cname);
pcount++;
}
if (i>2 && params[2][0] == '/') {
snprintf(fname2, sizeof(fname2), "%s%s", child->directory, params[2]);
all_string_sub(fname2,"client1", child->cname);
pcount++;
}
if (options.targetrate != 0 || targett == 0.0) {
nb_target_rate(child, options.targetrate);
} else {
nb_time_delay(child, targett);
}
while (child_repeat_count--) {
child_op(child, params[0], fname, fname2, params+pcount, status);
}
}
}
if (options.run_once) {
goto done;
}
gzrewind(gzf);
goto again;
done:
gzclose(gzf);
for (child=child0;child<child0+options.clients_per_process;child++) {
child->cleanup = 1;
fflush(stdout);
if (!options.skip_cleanup) {
nb_ops->cleanup(child);
}
child->cleanup_finished = 1;
if(child->cname){
free(child->cname);
child->cname = NULL;
}
}
}
TEST_FIXTURE(file_directory_test_base, directory_list_files_and_directories_with_prefix)
{
m_directory.create_if_not_exists(azure::storage::file_access_condition(), azure::storage::file_request_options(), m_context);
auto prefix = _XPLATSTR("t") + get_random_string(3);
auto dir_prefix = prefix + _XPLATSTR("dir");
auto file_prefix = prefix + _XPLATSTR("file");
auto exclude_prefix = _XPLATSTR("exclude");
std::vector<azure::storage::cloud_file_directory> directories;
std::vector<azure::storage::cloud_file> files;
for (int i = 0; i < get_random_int32() % 3 + 1; ++i)
{
auto subdirectory = m_directory.get_subdirectory_reference(dir_prefix + utility::conversions::print_string(i));
subdirectory.create();
directories.push_back(subdirectory);
auto file = m_directory.get_file_reference(file_prefix + utility::conversions::print_string(i));
file.create(1);
files.push_back(file);
m_directory.get_subdirectory_reference(exclude_prefix + utility::conversions::print_string(i)).create();
}
int num_items_expected = directories.size() + files.size();
int num_items_actual = 0;
for (auto&& item : m_directory.list_files_and_directories(prefix))
{
++num_items_actual;
if (item.is_directory())
{
auto actual = item.as_directory();
CHECK(actual.get_parent_share_reference().is_valid());
check_equal(m_share, actual.get_parent_share_reference());
auto it_found = std::find_if(directories.begin(), directories.end(), [&actual](const azure::storage::cloud_file_directory& expect)
{
return actual.name() == expect.name();
});
CHECK(it_found != directories.end());
check_equal(*it_found, actual);
directories.erase(it_found);
}
else if (item.is_file())
{
auto actual = item.as_file();
CHECK(actual.get_parent_share_reference().is_valid());
check_equal(m_share, actual.get_parent_share_reference());
auto it_found = std::find_if(files.begin(), files.end(), [&actual](const azure::storage::cloud_file& expect)
{
return actual.name() == expect.name();
});
CHECK(it_found != files.end());
check_equal(*it_found, actual);
files.erase(it_found);
}
}
CHECK_EQUAL(num_items_expected, num_items_actual);
CHECK(directories.empty());
CHECK(files.empty());
}
