int
main(void)
{
    SXE_HASH    * hash;
    unsigned      i;
    unsigned      id;
    unsigned      bucket;
    int           counter[MAX_BUCKET_INDEX];

    plan_tests(2);
    sxe_log_set_level(SXE_LOG_LEVEL_DEBUG);

    memset(counter, 0, MAX_BUCKET_INDEX * sizeof(int));
    hash = sxe_hash_new("test-hash", HASH_SIZE);

    for (i = 0; i < HASH_SIZE; i++)
    {
        char in_buf[5];
        char out_buf[41];

        snprintf(in_buf, 5, "%d", i);
        sha1sum( in_buf, 4, out_buf);
        id = sxe_hash_set(hash, out_buf, SXE_HASH_SHA1_AS_HEX_LENGTH, 1U);
        bucket = sxe_pool_index_to_state(hash, id);
        SXEA11(bucket < MAX_BUCKET_INDEX, "Bucket index %u is out of range", bucket);
        counter[bucket]++;

        if (counter[bucket] > MAX_ALLOWED_PER_BUCKET_INDEX) {
            diag("Count at bucket index %u is greater than %u", counter[bucket], MAX_ALLOWED_PER_BUCKET_INDEX);
            break;
        }
    }

    is(i, HASH_SIZE, "%u items SHA1 hashed and no bucket has more that %u entries", i, MAX_ALLOWED_PER_BUCKET_INDEX);

    memset(counter, 0, MAX_BUCKET_INDEX * sizeof(int));
    hash = sxe_hash_new_plus("lookup3", HASH_SIZE, sizeof(SXE_HASH), 0, 8, SXE_HASH_OPTION_LOOKUP3_HASH);

    for (i = 0; i < HASH_SIZE; i++)
    {
        id = sxe_hash_take(hash);
        snprintf((char *)&hash[id], 9, "%08x", i);
        sxe_hash_add(hash, id);

        bucket = sxe_pool_index_to_state(hash, id);
        SXEA11(bucket < MAX_BUCKET_INDEX, "Bucket index %u is out of range", bucket);
        counter[bucket]++;

        if (counter[bucket] > MAX_ALLOWED_PER_BUCKET_INDEX + 1) {
            diag("Count at bucket index %u is greater than %u", counter[bucket], MAX_ALLOWED_PER_BUCKET_INDEX + 1);
            break;
        }
    }

    is(i, HASH_SIZE, "%u items lookup3 hashed and no bucket has more that %u entries", i, MAX_ALLOWED_PER_BUCKET_INDEX + 1);
    return exit_status();
}
Пример #2
0
static void
sxe_dirwatch_event(EV_P_ ev_io * io, int revents)
{
    char                   buffer[8192];
    int                    length;
    unsigned               offset;
    struct inotify_event * event;

    SXE_UNUSED_PARAMETER(revents);
    SXEE62("(fd=%d, revents=%08x)", io->fd, revents);
    SXEA11((length = read(io->fd, buffer, sizeof(buffer))) >= 0, "sxe_dirwatch_event: Failed to read events from inotify: %s",
            strerror(errno));

    for (offset = 0; offset < (unsigned)length;)
    {
        SXE_LIST_WALKER walker;
        SXE_DIRWATCH  * dirwatch;
        int             flags = 0;

        SXEA12(length - offset >= sizeof(struct inotify_event),
               "Odd sized chunk left in buffer %u (expected inotify event of %u bytes)",
               length - offset, sizeof(struct inotify_event));
        event = (struct inotify_event *)&buffer[offset];
        offset += sizeof(struct inotify_event);
        SXEA12(length - offset >= event->len, "Chunk left in buffer %u (expected length %u)", length - offset, event->len);
        offset += event->len;
        SXEL63("dirwatch_event: fd=%d flags=%08x file=%s", event->wd, event->mask, event->name);
        sxe_list_walker_construct(&walker, &sxe_dirwatch_list);

        while ((dirwatch = (SXE_DIRWATCH *)sxe_list_walker_step(&walker)) != NULL) {
            if (dirwatch->fd == event->wd) {
                break;
            }
        }

        SXEA11(dirwatch, "No watched directory found with fd %d", event->wd);

        flags |= (event->mask & IN_CREATE)     ? SXE_DIRWATCH_CREATED  : 0;
        flags |= (event->mask & IN_MOVED_TO)   ? SXE_DIRWATCH_CREATED  : 0;
        flags |= (event->mask & IN_MODIFY)     ? SXE_DIRWATCH_MODIFIED : 0;
        flags |= (event->mask & IN_DELETE)     ? SXE_DIRWATCH_DELETED  : 0;
        flags |= (event->mask & IN_MOVED_FROM) ? SXE_DIRWATCH_DELETED  : 0;

        dirwatch->notify(EV_A_ event->name, flags, dirwatch->user_data);
    }

    SXER60("return");
}
Пример #3
0
int
main(int argc, char **argv)
{
    char line[2056];
    char decoded[2056];
    int i;
    unsigned len;

    if (argc != 2) {
        printf("usage: %s -use_stdio\n", argv[0]);
        return 0;
    }

    while (fgets(line, sizeof(line), stdin) != NULL) {

        i = 0;

        while ((line[i] != ' ') && (line[i] != '\0') && (line[i] != '\n')) {
            i++;
        }

        line[i] = '\0';
        //i++;

        SXEA11(sxe_dns_uri_decode(decoded, sizeof(decoded), &len, line, i) == SXE_RETURN_OK, "decode failed for %s", line);
        printf("%.*s\n", len, decoded);
    }

    return 0;
}
Пример #4
0
const char *
sxe_return_to_string(SXE_RETURN ret)
{
    if (ret >= SXE_RETURN_INVALID_VALUE) {
        return "INVALID_VALUE";
    }

    /* Convert to string.  If any enumerand is missing, should get a compiler error (works with gcc).
     */
    switch (ret) {
    SXE_RETURN_CASE(OK);
    SXE_RETURN_CASE(UNCATEGORIZED);
    SXE_RETURN_CASE(WARN_CACHE_DOUBLE_INITIALIZED);
    SXE_RETURN_CASE(WARN_WOULD_BLOCK);
    SXE_RETURN_CASE(ERROR_CACHE_UNINITIALIZED);
    SXE_RETURN_CASE(ERROR_ALLOC);
    SXE_RETURN_CASE(ERROR_INTERNAL);
    SXE_RETURN_CASE(ERROR_NO_CONNECTION);
    SXE_RETURN_CASE(ERROR_ALREADY_CONNECTED);
    SXE_RETURN_CASE(ERROR_INVALID_URI);
    SXE_RETURN_CASE(ERROR_ADDRESS_IN_USE);
    SXE_RETURN_CASE(WARN_ALREADY_CLOSED);
    SXE_RETURN_CASE(ERROR_INTERRUPTED);
    SXE_RETURN_CASE(ERROR_COMMAND_NOT_RUN);
    SXE_RETURN_CASE(INVALID_VALUE);    /* COVERAGE EXCLUSION: Cannot hit this */
    }

    /* Can't happen!
     */
    SXEA11(1, "Invalid return value %u", ret);
    return "INVALID_VALUE"; /* COVERAGE EXCLUSION: Cannot hit this */
}
Пример #5
0
static SXE_TIME
local_get_time(void)
{
    struct timeval tv;

    SXEA11(gettimeofday(&tv, NULL) >= 0, "gettimeofday failed: %s", strerror(errno));
    return SXE_TIME_FROM_TIMEVAL(&tv);
}
Пример #6
0
void
sxe_sync_ev_post(void * sync_point)
{
    SXE_SYNC_EV * sync_ev = (SXE_SYNC_EV *)sync_point;

    SXEE81("sxe_sync_ev_post(sync_point=%p)", sync_point);
    SXEA11(sendto(sync_ev->sock, (MOCK_SOCKET_VOID *)&sync_point, sizeof(sync_point), 0, (struct sockaddr *)&sxe_sync_ev_addr,
                  sizeof(sxe_sync_ev_addr)) == sizeof(sync_point),
           "Can't send to sync_point listener port: %s", sxe_socket_get_last_error_as_str());
    SXER80("return");
}
Пример #7
0
static int
sxe_sync_ev_socket(void)
{
    int sock;

    SXEE80("sxe_sync_ev_socket()");
    SXEA11((sock = socket(AF_INET, SOCK_DGRAM, 0)) != SXE_SOCKET_INVALID, "Error creating sync socket: %s",
           sxe_socket_get_last_error_as_str());
    SXEA12(sxe_socket_set_nonblock(sock, 1) >= 0, "socket %d: couldn't set non-blocking flag: %s", sock,
           sxe_socket_get_last_error_as_str());
    SXER81("return sock=%d", sock);
    return sock;
}
Пример #8
0
/**
 * Initialize the dirwatch package
 *
 * @exceptions Aborts if already initialized or on failure to initialize inotify
 */
