static int cond_signaller1(void)
{
EXPECT_ZERO(pthread_mutex_lock(&g_cslock1));
EXPECT_ZERO(pthread_cond_signal(&g_cond1));
EXPECT_ZERO(pthread_mutex_unlock(&g_cslock1));
return 0;
}
static int test_bad_unlock_helper1(void)
{
EXPECT_ZERO(pthread_mutex_lock(&g_test_bad_unlock_mutex));
EXPECT_ZERO(sem_post(&g_test_bad_unlock_sem1));
EXPECT_ZERO(sem_wait(&g_test_bad_unlock_sem2));
EXPECT_ZERO(pthread_mutex_unlock(&g_test_bad_unlock_mutex));
return 0;
}
static int inver_thread_b(void)
{
EXPECT_ZERO(sem_wait(&g_inver_sem1));
EXPECT_ZERO(pthread_mutex_lock(&g_lock2));
EXPECT_EQ(pthread_mutex_trylock(&g_lock1), EBUSY);
EXPECT_ZERO(sem_post(&g_inver_sem2));
EXPECT_ZERO(pthread_mutex_unlock(&g_lock2));
return 0;
}
static int test4(void)
{
struct bob *b1 = JORM_INIT_bob();
struct bob *b2 = JORM_INIT_bob();
struct bob *b3 = JORM_INIT_bob();
struct abbie **abbie_arr = NULL;
EXPECT_NOT_EQUAL(b1, NULL);
EXPECT_NOT_EQUAL(b2, NULL);
EXPECT_NOT_EQUAL(b3, NULL);
EXPECT_EQUAL(b3->a, JORM_INVAL_INT);
b1->a = 101;
EXPECT_ZERO(JORM_COPY_bob(b1, b3));
EXPECT_EQUAL(b3->a, 101);
b2->a = JORM_INVAL_INT;
b2->b = 50;
b2->d = JORM_INIT_abbie();
b2->d->a = 9000;
EXPECT_ZERO(JORM_COPY_bob(b2, b3));
EXPECT_EQUAL(b3->b, 50);
EXPECT_NOT_EQUAL(b3->d, NULL);
EXPECT_EQUAL(b3->d->a, 9000);
EXPECT_EQUAL(b3->a, 101);
b1->f = calloc(3, sizeof(struct abbie*));
EXPECT_NOT_EQUAL(b1->f, NULL);
b1->f[0] = JORM_INIT_abbie();
EXPECT_NOT_EQUAL(b1->f[0], NULL);
b1->f[1] = JORM_INIT_abbie();
EXPECT_NOT_EQUAL(b1->f[1], NULL);
b1->f[2] = NULL;
b1->f[0]->a = 100;
b1->f[1]->a = 200;
EXPECT_ZERO(JORM_COPY_bob(b1, b3));
EXPECT_NOT_EQUAL(b3->f, NULL);
EXPECT_NOT_EQUAL(b3->f[0], NULL);
EXPECT_EQUAL(b3->f[0]->a, 100);
EXPECT_NOT_EQUAL(b3->f[1], NULL);
EXPECT_EQUAL(b3->f[1]->a, 200);
EXPECT_EQUAL(b3->f[2], NULL);
abbie_arr = JORM_ARRAY_COPY_abbie(b3->f);
EXPECT_NOT_EQUAL(abbie_arr, NULL);
EXPECT_NOT_EQUAL(abbie_arr[0], NULL);
EXPECT_EQUAL(abbie_arr[0]->a, 100);
EXPECT_NOT_EQUAL(abbie_arr[1], NULL);
EXPECT_EQUAL(abbie_arr[1]->a, 200);
EXPECT_EQUAL(abbie_arr[2], NULL);
JORM_ARRAY_FREE_abbie(&abbie_arr);
JORM_FREE_bob(b1);
JORM_FREE_bob(b2);
JORM_FREE_bob(b3);
return 0;
}
/**
* Verify that the fuse workload works on the local FS.
*
* @return 0 on success; error code otherwise
*/
static int verifyFuseWorkload(void)
{
char tempDir[PATH_MAX];
EXPECT_ZERO(createTempDir(tempDir, sizeof(tempDir), 0755));
EXPECT_ZERO(runFuseWorkload(tempDir, "test"));
EXPECT_ZERO(recursiveDelete(tempDir));
return 0;
}
static int test_thread_name_set_and_get_impl(void)
{
const char * const MY_THREAD = "my_thread";
const char *name;
EXPECT_ZERO(lksmith_set_thread_name(MY_THREAD));
name = lksmith_get_thread_name();
EXPECT_NOT_EQ(name, NULL);
EXPECT_ZERO(strcmp(MY_THREAD, name));
return 0;
}
int main(POSSIBLY_UNUSED(int argc), char **argv)
{
EXPECT_ZERO(utility_ctx_init(argv[0])); /* for g_fast_log_mgr */
EXPECT_ZERO(test_alloc_free());
EXPECT_ZERO(test_lookups());
EXPECT_ZERO(test_pack());
process_ctx_shutdown();
return EXIT_SUCCESS;
}
/**
* Test that we can create a MiniDFSCluster and shut it down.
*/
int main(void) {
struct NativeMiniDfsCluster* cl;
cl = nmdCreate(&conf);
EXPECT_NONNULL(cl);
EXPECT_ZERO(nmdWaitClusterUp(cl));
EXPECT_ZERO(nmdShutdown(cl));
nmdFree(cl);
return 0;
}
static int test_destroy_while_same_thread_has_locked(void)
{
pthread_mutex_t mutex;
EXPECT_ZERO(pthread_mutex_init(&mutex, NULL));
EXPECT_ZERO(pthread_mutex_lock(&mutex));
EXPECT_EQ(pthread_mutex_destroy(&mutex), EBUSY);
EXPECT_EQ(find_recorded_error(EBUSY), 1);
EXPECT_ZERO(pthread_mutex_unlock(&mutex));
EXPECT_ZERO(pthread_mutex_destroy(&mutex));
clear_recorded_errors();
return 0;
}
int main(POSSIBLY_UNUSED(int argc), char **argv)
{
char st_trivial[PATH_MAX];
EXPECT_ZERO(get_colocated_path(argv[0], "st_trivial",
st_trivial, sizeof(st_trivial)));
EXPECT_ZERO(run_cmd(st_trivial, "-h", (char*)NULL));
EXPECT_ZERO(run_cmd(st_trivial, "-f", (char*)NULL));
snprintf(env_str, sizeof(env_str), "ST_ERROR=1");
putenv(env_str);
EXPECT_NONZERO(run_cmd(st_trivial, "-f", (char*)NULL));
return 0;
}
/* A simple test of what POSIX rename does in a bunch of different
* scenarios. This doesn't test certain tricky corner cases like a rename
* where both src and dst are a hardlink to the same file. It's just your
* basic directories and files.
*/
static int do_rename(const char *src_base, const char *src_suffix,
const char *dst_base, const char *dst_suffix)
{
char src[PATH_MAX], dst[PATH_MAX];
EXPECT_ZERO(zsnprintf(src, PATH_MAX, "%s/%s", src_base, src_suffix));
EXPECT_ZERO(zsnprintf(dst, PATH_MAX, "%s/%s", dst_base, dst_suffix));
if (rename(src, dst) < 0) {
int err = -errno;
return err;
}
return 0;
}
static int test_canonicalize_path(const char *path, const char *expected)
{
char epath[PATH_MAX];
EXPECT_ZERO(zsnprintf(epath, PATH_MAX, "%s", path));
if (!expected) {
EXPECT_NONZERO(canonicalize_path(epath));
}
else {
EXPECT_ZERO(canonicalize_path(epath));
EXPECT_ZERO(strcmp(epath, expected));
}
return 0;
}
static int test_copy_fd_to_fd(const char *tempdir, int *next_id,
const char *buf)
{
size_t buf_len = strlen(buf);
ssize_t res;
char *nbuf, src_file[PATH_MAX], dst_file[PATH_MAX];
FILE *ifp, *ofp;
int ret;
EXPECT_ZERO(zsnprintf(src_file, sizeof(src_file),
"%s/src_file.%d", tempdir, *next_id));
EXPECT_ZERO(zsnprintf(dst_file, sizeof(dst_file),
"%s/dst_file.%d", tempdir, *next_id));
*next_id = *next_id + 1;
ifp = fopen(src_file, "w");
if (!ifp) {
ret = errno;
return ret;
}
EXPECT_EQUAL(fwrite(buf, 1, buf_len, ifp), buf_len);
ifp = freopen(src_file, "r", ifp);
if (!ifp) {
ret = errno;
return ret;
}
ofp = fopen(dst_file, "w");
if (!ofp) {
ret = errno;
fclose(ifp);
return ret;
}
ret = copy_fd_to_fd(fileno(ifp), fileno(ofp));
EXPECT_ZERO(ret);
fclose(ofp);
fclose(ifp);
nbuf = calloc(1, buf_len + 1);
EXPECT_NOT_EQUAL(nbuf, NULL);
res = simple_io_read_whole_file_zt(dst_file, nbuf, buf_len + 1);
if (res < 0) {
free(nbuf);
return res;
}
if ((res > 0) && (memcmp(buf, nbuf, buf_len - 1))) {
free(nbuf);
return -EIO;
}
free(nbuf);
return 0;
}
static int test_do_basename(const char *fname, const char *expected)
{
char bname[PATH_MAX] = { 0 };
EXPECT_ZERO(do_basename(bname, PATH_MAX, fname));
return strcmp(bname, expected);
}
static int test_signal_handler(const char *argv0, const char *tempdir, int sig)
{
int ret, pid, status;
char err[512] = { 0 };
char crash_log_path[PATH_MAX];
snprintf(crash_log_path, sizeof(crash_log_path), "%s/crash.log.%d",
tempdir, rand());
pid = fork();
if (pid == -1) {
ret = errno;
return ret;
}
else if (pid == 0) {
struct logc lc;
memset(&lc, 0, sizeof(lc));
lc.crash_log_path = crash_log_path;
signal_init(argv0, err, sizeof(err), &lc);
if (err[0]) {
fprintf(stderr, "signal_init error: %s\n", err);
_exit(1);
}
raise(sig);
_exit(1);
}
RETRY_ON_EINTR(ret, waitpid(pid, &status, 0));
EXPECT_ZERO(validate_crash_log(crash_log_path, sig));
return 0;
}
/**
* Test that we can write a file with libhdfs and then read it back
*/
int main(int argc, const char *args[])
{
int i, tlhNumThreads;
const char *tlhNumThreadsStr;
struct tlhThreadInfo ti[TLH_MAX_THREADS];
if (argc != 2) {
fprintf(stderr, "usage: test_libwebhdfs_threaded <username>\n");
exit(1);
}
user = args[1];
struct NativeMiniDfsConf conf = {
.doFormat = 1, .webhdfsEnabled = 1, .namenodeHttpPort = 50070,
};
cluster = nmdCreate(&conf);
EXPECT_NONNULL(cluster);
EXPECT_ZERO(nmdWaitClusterUp(cluster));
tlhNumThreadsStr = getenv("TLH_NUM_THREADS");
if (!tlhNumThreadsStr) {
tlhNumThreadsStr = "3";
}
tlhNumThreads = atoi(tlhNumThreadsStr);
if ((tlhNumThreads <= 0) || (tlhNumThreads > TLH_MAX_THREADS)) {
fprintf(stderr, "testLibHdfs: must have a number of threads "
"between 1 and %d inclusive, not %d\n",
TLH_MAX_THREADS, tlhNumThreads);
return EXIT_FAILURE;
}
memset(&ti[0], 0, sizeof(ti));
for (i = 0; i < tlhNumThreads; i++) {
ti[i].threadIdx = i;
}
for (i = 0; i < tlhNumThreads; i++) {
EXPECT_ZERO(pthread_create(&ti[i].thread, NULL,
testHdfsOperations, &ti[i]));
}
for (i = 0; i < tlhNumThreads; i++) {
EXPECT_ZERO(pthread_join(ti[i].thread, NULL));
}
EXPECT_ZERO(nmdShutdown(cluster));
nmdFree(cluster);
return checkFailures(ti, tlhNumThreads);
}
int main(void)
{
EXPECT_ZERO(test_canonicalize_path("", NULL));
EXPECT_ZERO(test_canonicalize_path("./foo", NULL));
EXPECT_ZERO(test_canonicalize_path("/tmp//foo", "/tmp/foo"));
EXPECT_ZERO(test_canonicalize_path("////tmp/////foo/", "/tmp/foo"));
EXPECT_ZERO(test_canonicalize_path("/tmp/foo", "/tmp/foo"));
EXPECT_ZERO(test_canonicalize_path("/long/path/that/ends/in/a/slash/",
"/long/path/that/ends/in/a/slash"));
EXPECT_ZERO(test_canonicalize_path("/", "/"));
EXPECT_ZERO(test_do_dirname("/", "/"));
EXPECT_ZERO(test_do_dirname("/tmp/foo", "/tmp"));
EXPECT_ZERO(test_do_dirname("/longer/path/here", "/longer/path"));
return EXIT_SUCCESS;
}
int main(void)
{
char tempdir[PATH_MAX];
char glitch_log_path[PATH_MAX];
struct logc lc;
EXPECT_ZERO(get_tempdir(tempdir, PATH_MAX, 0700));
EXPECT_ZERO(register_tempdir_for_cleanup(tempdir));
snprintf(glitch_log_path, sizeof(glitch_log_path),
"%s/glitch_log.txt", tempdir);
memset(&lc, 0, sizeof(struct logc));
lc.glitch_log_path = glitch_log_path;
EXPECT_ZERO(test_stderr_output(tempdir));
configure_glitch_log(&lc);
EXPECT_ZERO(test_log_output(lc.glitch_log_path));
return EXIT_SUCCESS;
}
static int read_then_write_file(const char *tempdir, int *next_id,
const char *contents, int buf_sz)
{
ssize_t res;
FILE *fp;
char *buf, file_name[PATH_MAX];
EXPECT_ZERO(zsnprintf(file_name, PATH_MAX,"%s/outfile.%d",
tempdir, *next_id));
*next_id = *next_id + 1;
fp = fopen(file_name, "w");
if (!fp) {
int ret = errno;
fprintf(stderr, "failed to open '%s': error %d\n",
file_name, ret);
return ret;
}
if (fprintf(fp, "%s", contents) < 0) {
int ret = errno;
fprintf(stderr, "failed to write to '%s': error %d\n",
file_name, ret);
return ret;
}
EXPECT_ZERO(fclose(fp));
buf = calloc(1, buf_sz);
if (!buf) {
return -ENOMEM;
}
res = simple_io_read_whole_file_zt(file_name, buf, buf_sz);
if (res < 0) {
free(buf);
fprintf(stderr, "simple_io_read_whole_file_zt failed with "
"error %Zd\n", res);
return res;
}
if ((buf_sz > 0) && (strncmp(contents, buf, buf_sz - 1))) {
fprintf(stderr, "got contents: '%s'; expected first "
"%d characters of: '%s' \n",
buf, buf_sz - 1, contents);
free(buf);
return -EIO;
}
free(buf);
return 0;
}
static int msgr_test_simple_send(int num_sends)
{
int i, res;
struct msgr *foo_msgr, *bar_msgr;
char err[512] = { 0 };
size_t err_len = sizeof(err);
struct listen_info linfo;
EXPECT_ZERO(sem_init(&g_msgr_test_simple_send_sem, 0, 0));
foo_msgr = msgr_init_helper(10, 10, 360, "foo_msgr");
bar_msgr = msgr_init_helper(10, 10, 360, "bar_msgr");
memset(&linfo, 0, sizeof(linfo));
linfo.cb = bar_cb;
linfo.priv = NULL;
linfo.port = MSGR_UNIT_PORT;
msgr_listen(bar_msgr, &linfo, err, err_len);
if (err[0])
goto handle_error;
msgr_start(foo_msgr, err, err_len);
if (err[0])
goto handle_error;
msgr_start(bar_msgr, err, err_len);
if (err[0])
goto handle_error;
for (i = 0; i < num_sends; ++i) {
EXPECT_ZERO(send_foo_tr(foo_msgr, foo_cb, i + 1));
}
for (i = 0; i < num_sends; ++i) {
RETRY_ON_EINTR(res, sem_wait(&g_msgr_test_simple_send_sem));
}
EXPECT_ZERO(sem_destroy(&g_msgr_test_simple_send_sem));
msgr_shutdown(foo_msgr);
msgr_shutdown(bar_msgr);
msgr_free(foo_msgr);
msgr_free(bar_msgr);
return 0;
handle_error:
fprintf(stderr, "msgr_test_simple_send: got error %s\n", err);
return 1;
}
static int do_test_mkdir(const char *base, const char *suffix)
{
char path[PATH_MAX];
EXPECT_ZERO(zsnprintf(path, PATH_MAX, "%s/%s", base, suffix));
if (mkdir(path, 0755) < 0) {
return -errno;
}
return 0;
}
int test_str_to_int(void)
{
int i;
char err[512] = { 0 };
err[0] = '\0';
str_to_int("123", 10, &i, err, sizeof(err));
EXPECT_ZERO(err[0]);
EXPECT_EQUAL(i, 123);
err[0] = '\0';
str_to_int("0", 10, &i, err, sizeof(err));
EXPECT_ZERO(err[0]);
EXPECT_EQUAL(i, 0);
err[0] = '\0';
str_to_int("", 10, &i, err, sizeof(err));
EXPECT_NONZERO(err[0]);
err[0] = '\0';
str_to_int("10b", 10, &i, err, sizeof(err));
EXPECT_NONZERO(err[0]);
err[0] = '\0';
str_to_int("f", 16, &i, err, sizeof(err));
EXPECT_ZERO(err[0]);
EXPECT_EQUAL(i, 15);
err[0] = '\0';
str_to_int("8589934592", 10, &i, err, sizeof(err));
EXPECT_NONZERO(err[0]);
err[0] = '\0';
str_to_int("2147483647", 10, &i, err, sizeof(err));
EXPECT_ZERO(err[0]);
EXPECT_EQUAL(i, 2147483647);
err[0] = '\0';
str_to_int("blah", 10, &i, err, sizeof(err));
EXPECT_NONZERO(err[0]);
return 0;
}
/**
* Test that we can write a file with libhdfs and then read it back
*/
int main(void)
{
int i, tlhNumThreads;
const char *tlhNumThreadsStr;
struct tlhThreadInfo ti[TLH_MAX_THREADS];
struct NativeMiniDfsConf conf = {
1, /* doFormat */
};
tlhNumThreadsStr = getenv("TLH_NUM_THREADS");
if (!tlhNumThreadsStr) {
tlhNumThreadsStr = "3";
}
tlhNumThreads = atoi(tlhNumThreadsStr);
if ((tlhNumThreads <= 0) || (tlhNumThreads > TLH_MAX_THREADS)) {
fprintf(stderr, "testLibHdfs: must have a number of threads "
"between 1 and %d inclusive, not %d\n",
TLH_MAX_THREADS, tlhNumThreads);
return EXIT_FAILURE;
}
memset(&ti[0], 0, sizeof(ti));
for (i = 0; i < tlhNumThreads; i++) {
ti[i].threadIdx = i;
}
tlhCluster = nmdCreate(&conf);
EXPECT_NONNULL(tlhCluster);
EXPECT_ZERO(nmdWaitClusterUp(tlhCluster));
for (i = 0; i < tlhNumThreads; i++) {
ti[i].theThread.start = testHdfsOperations;
ti[i].theThread.arg = &ti[i];
EXPECT_ZERO(threadCreate(&ti[i].theThread));
}
for (i = 0; i < tlhNumThreads; i++) {
EXPECT_ZERO(threadJoin(&ti[i].theThread));
}
EXPECT_ZERO(nmdShutdown(tlhCluster));
nmdFree(tlhCluster);
return checkFailures(ti, tlhNumThreads);
}
static int test_lookups(void)
{
struct udata *udata;
struct user *u;
udata = udata_create_default();
EXPECT_NOT_ERRPTR(udata);
EXPECT_ZERO(do_test_lookups(udata));
u = udata_lookup_user(udata, RF_NOBODY_NAME);
if (IS_ERR(u))
return PTR_ERR(u);
EXPECT_EQ(user_in_gid(u, RF_SUPERUSER_GID), 0);
EXPECT_ZERO(user_add_segid(udata, RF_NOBODY_NAME, 0));
u = udata_lookup_user(udata, RF_NOBODY_NAME);
if (IS_ERR(u))
return PTR_ERR(u);
EXPECT_EQ(user_in_gid(u, RF_SUPERUSER_GID), 1);
udata_free(udata);
return 0;
}
int main(POSSIBLY_UNUSED(int argc), char **argv)
{
timer_t timer;
time_t t;
EXPECT_ZERO(utility_ctx_init(argv[0]));
t = mt_time() + 600;
EXPECT_ZERO(mt_set_alarm(t, "msgr_unit timed out", &timer));
EXPECT_ZERO(get_localhost_ipv4(&g_localhost));
EXPECT_ZERO(msgr_test_init_shutdown(0));
EXPECT_ZERO(msgr_test_init_shutdown(1));
EXPECT_ZERO(msgr_test_simple_send(1));
EXPECT_ZERO(msgr_test_simple_send(100));
EXPECT_ZERO(msgr_test_conn_timeout());
EXPECT_ZERO(msgr_test_conn_shutdown());
EXPECT_ZERO(mt_deactivate_alarm(timer));
process_ctx_shutdown();
return EXIT_SUCCESS;
}
static int ostoru_thread1(struct redfish_thread *rt)
{
char buf[1024];
struct ostor *ostor = rt->priv;
EXPECT_ZERO(ostor_write(ostor, rt->fb, 123, TEST_DATA1,
strlen(TEST_DATA1)));
sem_post(&ostoru_threaded_test_sem2);
sem_wait(&ostoru_threaded_test_sem1);
EXPECT_EQ(ostor_read(ostor, rt->fb, 123, 0, buf, sizeof(buf)),
-ENOENT);
EXPECT_EQ(ostor_unlink(ostor, rt->fb, 123), -ENOENT);
EXPECT_ZERO(ostor_write(ostor, rt->fb, 456, TEST_DATA2,
strlen(TEST_DATA2)));
sem_post(&ostoru_threaded_test_sem2);
sem_wait(&ostoru_threaded_test_sem1);
ostor_shutdown(ostor);
sem_post(&ostoru_threaded_test_sem2);
return 0;
}
static int msgr_test_conn_shutdown(void)
{
int res;
struct msgr *baz1_msgr, *baz2_msgr;
char err[512] = { 0 };
size_t err_len = sizeof(err);
struct listen_info linfo;
EXPECT_ZERO(sem_init(&g_msgr_test_baz_sem, 0, 0));
baz1_msgr = msgr_init_helper(10, 10, 360, "baz1_msgr");
baz2_msgr = msgr_init_helper(10, 10, 360, "baz2_msgr");
memset(&linfo, 0, sizeof(linfo));
linfo.cb = baz_cb;
linfo.priv = NULL;
linfo.port = MSGR_UNIT_PORT;
msgr_listen(baz2_msgr, &linfo, err, err_len);
if (err[0])
goto handle_error;
msgr_start(baz1_msgr, err, err_len);
if (err[0])
goto handle_error;
msgr_start(baz2_msgr, err, err_len);
if (err[0])
goto handle_error;
EXPECT_ZERO(send_foo_tr(baz1_msgr, baz_cb, ECANCELED));
msgr_shutdown(baz1_msgr);
EXPECT_ZERO(send_foo_tr(baz1_msgr, baz_cb, ECANCELED));
RETRY_ON_EINTR(res, sem_wait(&g_msgr_test_baz_sem));
RETRY_ON_EINTR(res, sem_wait(&g_msgr_test_baz_sem));
EXPECT_ZERO(sem_destroy(&g_msgr_test_baz_sem));
msgr_shutdown(baz2_msgr);
msgr_free(baz1_msgr);
msgr_free(baz2_msgr);
return 0;
handle_error:
fprintf(stderr, "msgr_test_conn_shutdown: got error %s\n", err);
return 1;
}
TEST(cstr, ultohex)
{
char buf[TFW_ULTOA_BUF_SIZ + 1] = {0};
EXPECT_EQ(tfw_ultohex(0, buf, TFW_ULTOA_BUF_SIZ), 1);
EXPECT_ZERO(tfw_cstricmp(buf, "0", 2));
memset(buf, 0, TFW_ULTOA_BUF_SIZ + 1);
EXPECT_EQ(tfw_ultohex(5, buf, TFW_ULTOA_BUF_SIZ), 1);
EXPECT_ZERO(tfw_cstricmp(buf, "5", 2));
memset(buf, 0, TFW_ULTOA_BUF_SIZ + 1);
EXPECT_EQ(tfw_ultohex(0x58743, buf, TFW_ULTOA_BUF_SIZ), 5);
EXPECT_ZERO(tfw_cstricmp(buf, "58743", 6));
memset(buf, 0, TFW_ULTOA_BUF_SIZ + 1);
EXPECT_EQ(tfw_ultohex(0xaabbccff, buf, TFW_ULTOA_BUF_SIZ), 8);
EXPECT_ZERO(tfw_cstricmp(buf, "aabbccff", 9));
memset(buf, 0, TFW_ULTOA_BUF_SIZ + 1);
EXPECT_EQ(tfw_ultohex(0xf84467440abf095eUL, buf, TFW_ULTOA_BUF_SIZ),
16);
EXPECT_ZERO(tfw_cstricmp(buf, "f84467440abf095e", 17));
EXPECT_ZERO(tfw_ultohex(0x589, buf, 2));
}
TEST(cstr, ultoa)
{
char buf[TFW_ULTOA_BUF_SIZ + 1] = {0};
EXPECT_EQ(tfw_ultoa(0, buf, TFW_ULTOA_BUF_SIZ), 1);
EXPECT_ZERO(tfw_cstricmp(buf, "0", 2));
memset(buf, 0, TFW_ULTOA_BUF_SIZ + 1);
EXPECT_EQ(tfw_ultoa(5, buf, TFW_ULTOA_BUF_SIZ), 1);
EXPECT_ZERO(tfw_cstricmp(buf, "5", 2));
memset(buf, 0, TFW_ULTOA_BUF_SIZ + 1);
EXPECT_EQ(tfw_ultoa(58743, buf, TFW_ULTOA_BUF_SIZ), 5);
EXPECT_ZERO(tfw_cstricmp(buf, "58743", 6));
memset(buf, 0, TFW_ULTOA_BUF_SIZ + 1);
EXPECT_EQ(tfw_ultoa(0xaabbccff, buf, TFW_ULTOA_BUF_SIZ), 10);
EXPECT_ZERO(tfw_cstricmp(buf, "2864434431", 11));
memset(buf, 0, TFW_ULTOA_BUF_SIZ + 1);
EXPECT_EQ(tfw_ultoa(18446744073709551615UL, buf, TFW_ULTOA_BUF_SIZ),
20);
EXPECT_ZERO(tfw_cstricmp(buf, "18446744073709551615", 21));
EXPECT_ZERO(tfw_ultoa(589, buf, 2));
}
static int ostoru_threaded_test(const char *ostor_path, int max_open)
{
struct ostorc *oconf;
struct ostor *ostor;
struct redfish_thread thread1, thread2;
sem_init(&ostoru_threaded_test_sem1, 0, 0);
sem_init(&ostoru_threaded_test_sem2, 0, 0);
oconf = JORM_INIT_ostorc();
EXPECT_NOT_ERRPTR(oconf);
oconf->ostor_max_open = max_open;
oconf->ostor_timeo = 10;
oconf->ostor_path = strdup(ostor_path);
EXPECT_NOT_EQ(oconf->ostor_path, NULL);
ostor = ostor_init(oconf);
EXPECT_NOT_ERRPTR(ostor);
EXPECT_ZERO(redfish_thread_create(g_fast_log_mgr, &thread1,
ostoru_thread1, ostor));
EXPECT_ZERO(redfish_thread_create(g_fast_log_mgr, &thread2,
ostoru_thread2, ostor));
EXPECT_ZERO(redfish_thread_join(&thread1));
EXPECT_ZERO(redfish_thread_join(&thread2));
EXPECT_ZERO(sem_destroy(&ostoru_threaded_test_sem1));
EXPECT_ZERO(sem_destroy(&ostoru_threaded_test_sem2));
ostor_free(ostor);
JORM_FREE_ostorc(oconf);
return 0;
}