static void read_write_notimeout(abts_case *tc, void *data)
{
apr_status_t rv;
char *buf = "this is a test";
char *input;
apr_size_t nbytes;
nbytes = strlen("this is a test");
rv = apr_file_pipe_create(&readp, &writep, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, readp);
ABTS_PTR_NOTNULL(tc, writep);
rv = apr_file_write(writep, buf, &nbytes);
ABTS_INT_EQUAL(tc, strlen("this is a test"), nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
nbytes = 256;
input = apr_pcalloc(p, nbytes + 1);
rv = apr_file_read(readp, input, &nbytes);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, strlen("this is a test"), nbytes);
ABTS_STR_EQUAL(tc, "this is a test", input);
}
static void broadcast_threads(abts_case *tc, void *data)
{
toolbox_t box;
unsigned int i;
apr_status_t rv;
apr_uint32_t count = 0;
apr_thread_cond_t *cond = NULL;
apr_thread_mutex_t *mutex = NULL;
apr_thread_t *thread[NTHREADS];
rv = apr_thread_cond_create(&cond, p);
ABTS_SUCCESS(rv);
ABTS_PTR_NOTNULL(tc, cond);
rv = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, p);
ABTS_SUCCESS(rv);
ABTS_PTR_NOTNULL(tc, mutex);
rv = apr_thread_mutex_lock(mutex);
ABTS_SUCCESS(rv);
box.tc = tc;
box.data = &count;
box.mutex = mutex;
box.cond = cond;
box.func = lock_and_wait;
for (i = 0; i < NTHREADS; i++) {
rv = apr_thread_create(&thread[i], NULL, thread_routine, &box, p);
ABTS_SUCCESS(rv);
}
do {
rv = apr_thread_mutex_unlock(mutex);
ABTS_SUCCESS(rv);
apr_sleep(100000);
rv = apr_thread_mutex_lock(mutex);
ABTS_SUCCESS(rv);
} while (apr_atomic_read32(&count) != NTHREADS);
rv = apr_thread_cond_broadcast(cond);
ABTS_SUCCESS(rv);
rv = apr_thread_mutex_unlock(mutex);
ABTS_SUCCESS(rv);
for (i = 0; i < NTHREADS; i++) {
apr_status_t retval;
rv = apr_thread_join(&retval, thread[i]);
ABTS_SUCCESS(rv);
}
ABTS_INT_EQUAL(tc, 0, count);
rv = apr_thread_cond_destroy(cond);
ABTS_SUCCESS(rv);
rv = apr_thread_mutex_destroy(mutex);
ABTS_SUCCESS(rv);
}
static void merge_lowercasedrive(abts_case *tc, void *data)
{
char current_dir[1024];
char current_dir_on_C[1024];
char *dir_on_c;
char *testdir;
apr_status_t rv;
/* Change the current directory on C: from something like "C:\dir"
to something like "c:\dir" to replicate the failing case. */
ABTS_PTR_NOTNULL(tc, _getcwd(current_dir, sizeof(current_dir)));
/* 3 stands for drive C: */
ABTS_PTR_NOTNULL(tc, _getdcwd(3, current_dir_on_C,
sizeof(current_dir_on_C)));
/* Use the same path, but now with a lower case driveletter */
dir_on_c = apr_pstrdup(p, current_dir_on_C);
dir_on_c[0] = (char)tolower(dir_on_c[0]);
chdir(dir_on_c);
/* Now merge a drive relative path with an upper case drive letter. */
rv = apr_filepath_merge(&testdir, NULL, "C:hi",
APR_FILEPATH_NOTRELATIVE, p);
/* Change back to original directory for next tests */
chdir("C:\\"); /* Switch to upper case */
chdir(current_dir_on_C); /* Switch cwd on C: */
chdir(current_dir); /* Switch back to original cwd */
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
static void test_dup2(abts_case *tc, void *data)
{
apr_file_t *testfile = NULL;
apr_file_t *errfile = NULL;
apr_file_t *saveerr = NULL;
apr_status_t rv;
rv = apr_file_open(&testfile, FILEPATH "testdup2.file",
APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE |
APR_FOPEN_DELONCLOSE, APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, testfile);
rv = apr_file_open_stderr(&errfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Set aside the real errfile */
rv = apr_file_dup(&saveerr, errfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, saveerr);
rv = apr_file_dup2(errfile, testfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, errfile);
apr_file_close(testfile);
rv = apr_file_dup2(errfile, saveerr, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, errfile);
apr_file_close(saveerr);
}
static void test_file_dup(abts_case *tc, void *data)
{
apr_file_t *file1 = NULL;
apr_file_t *file3 = NULL;
apr_status_t rv;
apr_finfo_t finfo;
/* First, create a new file, empty... */
rv = apr_file_open(&file1, FILEPATH "testdup.file",
APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE |
APR_FOPEN_DELONCLOSE, APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, file1);
rv = apr_file_dup(&file3, file1, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, file3);
rv = apr_file_close(file1);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* cleanup after ourselves */
rv = apr_file_close(file3);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_stat(&finfo, FILEPATH "testdup.file", APR_FINFO_NORM, p);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_ENOENT(rv));
}
static void test_dbd_sqlite3(abts_case *tc, void *data)
{
apr_pool_t *pool = p;
apr_status_t rv;
const apr_dbd_driver_t* driver = NULL;
apr_dbd_t* handle = NULL;
rv = apr_dbd_get_driver(pool, "sqlite3", &driver);
ABTS_ASSERT(tc, "failed to fetch sqlite3 driver", rv == APR_SUCCESS);
ABTS_PTR_NOTNULL(tc, driver);
if (!driver) {
return;
}
ABTS_STR_EQUAL(tc, "sqlite3", apr_dbd_name(driver));
rv = apr_dbd_open(driver, pool, "data/sqlite3.db", &handle);
ABTS_ASSERT(tc, "failed to open sqlite3 database", rv == APR_SUCCESS);
ABTS_PTR_NOTNULL(tc, handle);
if (!handle) {
return;
}
test_dbd_generic(tc, handle, driver);
}
static void test_dso_sym(abts_case *tc, void *data)
{
apr_dso_handle_t *h = NULL;
apr_dso_handle_sym_t func1 = NULL;
apr_status_t status;
void (*function)(char str[256]);
char teststr[256];
char errstr[256];
status = apr_dso_load(&h, modname, p);
ABTS_ASSERT(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
ABTS_PTR_NOTNULL(tc, h);
status = apr_dso_sym(&func1, h, "print_hello");
ABTS_ASSERT(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
ABTS_PTR_NOTNULL(tc, func1);
if (!tc->failed) {
function = (void (*)(char *))func1;
(*function)(teststr);
ABTS_STR_EQUAL(tc, "Hello - I'm a DSO!\n", teststr);
}
apr_dso_unload(h);
}
static void overlay_empty(abts_case *tc, void *data)
{
apr_hash_t *base = NULL;
apr_hash_t *overlay = NULL;
apr_hash_t *result = NULL;
int count;
char StrArray[MAX_DEPTH][MAX_LTH];
base = apr_hash_make(p);
overlay = apr_hash_make(p);
ABTS_PTR_NOTNULL(tc, base);
ABTS_PTR_NOTNULL(tc, overlay);
apr_hash_set(base, "key1", APR_HASH_KEY_STRING, "value1");
apr_hash_set(base, "key2", APR_HASH_KEY_STRING, "value2");
apr_hash_set(base, "key3", APR_HASH_KEY_STRING, "value3");
apr_hash_set(base, "key4", APR_HASH_KEY_STRING, "value4");
apr_hash_set(base, "key5", APR_HASH_KEY_STRING, "value5");
result = apr_hash_overlay(p, overlay, base);
count = apr_hash_count(result);
ABTS_INT_EQUAL(tc, 5, count);
dump_hash(p, result, StrArray);
ABTS_STR_EQUAL(tc, "Key key1 (4) Value value1\n", StrArray[0]);
ABTS_STR_EQUAL(tc, "Key key2 (4) Value value2\n", StrArray[1]);
ABTS_STR_EQUAL(tc, "Key key3 (4) Value value3\n", StrArray[2]);
ABTS_STR_EQUAL(tc, "Key key4 (4) Value value4\n", StrArray[3]);
ABTS_STR_EQUAL(tc, "Key key5 (4) Value value5\n", StrArray[4]);
ABTS_STR_EQUAL(tc, "#entries 5\n", StrArray[5]);
}
static void pollcb_default(abts_case *tc, void *data)
{
apr_status_t rv1, rv2;
apr_pollcb_t *pollcb;
/* verify that APR will successfully create a pollcb if an invalid method
* is specified as long as APR_POLLSET_NODEFAULT isn't specified
* (no platform has both APR_POLLSET_PORT and APR_POLLSET_KQUEUE, so at
* least one create call will succeed after having to switch to the default
* type)
*/
rv1 = apr_pollcb_create_ex(&pollcb, 1, p, 0, APR_POLLSET_PORT);
if (rv1 == APR_ENOTIMPL) {
ABTS_NOT_IMPL(tc, "pollcb interface not supported");
return;
}
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv1);
ABTS_PTR_NOTNULL(tc, pollcb);
rv1 = apr_pollcb_create_ex(&pollcb, 1, p, 0, APR_POLLSET_KQUEUE);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv1);
ABTS_PTR_NOTNULL(tc, pollcb);
/* verify that APR will fail to create a pollcb if an invalid method is
* specified along with APR_POLLSET_NODEFAULT
* (no platform has both APR_POLLSET_PORT and APR_POLLSET_KQUEUE, so at
* least one create call will fail since it can't switch to the default
* type)
*/
rv1 = apr_pollcb_create_ex(&pollcb, 1, p, APR_POLLSET_NODEFAULT,
APR_POLLSET_PORT);
if (rv1 == APR_SUCCESS) {
ABTS_PTR_NOTNULL(tc, pollcb);
}
rv2 = apr_pollcb_create_ex(&pollcb, 1, p, APR_POLLSET_NODEFAULT,
APR_POLLSET_KQUEUE);
if (rv2 == APR_SUCCESS) {
ABTS_PTR_NOTNULL(tc, pollcb);
}
ABTS_ASSERT(tc,
"failure using APR_POLLSET_NODEFAULT with unsupported method",
rv1 != APR_SUCCESS || rv2 != APR_SUCCESS);
/* verify basic behavior for another method fallback case (this caused
* APR to crash before r834029)
*/
rv1 = apr_pollcb_create_ex(&pollcb, 1, p, 0, APR_POLLSET_POLL);
if (rv1 != APR_ENOTIMPL) {
ABTS_INT_EQUAL(tc, rv1, APR_SUCCESS);
ABTS_PTR_NOTNULL(tc, pollcb);
}
}
static void create_pipe(abts_case *tc, void *data)
{
apr_status_t rv;
rv = apr_file_pipe_create(&readp, &writep, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, readp);
ABTS_PTR_NOTNULL(tc, writep);
}
static void root_from_cwd_and_back(abts_case *tc, void *data)
{
apr_status_t rv;
const char *root = NULL;
const char *path = "//";
char *origpath;
char *testpath;
int hadfailed;
ABTS_INT_EQUAL(tc, APR_SUCCESS, apr_filepath_get(&origpath, 0, p));
path = origpath;
rv = apr_filepath_root(&root, &path, APR_FILEPATH_TRUENAME, p);
#if defined(WIN32) || defined(OS2)
hadfailed = tc->failed;
/* It appears some mingw/cygwin and more modern builds can return
* a lowercase drive designation, but we canonicalize to uppercase
*/
ABTS_INT_EQUAL(tc, toupper(origpath[0]), root[0]);
ABTS_INT_EQUAL(tc, ':', root[1]);
ABTS_INT_EQUAL(tc, '/', root[2]);
ABTS_INT_EQUAL(tc, 0, root[3]);
ABTS_STR_EQUAL(tc, origpath + 3, path);
#elif defined(NETWARE)
ABTS_INT_EQUAL(tc, origpath[0], root[0]);
{
char *pt = strchr(root, ':');
ABTS_PTR_NOTNULL(tc, pt);
ABTS_INT_EQUAL(tc, ':', pt[0]);
ABTS_INT_EQUAL(tc, '/', pt[1]);
ABTS_INT_EQUAL(tc, 0, pt[2]);
pt = strchr(origpath, ':');
ABTS_PTR_NOTNULL(tc, pt);
ABTS_STR_EQUAL(tc, (pt+2), path);
}
#else
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, "/", root);
ABTS_STR_EQUAL(tc, origpath + 1, path);
#endif
rv = apr_filepath_merge(&testpath, root, path,
APR_FILEPATH_TRUENAME
| APR_FILEPATH_NOTABOVEROOT
| APR_FILEPATH_NOTRELATIVE, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
hadfailed = tc->failed;
/* The API doesn't promise equality!!!
* apr_filepath_get never promised a canonical filepath.
* We'll emit noise under verbose so the user is aware,
* but translate this back to success.
*/
ABTS_STR_EQUAL(tc, origpath, testpath);
#if defined(WIN32) || defined(OS2) || defined(NETWARE)
if (!hadfailed) tc->failed = 0;
#endif
}
static void test_mmap_contents(abts_case *tc, void *data)
{
ABTS_PTR_NOTNULL(tc, themmap);
ABTS_PTR_NOTNULL(tc, themmap->mm);
ABTS_SIZE_EQUAL(tc, thisfsize, themmap->size);
/* Must use nEquals since the string is not guaranteed to be NULL terminated */
ABTS_STR_NEQUAL(tc, themmap->mm, TEST_STRING, thisfsize);
}
static void test_str(abts_case *tc, void *data)
{
apr_pool_t *pool = p;
const apr_strmatch_pattern *pattern;
const apr_strmatch_pattern *pattern_nocase;
const apr_strmatch_pattern *pattern_onechar;
const apr_strmatch_pattern *pattern_zero;
const char *match = NULL;
const char *input1 = "string that contains a patterN...";
const char *input2 = "string that contains a pattern...";
const char *input3 = "pattern at the start of a string";
const char *input4 = "string that ends with a pattern";
const char *input5 = "patter\200n not found, negative chars in input";
const char *input6 = "patter\200n, negative chars, contains pattern...";
pattern = apr_strmatch_precompile(pool, "pattern", 1);
ABTS_PTR_NOTNULL(tc, pattern);
pattern_nocase = apr_strmatch_precompile(pool, "pattern", 0);
ABTS_PTR_NOTNULL(tc, pattern_nocase);
pattern_onechar = apr_strmatch_precompile(pool, "g", 0);
ABTS_PTR_NOTNULL(tc, pattern_onechar);
pattern_zero = apr_strmatch_precompile(pool, "", 0);
ABTS_PTR_NOTNULL(tc, pattern_zero);
match = apr_strmatch(pattern, input1, strlen(input1));
ABTS_PTR_EQUAL(tc, match, NULL);
match = apr_strmatch(pattern, input2, strlen(input2));
ABTS_PTR_EQUAL(tc, match, input2 + 23);
match = apr_strmatch(pattern_onechar, input1, strlen(input1));
ABTS_PTR_EQUAL(tc, match, input1 + 5);
match = apr_strmatch(pattern_zero, input1, strlen(input1));
ABTS_PTR_EQUAL(tc, match, input1);
match = apr_strmatch(pattern_nocase, input1, strlen(input1));
ABTS_PTR_EQUAL(tc, match, input1 + 23);
match = apr_strmatch(pattern, input3, strlen(input3));
ABTS_PTR_EQUAL(tc, match, input3);
match = apr_strmatch(pattern, input4, strlen(input4));
ABTS_PTR_EQUAL(tc, match, input4 + 24);
match = apr_strmatch(pattern, input5, strlen(input5));
ABTS_PTR_EQUAL(tc, match, NULL);
match = apr_strmatch(pattern, input6, strlen(input6));
ABTS_PTR_EQUAL(tc, match, input6 + 35);
}
static void test_cond(abts_case *tc, void *data)
{
apr_thread_t *p1, *p2, *p3, *p4, *c1;
apr_status_t s0, s1, s2, s3, s4;
int count1, count2, count3, count4;
int sum;
APR_ASSERT_SUCCESS(tc, "create put mutex",
apr_thread_mutex_create(&put.mutex,
APR_THREAD_MUTEX_DEFAULT, p));
ABTS_PTR_NOTNULL(tc, put.mutex);
APR_ASSERT_SUCCESS(tc, "create nready mutex",
apr_thread_mutex_create(&nready.mutex,
APR_THREAD_MUTEX_DEFAULT, p));
ABTS_PTR_NOTNULL(tc, nready.mutex);
APR_ASSERT_SUCCESS(tc, "create condvar",
apr_thread_cond_create(&nready.cond, p));
ABTS_PTR_NOTNULL(tc, nready.cond);
count1 = count2 = count3 = count4 = 0;
put.nput = put.nval = 0;
nready.nready = 0;
i = 0;
x = 0;
s0 = apr_thread_create(&p1, NULL, thread_cond_producer, &count1, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, s0);
s1 = apr_thread_create(&p2, NULL, thread_cond_producer, &count2, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, s1);
s2 = apr_thread_create(&p3, NULL, thread_cond_producer, &count3, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, s2);
s3 = apr_thread_create(&p4, NULL, thread_cond_producer, &count4, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, s3);
s4 = apr_thread_create(&c1, NULL, thread_cond_consumer, NULL, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, s4);
apr_thread_join(&s0, p1);
apr_thread_join(&s1, p2);
apr_thread_join(&s2, p3);
apr_thread_join(&s3, p4);
apr_thread_join(&s4, c1);
APR_ASSERT_SUCCESS(tc, "destroy condvar",
apr_thread_cond_destroy(nready.cond));
sum = count1 + count2 + count3 + count4;
/*
printf("count1 = %d count2 = %d count3 = %d count4 = %d\n",
count1, count2, count3, count4);
*/
ABTS_INT_EQUAL(tc, MAX_COUNTER, sum);
}
static void test_dup2_readwrite(abts_case *tc, void *data)
{
apr_file_t *errfile = NULL;
apr_file_t *testfile = NULL;
apr_file_t *saveerr = NULL;
apr_status_t rv;
apr_size_t txtlen = sizeof(TEST);
char buff[50];
apr_off_t fpos;
rv = apr_file_open(&testfile, FILEPATH "testdup2.readwrite.file",
APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE |
APR_FOPEN_DELONCLOSE, APR_OS_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, testfile);
rv = apr_file_open_stderr(&errfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* Set aside the real errfile */
rv = apr_file_dup(&saveerr, errfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, saveerr);
rv = apr_file_dup2(errfile, testfile, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, errfile);
txtlen = sizeof(TEST2);
rv = apr_file_write(errfile, TEST2, &txtlen);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_SIZE_EQUAL(tc, sizeof(TEST2), txtlen);
fpos = 0;
rv = apr_file_seek(testfile, APR_SET, &fpos);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_ASSERT(tc, "File position mismatch, expected 0", fpos == 0);
txtlen = 50;
rv = apr_file_read(testfile, buff, &txtlen);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, TEST2, buff);
apr_file_close(testfile);
rv = apr_file_dup2(errfile, saveerr, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, errfile);
apr_file_close(saveerr);
}
static void select_rows(abts_case *tc, apr_dbd_t* handle,
const apr_dbd_driver_t* driver, int count)
{
apr_status_t rv;
apr_pool_t* pool = p;
apr_pool_t* tpool;
const char* sql = "SELECT * FROM apr_dbd_test ORDER BY col1";
apr_dbd_results_t *res = NULL;
apr_dbd_row_t *row = NULL;
int i;
rv = apr_dbd_select(driver, pool, handle, &res, sql, 0);
ABTS_ASSERT(tc, sql, rv == APR_SUCCESS);
ABTS_PTR_NOTNULL(tc, res);
apr_pool_create(&tpool, pool);
i = count;
while (i > 0) {
row = NULL;
rv = apr_dbd_get_row(driver, pool, res, &row, -1);
ABTS_ASSERT(tc, sql, rv == APR_SUCCESS);
ABTS_PTR_NOTNULL(tc, row);
apr_pool_clear(tpool);
i--;
}
ABTS_ASSERT(tc, "Missing Rows!", i == 0);
res = NULL;
i = count;
rv = apr_dbd_select(driver, pool, handle, &res, sql, 1);
ABTS_ASSERT(tc, sql, rv == APR_SUCCESS);
ABTS_PTR_NOTNULL(tc, res);
rv = apr_dbd_num_tuples(driver, res);
ABTS_ASSERT(tc, "invalid row count", rv == count);
while (i > 0) {
row = NULL;
rv = apr_dbd_get_row(driver, pool, res, &row, i);
ABTS_ASSERT(tc, sql, rv == APR_SUCCESS);
ABTS_PTR_NOTNULL(tc, row);
apr_pool_clear(tpool);
i--;
}
ABTS_ASSERT(tc, "Missing Rows!", i == 0);
rv = apr_dbd_get_row(driver, pool, res, &row, count+100);
ABTS_ASSERT(tc, "If we overseek, get_row should return -1", rv == -1);
}
static void test_shm_allocate(abts_case *tc, void *data)
{
apr_status_t rv;
apr_shm_t *shm = NULL;
rv = apr_shm_create(&shm, SHARED_SIZE, NULL, p);
APR_ASSERT_SUCCESS(tc, "Error allocating shared memory block", rv);
ABTS_PTR_NOTNULL(tc, shm);
boxes = apr_shm_baseaddr_get(shm);
ABTS_PTR_NOTNULL(tc, boxes);
rv = apr_shm_destroy(shm);
APR_ASSERT_SUCCESS(tc, "Error destroying shared memory block", rv);
}
static void test_anon(abts_case *tc, void *data)
{
apr_proc_t proc;
apr_status_t rv;
apr_shm_t *shm;
apr_size_t retsize;
int cnt, i;
int recvd;
rv = apr_shm_create(&shm, SHARED_SIZE, NULL, p);
APR_ASSERT_SUCCESS(tc, "Error allocating shared memory block", rv);
ABTS_PTR_NOTNULL(tc, shm);
retsize = apr_shm_size_get(shm);
ABTS_INT_EQUAL(tc, SHARED_SIZE, retsize);
boxes = apr_shm_baseaddr_get(shm);
ABTS_PTR_NOTNULL(tc, boxes);
rv = apr_proc_fork(&proc, p);
if (rv == APR_INCHILD) { /* child */
int num = msgwait(5, 0, N_BOXES);
/* exit with the number of messages received so that the parent
* can check that all messages were received.
*/
exit(num);
}
else if (rv == APR_INPARENT) { /* parent */
i = N_BOXES;
cnt = 0;
while (cnt++ < N_MESSAGES) {
if ((i-=3) < 0) {
i += N_BOXES; /* start over at the top */
}
msgput(i, MSG);
apr_sleep(apr_time_make(0, 10000));
}
}
else {
ABTS_FAIL(tc, "apr_proc_fork failed");
}
/* wait for the child */
rv = apr_proc_wait(&proc, &recvd, NULL, APR_WAIT);
ABTS_INT_EQUAL(tc, N_MESSAGES, recvd);
rv = apr_shm_destroy(shm);
APR_ASSERT_SUCCESS(tc, "Error destroying shared memory block", rv);
}
static void test_dbd_generic(abts_case *tc, apr_dbd_t* handle,
const apr_dbd_driver_t* driver)
{
void* native;
apr_pool_t *pool = p;
apr_status_t rv;
native = apr_dbd_native_handle(driver, handle);
ABTS_PTR_NOTNULL(tc, native);
rv = apr_dbd_check_conn(driver, pool, handle);
create_table(tc, handle, driver);
select_rows(tc, handle, driver, 0);
insert_data(tc, handle, driver, 5);
select_rows(tc, handle, driver, 5);
delete_rows(tc, handle, driver);
select_rows(tc, handle, driver, 0);
drop_table(tc, handle, driver);
test_escape(tc, handle, driver);
rv = apr_dbd_close(driver, handle);
ABTS_ASSERT(tc, "failed to close database", rv == APR_SUCCESS);
}
static void dynamic_binding(abts_case *tc, void *data)
{
unsigned int i;
apr_status_t rv;
toolbox_t box[NTHREADS];
apr_thread_t *thread[NTHREADS];
apr_thread_mutex_t *mutex[NTHREADS];
apr_thread_cond_t *cond = NULL;
rv = apr_thread_cond_create(&cond, p);
ABTS_SUCCESS(rv);
ABTS_PTR_NOTNULL(tc, cond);
for (i = 0; i < NTHREADS; i++) {
rv = apr_thread_mutex_create(&mutex[i], APR_THREAD_MUTEX_DEFAULT, p);
ABTS_SUCCESS(rv);
rv = apr_thread_mutex_lock(mutex[i]);
ABTS_SUCCESS(rv);
box[i].tc = tc;
box[i].cond = cond;
box[i].mutex = mutex[i];
box[i].func = lock_and_signal;
rv = apr_thread_create(&thread[i], NULL, thread_routine, &box[i], p);
ABTS_SUCCESS(rv);
}
/*
* The dynamic binding should be preserved because we use only one waiter
*/
for (i = 0; i < NTHREADS; i++) {
rv = apr_thread_cond_wait(cond, mutex[i]);
ABTS_SUCCESS(rv);
}
for (i = 0; i < NTHREADS; i++) {
rv = apr_thread_cond_timedwait(cond, mutex[i], 10000);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv));
rv = apr_thread_mutex_unlock(mutex[i]);
ABTS_SUCCESS(rv);
}
for (i = 0; i < NTHREADS; i++) {
apr_status_t retval;
rv = apr_thread_join(&retval, thread[i]);
ABTS_SUCCESS(rv);
}
rv = apr_thread_cond_destroy(cond);
ABTS_SUCCESS(rv);
for (i = 0; i < NTHREADS; i++) {
rv = apr_thread_mutex_destroy(mutex[i]);
ABTS_SUCCESS(rv);
}
}
/* This is kind of a hack, but I am just keeping an existing test. This is
* really testing apr_hash_first, apr_hash_next, and apr_hash_this which
* should be tested in three separate tests, but this will do for now.
*/
static void summation_test(abts_case *tc, void *data)
{
apr_hash_t *h;
int sumKeys, sumVal, trySumKey, trySumVal;
int i, j, *val, *key;
h =apr_hash_make(p);
ABTS_PTR_NOTNULL(tc, h);
sumKeys = 0;
sumVal = 0;
trySumKey = 0;
trySumVal = 0;
for (i = 0; i < 100; i++) {
j = i * 10 + 1;
sumKeys += j;
sumVal += i;
key = apr_palloc(p, sizeof(int));
*key = j;
val = apr_palloc(p, sizeof(int));
*val = i;
apr_hash_set(h, key, sizeof(int), val);
}
sum_hash(p, h, &i, &trySumKey, &trySumVal);
ABTS_INT_EQUAL(tc, 100, i);
ABTS_INT_EQUAL(tc, sumVal, trySumVal);
ABTS_INT_EQUAL(tc, sumKeys, trySumKey);
}
static void timeout_pollin_pollcb(abts_case *tc, void *data)
{
apr_status_t rv;
pollcb_baton_t pcb;
apr_pollfd_t socket_pollfd;
POLLCB_PREREQ;
recv_msg(s, 0, p, tc);
ABTS_PTR_NOTNULL(tc, s[0]);
socket_pollfd.desc_type = APR_POLL_SOCKET;
socket_pollfd.reqevents = APR_POLLIN;
socket_pollfd.desc.s = s[0];
socket_pollfd.client_data = s[0];
rv = apr_pollcb_add(pollcb, &socket_pollfd);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
pcb.count = 0;
pcb.tc = tc;
rv = apr_pollcb_poll(pollcb, 1, trigger_pollcb_cb, &pcb);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv));
ABTS_INT_EQUAL(tc, 0, pcb.count);
rv = apr_pollcb_remove(pollcb, &socket_pollfd);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
static void trigger_pollcb(abts_case *tc, void *data)
{
apr_status_t rv;
apr_pollfd_t socket_pollfd;
pollcb_baton_t pcb;
POLLCB_PREREQ;
ABTS_PTR_NOTNULL(tc, s[0]);
socket_pollfd.desc_type = APR_POLL_SOCKET;
socket_pollfd.reqevents = APR_POLLIN;
socket_pollfd.desc.s = s[0];
socket_pollfd.client_data = s[0];
rv = apr_pollcb_add(pollcb, &socket_pollfd);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
send_msg(s, sa, 0, tc);
pcb.tc = tc;
pcb.count = 0;
rv = apr_pollcb_poll(pollcb, -1, trigger_pollcb_cb, &pcb);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, 1, pcb.count);
rv = apr_pollcb_remove(pollcb, &socket_pollfd);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
static void hash_make(abts_case *tc, void *data)
{
apr_hash_t *h = NULL;
h = apr_hash_make(p);
ABTS_PTR_NOTNULL(tc, h);
}
static void delete_key(abts_case *tc, void *data)
{
apr_hash_t *h = NULL;
char *result = NULL;
h = apr_hash_make(p);
ABTS_PTR_NOTNULL(tc, h);
apr_hash_set(h, "key", APR_HASH_KEY_STRING, "value");
apr_hash_set(h, "key2", APR_HASH_KEY_STRING, "value2");
result = apr_hash_get(h, "key", APR_HASH_KEY_STRING);
ABTS_STR_EQUAL(tc, "value", result);
result = apr_hash_get(h, "key2", APR_HASH_KEY_STRING);
ABTS_STR_EQUAL(tc, "value2", result);
apr_hash_set(h, "key", APR_HASH_KEY_STRING, NULL);
result = apr_hash_get(h, "key", APR_HASH_KEY_STRING);
ABTS_PTR_EQUAL(tc, NULL, result);
result = apr_hash_get(h, "key2", APR_HASH_KEY_STRING);
ABTS_STR_EQUAL(tc, "value2", result);
}
static void test_thread_mutex(abts_case *tc, void *data)
{
apr_thread_t *t1, *t2, *t3, *t4;
apr_status_t s1, s2, s3, s4;
s1 = apr_thread_mutex_create(&thread_mutex, APR_THREAD_MUTEX_DEFAULT, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, s1);
ABTS_PTR_NOTNULL(tc, thread_mutex);
i = 0;
x = 0;
s1 = apr_thread_create(&t1, NULL, thread_mutex_function, NULL, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, s1);
s2 = apr_thread_create(&t2, NULL, thread_mutex_function, NULL, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, s2);
s3 = apr_thread_create(&t3, NULL, thread_mutex_function, NULL, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, s3);
s4 = apr_thread_create(&t4, NULL, thread_mutex_function, NULL, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, s4);
apr_thread_join(&s1, t1);
apr_thread_join(&s2, t2);
apr_thread_join(&s3, t3);
apr_thread_join(&s4, t4);
ABTS_INT_EQUAL(tc, MAX_ITER, x);
}
static void test_thread_rwlock(abts_case *tc, void *data)
{
apr_thread_t *t1, *t2, *t3, *t4;
apr_status_t s1, s2, s3, s4;
s1 = apr_thread_rwlock_create(&rwlock, p);
if (s1 == APR_ENOTIMPL) {
ABTS_NOT_IMPL(tc, "rwlocks not implemented");
return;
}
APR_ASSERT_SUCCESS(tc, "rwlock_create", s1);
ABTS_PTR_NOTNULL(tc, rwlock);
i = 0;
x = 0;
s1 = apr_thread_create(&t1, NULL, thread_rwlock_func, NULL, p);
APR_ASSERT_SUCCESS(tc, "create thread 1", s1);
s2 = apr_thread_create(&t2, NULL, thread_rwlock_func, NULL, p);
APR_ASSERT_SUCCESS(tc, "create thread 2", s2);
s3 = apr_thread_create(&t3, NULL, thread_rwlock_func, NULL, p);
APR_ASSERT_SUCCESS(tc, "create thread 3", s3);
s4 = apr_thread_create(&t4, NULL, thread_rwlock_func, NULL, p);
APR_ASSERT_SUCCESS(tc, "create thread 4", s4);
apr_thread_join(&s1, t1);
apr_thread_join(&s2, t2);
apr_thread_join(&s3, t3);
apr_thread_join(&s4, t4);
ABTS_INT_EQUAL(tc, MAX_ITER, x);
apr_thread_rwlock_destroy(rwlock);
}
/* This is kind of a hack, but I am just keeping an existing test. This is
* really testing apr_hash_first, apr_hash_next, and apr_hash_this which
* should be tested in three separate tests, but this will do for now.
*/
static void hash_traverse(abts_case *tc, void *data)
{
apr_hash_t *h;
char StrArray[MAX_DEPTH][MAX_LTH];
h = apr_hash_make(p);
ABTS_PTR_NOTNULL(tc, h);
apr_hash_set(h, "OVERWRITE", APR_HASH_KEY_STRING, "should not see this");
apr_hash_set(h, "FOO3", APR_HASH_KEY_STRING, "bar3");
apr_hash_set(h, "FOO3", APR_HASH_KEY_STRING, "bar3");
apr_hash_set(h, "FOO1", APR_HASH_KEY_STRING, "bar1");
apr_hash_set(h, "FOO2", APR_HASH_KEY_STRING, "bar2");
apr_hash_set(h, "FOO4", APR_HASH_KEY_STRING, "bar4");
apr_hash_set(h, "SAME1", APR_HASH_KEY_STRING, "same");
apr_hash_set(h, "SAME2", APR_HASH_KEY_STRING, "same");
apr_hash_set(h, "OVERWRITE", APR_HASH_KEY_STRING, "Overwrite key");
dump_hash(p, h, StrArray);
ABTS_STR_EQUAL(tc, "Key FOO1 (4) Value bar1\n", StrArray[0]);
ABTS_STR_EQUAL(tc, "Key FOO2 (4) Value bar2\n", StrArray[1]);
ABTS_STR_EQUAL(tc, "Key FOO3 (4) Value bar3\n", StrArray[2]);
ABTS_STR_EQUAL(tc, "Key FOO4 (4) Value bar4\n", StrArray[3]);
ABTS_STR_EQUAL(tc, "Key OVERWRITE (9) Value Overwrite key\n", StrArray[4]);
ABTS_STR_EQUAL(tc, "Key SAME1 (5) Value same\n", StrArray[5]);
ABTS_STR_EQUAL(tc, "Key SAME2 (5) Value same\n", StrArray[6]);
ABTS_STR_EQUAL(tc, "#entries 7\n", StrArray[7]);
}
static void overlay_same(abts_case *tc, void *data)
{
apr_hash_t *base = NULL;
apr_hash_t *result = NULL;
int count;
char StrArray[MAX_DEPTH][MAX_LTH];
base = apr_hash_make(p);
ABTS_PTR_NOTNULL(tc, base);
apr_hash_set(base, "base1", APR_HASH_KEY_STRING, "value1");
apr_hash_set(base, "base2", APR_HASH_KEY_STRING, "value2");
apr_hash_set(base, "base3", APR_HASH_KEY_STRING, "value3");
apr_hash_set(base, "base4", APR_HASH_KEY_STRING, "value4");
apr_hash_set(base, "base5", APR_HASH_KEY_STRING, "value5");
result = apr_hash_overlay(p, base, base);
count = apr_hash_count(result);
ABTS_INT_EQUAL(tc, 5, count);
dump_hash(p, result, StrArray);
ABTS_STR_EQUAL(tc, "Key base1 (5) Value value1\n", StrArray[0]);
ABTS_STR_EQUAL(tc, "Key base2 (5) Value value2\n", StrArray[1]);
ABTS_STR_EQUAL(tc, "Key base3 (5) Value value3\n", StrArray[2]);
ABTS_STR_EQUAL(tc, "Key base4 (5) Value value4\n", StrArray[3]);
ABTS_STR_EQUAL(tc, "Key base5 (5) Value value5\n", StrArray[4]);
ABTS_STR_EQUAL(tc, "#entries 5\n", StrArray[5]);
}
static void overlay_same(abts_case *tc, void *data)
{
apr_hash_t *base = NULL;
apr_hash_t *result = NULL;
int count;
char str[8196];
base = apr_hash_make(p);
ABTS_PTR_NOTNULL(tc, base);
apr_hash_set(base, "base1", APR_HASH_KEY_STRING, "value1");
apr_hash_set(base, "base2", APR_HASH_KEY_STRING, "value2");
apr_hash_set(base, "base3", APR_HASH_KEY_STRING, "value3");
apr_hash_set(base, "base4", APR_HASH_KEY_STRING, "value4");
apr_hash_set(base, "base5", APR_HASH_KEY_STRING, "value5");
result = apr_hash_overlay(p, base, base);
count = apr_hash_count(result);
ABTS_INT_EQUAL(tc, 5, count);
dump_hash(p, result, str);
/* I don't know why these are out of order, but they are. I would probably
* consider this a bug, but others should comment.
*/
ABTS_STR_EQUAL(tc, "Key base5 (5) Value value5\n"
"Key base1 (5) Value value1\n"
"Key base2 (5) Value value2\n"
"Key base3 (5) Value value3\n"
"Key base4 (5) Value value4\n"
"#entries 5\n", str);
}