void
sxe_dirwatch_init(void)
{
    SXEE60("()");
    if (sxe_dirwatch_inotify_fd != -1) {
        SXEL60("sxe_dirwatch_init: Already initialized");
        goto SXE_EARLY_OUT;
    }

    SXEA11((sxe_dirwatch_inotify_fd = inotify_init()) != -1, "sxe_dirwatch_init: inotify_init() failed with %s", strerror(errno));
    SXEL61("inotify_init() returned fd: %d", sxe_dirwatch_inotify_fd);
    SXE_LIST_CONSTRUCT(&sxe_dirwatch_list, 0, SXE_DIRWATCH, node);
    ev_io_init(&sxe_dirwatch_watcher, sxe_dirwatch_event, sxe_dirwatch_inotify_fd, EV_READ);

SXE_EARLY_OUT:
    SXER60("return");
}
Пример #9
0
SXE_RETURN
md5_to_hex(SOPHOS_MD5 * md5, char * md5_in_hex, unsigned md5_in_hex_length)
{
    SXE_RETURN result = SXE_RETURN_OK;

    SXEE86("(md5=%08x%08x%08x%08x,md5_in_hex='%p',md5_in_hex_length='%u'",
           md5->word[3], md5->word[2], md5->word[1], md5->word[0],
           md5_in_hex, md5_in_hex_length);
    SXEA11(md5_in_hex_length == (MD5_IN_HEX_LENGTH + 1), "Incorrect length of char * for md5_to_hex(): '%u'", md5_in_hex_length);

    snprintf(md5_in_hex     , 9, "%08x", htonl(md5->word[0]));
    snprintf(md5_in_hex +  8, 9, "%08x", htonl(md5->word[1]));
    snprintf(md5_in_hex + 16, 9, "%08x", htonl(md5->word[2]));
    snprintf(md5_in_hex + 24, 9, "%08x", htonl(md5->word[3]));
    SXEL62("md5_in_hex: '%.*s'", MD5_IN_HEX_LENGTH, md5_in_hex);

    SXER81("return %s", sxe_return_to_string(result));
    return result;
}
Пример #10
0
SXE_RETURN
sha1_to_hex(SOPHOS_SHA1 * sha1, char * sha1_in_hex, unsigned sha1_in_hex_length)
{
    SXE_RETURN result = SXE_RETURN_OK;

    SXEE87("sxe_sha1_to_hex(sha1=%08x%08x%08x%08x%08x,sha1_in_hex='%p',sha1_in_hex_length='%u'",
           sha1->word[4], sha1->word[3], sha1->word[2], sha1->word[1], sha1->word[0],
           sha1_in_hex, sha1_in_hex_length);
    SXEA11(sha1_in_hex_length == (SHA1_IN_HEX_LENGTH + 1), "Incorrect length of char * for sha1_to_hex(): '%u'", sha1_in_hex_length);

    snprintf(sha1_in_hex     , 9, "%08x", htonl(sha1->word[0]));
    snprintf(sha1_in_hex +  8, 9, "%08x", htonl(sha1->word[1]));
    snprintf(sha1_in_hex + 16, 9, "%08x", htonl(sha1->word[2]));
    snprintf(sha1_in_hex + 24, 9, "%08x", htonl(sha1->word[3]));
    snprintf(sha1_in_hex + 32, 9, "%08x", htonl(sha1->word[4]));
    SXEL62("sha1_in_hex: '%.*s'", 40, sha1_in_hex);

    SXER81("return %s", sxe_return_to_string(result));
    return result;
}
Пример #11
0
static void
sxe_sync_ev_read(EV_P_ ev_io * io, int revents)
{
    SXE_SYNC_EV   * handle;

    SXEE82("sxe_sync_ev_read(io=%p,revents=%d)", io, revents);
#if EV_MULTIPLICITY
    SXE_UNUSED_ARGUMENT(loop);
#endif
    SXE_UNUSED_ARGUMENT(io);
    SXE_UNUSED_ARGUMENT(revents);

    while(recvfrom(sxe_sync_ev_sock, &handle, sizeof(handle), 0, NULL, NULL) == sizeof(handle)) {
        (*sxe_sync_generic_event)(handle, handle->user_data);
    }

    SXEA11(sxe_socket_get_last_error() == SXE_SOCKET_ERROR(EWOULDBLOCK), "Unexpected error receiving from sync socket: %s",
           sxe_socket_get_last_error_as_str());
    SXER80("return");
}
Пример #12
0
/**
 * Construct a pool state walker (AKA iterator)
 *
 * @param walker Pointer to the walker
 * @param array  Pointer to the pool array
 * @param state  State to walk
 *
 * @exception If the pool is both locked and timed, it cannot be walked safely
 */
void
sxe_pool_walker_construct(SXE_POOL_WALKER * walker, void * array, unsigned state)
{
    SXE_POOL_IMPL * pool = SXE_POOL_ARRAY_TO_IMPL(array);

    SXEE83("sxe_pool_walker_construct(walker=%p,pool=%s,state=%s)", walker, pool->name, (*pool->state_to_string)(state));
    SXEA11(!((pool->options & SXE_POOL_OPTION_LOCKED) && (pool->options & SXE_POOL_OPTION_TIMED)),
           "sxe_pool_walker_construct: Can't walk thread safe timed pool %s safely", pool->name);
    sxe_list_walker_construct(&walker->list_walker, &SXE_POOL_QUEUE(pool)[state]);
    walker->pool  = pool;
    walker->state = state;

    if (pool->options & SXE_POOL_OPTION_TIMED) {
        walker->last.time  = 0.0;
    }
    else {
        walker->last.count = 0;
    }

    SXER80("return");
}
Пример #13
0
int
main(void)
{

#ifdef WIN32
/* TODO: Implement sxe_dirwatch() on Windows */
#else

    char tempdir1[] = "tmp-XXXXXX";
    char tempdir2[] = "tmp-XXXXXX";
    char tempdir3[] = "tmp-XXXXXX";
    char fname[PATH_MAX];
    tap_ev ev;

    plan_tests(28);

    sxe_register(1, 0);
    sxe_init();

    /* We need to make a new temporary directory, because *everything* appears
     * to change willy-nilly during the build. The current directory has a
     * file that always changes. The /tmp directory always seems to have
     * spurious changes in it. */
    SXEA11(mkdtemp(tempdir1), "Failed to create tempdir: %s", strerror(errno));
    SXEA11(mkdtemp(tempdir2), "Failed to create tempdir: %s", strerror(errno));
    SXEA11(mkdtemp(tempdir3), "Failed to create tempdir: %s", strerror(errno));

    sxe_dirwatch_init(10);
    sxe_dirwatch_add(tempdir1, SXE_DIRWATCH_CREATED|SXE_DIRWATCH_MODIFIED|SXE_DIRWATCH_DELETED, test_dirwatch_event, (void *)1);
    sxe_dirwatch_add(tempdir2, SXE_DIRWATCH_MODIFIED, test_dirwatch_event, (void *)2);
    sxe_dirwatch_add(tempdir3, SXE_DIRWATCH_DELETED, test_dirwatch_event, (void *)3);
    sxe_dirwatch_start();

    /* tempdir1: create, modify, delete */
    {
        char rname[PATH_MAX];
        int fd;

        snprintf(rname, sizeof rname, "%s/renamed", tempdir1);
        snprintf(fname, sizeof fname, "%s/created", tempdir1);

        fd = open(fname, O_CREAT|O_RDWR, S_IRWXU);
        write(fd, "Hello", 5);
        rename(fname, rname);
        unlink(rname);

        is_eq(test_tap_ev_identifier_wait(TEST_WAIT, &ev), "test_dirwatch_event",  "Got a dirwatch event");
        is_eq(tap_ev_arg(ev, "chfile"), "created",                                 "Got filename %s", fname);
        is(tap_ev_arg(ev, "chflags"), SXE_DIRWATCH_CREATED,                        "Got flags=SXE_DIRWATCH_CREATED");
        is(tap_ev_arg(ev, "user_data"), 1,                                         "Got user_data=1 (%s)", tempdir1);

        is_eq(test_tap_ev_identifier_wait(TEST_WAIT, &ev), "test_dirwatch_event",  "Got a dirwatch event");
        is_eq(tap_ev_arg(ev, "chfile"), "created",                                 "Got filename %s", fname);
        is(tap_ev_arg(ev, "chflags"), SXE_DIRWATCH_MODIFIED,                       "Got flags=SXE_DIRWATCH_MODIFIED");
        is(tap_ev_arg(ev, "user_data"), 1,                                         "Got user_data=1 (%s)", tempdir1);

        is_eq(test_tap_ev_identifier_wait(TEST_WAIT, &ev), "test_dirwatch_event",  "Got a dirwatch event");
        is_eq(tap_ev_arg(ev, "chfile"), "created",                                 "Got filename %s", fname);
        is(tap_ev_arg(ev, "chflags"), SXE_DIRWATCH_DELETED,                        "Got flags=SXE_DIRWATCH_DELETED");
        is(tap_ev_arg(ev, "user_data"), 1,                                         "Got user_data=1 (%s)", tempdir1);

        is_eq(test_tap_ev_identifier_wait(TEST_WAIT, &ev), "test_dirwatch_event",  "Got a dirwatch event");
        is_eq(tap_ev_arg(ev, "chfile"), "renamed",                                 "Got filename %s", rname);
        is(tap_ev_arg(ev, "chflags"), SXE_DIRWATCH_CREATED,                        "Got flags=SXE_DIRWATCH_CREATED");
        is(tap_ev_arg(ev, "user_data"), 1,                                         "Got user_data=1 (%s)", tempdir1);

        is_eq(test_tap_ev_identifier_wait(TEST_WAIT, &ev), "test_dirwatch_event",  "Got a dirwatch event");
        is_eq(tap_ev_arg(ev, "chfile"), "renamed",                                 "Got filename %s", rname);
        is(tap_ev_arg(ev, "chflags"), SXE_DIRWATCH_DELETED,                        "Got flags=SXE_DIRWATCH_DELETED");
        is(tap_ev_arg(ev, "user_data"), 1,                                         "Got user_data=1 (%s)", tempdir1);
    }

    /* tempdir2: modified */
    {
        const char *rel;
        int fd;

        snprintf(fname, sizeof fname, "%s/file.XXXXXX", tempdir2);
        SXEA11((rel = strchr(fname, '/')), "Didn't find '/' in %s", fname);
        rel++;

        fd = mkstemp(fname);
        write(fd, "Hello", 5);
        unlink(fname);

        is_eq(test_tap_ev_identifier_wait(TEST_WAIT, &ev), "test_dirwatch_event",  "Got a dirwatch event");
        is_eq(tap_ev_arg(ev, "chfile"), rel,                                       "Got filename %s", fname);
        is(tap_ev_arg(ev, "chflags"), SXE_DIRWATCH_MODIFIED,                       "Got flags=SXE_DIRWATCH_MODIFIED");
        is(tap_ev_arg(ev, "user_data"), 2,                                         "Got user_data=2 (%s)", tempdir2);
    }

    /* tempdir3: deleted */
    {
        const char *rel;
        int fd;

        snprintf(fname, sizeof fname, "%s/file.XXXXXX", tempdir3);
        SXEA11((rel = strchr(fname, '/')), "Didn't find '/' in %s", fname);
        rel++;

        fd = mkstemp(fname);
        unlink(fname);

        is_eq(test_tap_ev_identifier_wait(TEST_WAIT, &ev), "test_dirwatch_event",  "Got a dirwatch event");
        is_eq(tap_ev_arg(ev, "chfile"), rel,                                       "Got filename %s", fname);
        is(tap_ev_arg(ev, "chflags"), SXE_DIRWATCH_DELETED,                        "Got flags=SXE_DIRWATCH_DELETED");
        is(tap_ev_arg(ev, "user_data"), 3,                                         "Got user_data=3 (%s)", tempdir3);
    }

    rmdir(tempdir1);
    rmdir(tempdir2);
    rmdir(tempdir3);

    sxe_dirwatch_stop();

#endif
    return exit_status();
}
Пример #14
0
int
main(int argc, char ** argv)
{
#ifdef WINDOWS_NT
    SXEL10("WARNING: Need to implement sxe_spawn() on Windows to run this test file!");
#else
    int           fd;
    double        start_time;
    unsigned      count;
    unsigned      id;
    unsigned    * pool;
    unsigned    * shared;
    size_t        size;
    SXE_MMAP      memmap;
    SXE_RETURN    result;
    SXE_SPAWN     spawn[TEST_CLIENT_INSTANCES];

    if (argc > 1) {
        count = atoi(argv[1]);
        sxe_mmap_open(&memmap, "memmap");
        shared  = (unsigned *)(unsigned long)SXE_MMAP_ADDR(&memmap);
        pool    = sxe_pool_from_base(shared);
        SXEL63("Instance %u mapped to shared pool // base=%p, pool=%p", count, shared, pool);
        do {
            usleep(10000 * count);
            id = sxe_pool_set_oldest_element_state_locked(pool, TEST_STATE_FREE, TEST_STATE_CLIENT_TAKE);
            SXEA10(id != SXE_POOL_LOCK_NEVER_TAKEN, "Got SXE_POOL_LOCK_NEVER_TAKEN");;
        } while (id == SXE_POOL_NO_INDEX);

        SXEL62("Instance %u got pool element %u", count, id);
        pool[id] = count;
        sxe_pool_set_indexed_element_state_locked(pool, id, TEST_STATE_CLIENT_TAKE, TEST_STATE_CLIENT_DONE);
        sxe_mmap_close(&memmap);
        SXEL61("Instance %u exiting", count);
        return 0;
    }

    plan_tests(5);
    ok((size = sxe_pool_size(TEST_CLIENT_INSTANCES/2, sizeof(*pool), TEST_STATE_NUMBER_OF_STATES)) >= TEST_CLIENT_INSTANCES * sizeof(*pool),
       "Expect pool size %u to be at least the size of the array %u", size, TEST_CLIENT_INSTANCES * sizeof(*pool));

    SXEA11((fd = open("memmap", O_CREAT | O_TRUNC | O_WRONLY, 0666)) >= 0, "Failed to create file 'memmap': %s",         strerror(errno));
    SXEA12(ftruncate(fd, size)                                       >= 0, "Failed to extend the file to %lu bytes: %s", size, strerror(errno));
    close(fd);
    sxe_mmap_open(&memmap, "memmap");
    shared = (unsigned *)(unsigned long)SXE_MMAP_ADDR(&memmap);

    pool = sxe_pool_construct(shared, "shared-pool", TEST_CLIENT_INSTANCES/2, sizeof(*pool), TEST_STATE_NUMBER_OF_STATES, SXE_POOL_LOCKS_ENABLED);

    sxe_register(TEST_CLIENT_INSTANCES + 1, 0);
    SXEA11((result = sxe_init()) == SXE_RETURN_OK,  "Failed to initialize the SXE package: %s",  sxe_return_to_string(result));

    for (count = 1; count <= TEST_CLIENT_INSTANCES; count++) {
        char buffer[12];

        snprintf(buffer, sizeof(buffer), "%u", count);
        result = sxe_spawn(NULL, &spawn[count - 1], argv[0], buffer, NULL, NULL, NULL, NULL);
        SXEA13(result == SXE_RETURN_OK, "Failed to spawn '%s %s': %s", argv[0], buffer, sxe_return_to_string(result));
    }

    start_time = sxe_get_time_in_seconds();
    for (count = 0; (count < TEST_CLIENT_INSTANCES); ) {
        SXEA10((TEST_WAIT + start_time ) > sxe_get_time_in_seconds(), "Unexpected timeout... is the hardware too slow?");
        usleep(10000);
        id = sxe_pool_set_oldest_element_state_locked(pool, TEST_STATE_CLIENT_DONE, TEST_STATE_FREE);

        /* Assert here in  the test. The actual service would take specific action here */
        SXEA12(id != SXE_POOL_LOCK_NEVER_TAKEN, "Parent: Failed to acqure lock .. yield limit reached. id %u vs %u", id, SXE_POOL_LOCK_NEVER_TAKEN);

        if (id != SXE_POOL_NO_INDEX) {
            SXEL62("Looks like instance %u got element %u", pool[id], id);
            count++;
        }
    }
    ok(count == TEST_CLIENT_INSTANCES, "All clients got an element in the pool");

    start_time = sxe_get_time_in_seconds();
    for (count = 0; (count < TEST_CLIENT_INSTANCES); count++) {
        SXEA10((TEST_WAIT + start_time ) > sxe_get_time_in_seconds(), "Unexpected timeout... is the hardware too slow?");
        waitpid(spawn[count].pid, NULL, 0);
    }

    ok(SXE_POOL_LOCK_NEVER_TAKEN != sxe_pool_lock(pool), "Forced lock to be always locked!");
    id = sxe_pool_set_oldest_element_state_locked(pool, TEST_STATE_FREE, TEST_STATE_FREE);
    ok(id == SXE_POOL_LOCK_NEVER_TAKEN,   "sxe_pool_set_oldest_element_state_locked() Failed to acquire lock");
    id = sxe_pool_set_indexed_element_state_locked(pool, 0, TEST_STATE_FREE, TEST_STATE_FREE);
    ok(id == SXE_POOL_LOCK_NEVER_TAKEN,   "sxe_pool_set_indexed_element_state_locked() Failed to acquire lock");
    sxe_pool_unlock(pool);
    sxe_pool_override_locked(pool); /* for coverage */

    sxe_mmap_close(&memmap);
    return exit_status();
#endif
}