static int test3(void)
{
size_t i;
int ret;
char err[512] = { 0 };
const char in_str[] = "{ \"a\": 1, \"b\": 2.500000, "
"\"c\": \"hi there\", \"d\": { \"a\": 0 }, "
"\"e\": false, \"f\": [ { \"a\": 1 }, "
"{ \"a\": 2 } ], \"x\" : 5, \"y\" : 1.5 }";
int expected_array_val[] = { 1, 2, 6 };
struct json_object* jo = NULL;
struct bob *my_bob = NULL;
struct abbie* final_abbie;
jo = parse_json_string(in_str, err, sizeof(err));
if (err[0]) {
fprintf(stderr, "parse_json_string error: %s\n", err);
ret = EXIT_FAILURE;
goto done;
}
my_bob = JORM_FROMJSON_bob(jo);
if (!my_bob) {
fprintf(stderr, "JORM_FROMJSON: OOM\n");
ret = EXIT_FAILURE;
goto done;
}
ret = 0;
EXPECT_NONZERO(my_bob->a == 1);
EXPECT_NONZERO(my_bob->b == 2.5);
EXPECT_ZERO(my_bob->extra_data);
final_abbie = JORM_ARRAY_APPEND_abbie(&my_bob->f);
EXPECT_NOT_EQUAL(final_abbie, NULL);
final_abbie->a = 6;
for (i = 0; i < sizeof(expected_array_val) /
sizeof(expected_array_val[0]); ++i) {
EXPECT_EQUAL(my_bob->f[i]->a, expected_array_val[i]);
}
EXPECT_EQUAL(my_bob->g->x, 5);
EXPECT_EQUAL(my_bob->g->y, 1.5);
done:
if (jo) {
json_object_put(jo);
jo = NULL;
}
if (my_bob) {
JORM_FREE_bob(my_bob);
my_bob = NULL;
}
return ret;
}
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;
}
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;
}
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 doTestHdfsOperations(struct tlhThreadInfo *ti, hdfsFS fs)
{
char prefix[256], tmp[256];
hdfsFile file;
int ret, expected;
hdfsFileInfo *fileInfo;
snprintf(prefix, sizeof(prefix), "/tlhData%04d", ti->threadIdx);
if (hdfsExists(fs, prefix) == 0) {
EXPECT_ZERO(hdfsDelete(fs, prefix, 1));
}
EXPECT_ZERO(hdfsCreateDirectory(fs, prefix));
snprintf(tmp, sizeof(tmp), "%s/file", prefix);
EXPECT_NONNULL(hdfsOpenFile(fs, tmp, O_RDONLY, 0, 0, 0));
file = hdfsOpenFile(fs, tmp, O_WRONLY, 0, 0, 0);
EXPECT_NONNULL(file);
/* TODO: implement writeFully and use it here */
expected = (int)strlen(prefix);
ret = hdfsWrite(fs, file, prefix, expected);
if (ret < 0) {
ret = errno;
fprintf(stderr, "hdfsWrite failed and set errno %d\n", ret);
return ret;
}
if (ret != expected) {
fprintf(stderr, "hdfsWrite was supposed to write %d bytes, but "
"it wrote %d\n", ret, expected);
return EIO;
}
EXPECT_ZERO(hdfsFlush(fs, file));
EXPECT_ZERO(hdfsCloseFile(fs, file));
/* Let's re-open the file for reading */
file = hdfsOpenFile(fs, tmp, O_RDONLY, 0, 0, 0);
EXPECT_NONNULL(file);
/* TODO: implement readFully and use it here */
ret = hdfsRead(fs, file, tmp, sizeof(tmp));
if (ret < 0) {
ret = errno;
fprintf(stderr, "hdfsRead failed and set errno %d\n", ret);
return ret;
}
if (ret != expected) {
fprintf(stderr, "hdfsRead was supposed to read %d bytes, but "
"it read %d\n", ret, expected);
return EIO;
}
EXPECT_ZERO(memcmp(prefix, tmp, expected));
EXPECT_ZERO(hdfsCloseFile(fs, file));
snprintf(tmp, sizeof(tmp), "%s/file", prefix);
EXPECT_NONZERO(hdfsChown(fs, tmp, NULL, NULL));
EXPECT_ZERO(hdfsChown(fs, tmp, NULL, "doop"));
fileInfo = hdfsGetPathInfo(fs, tmp);
EXPECT_NONNULL(fileInfo);
EXPECT_ZERO(strcmp("doop", fileInfo->mGroup));
hdfsFreeFileInfo(fileInfo, 1);
EXPECT_ZERO(hdfsChown(fs, tmp, "ha", "doop2"));
fileInfo = hdfsGetPathInfo(fs, tmp);
EXPECT_NONNULL(fileInfo);
EXPECT_ZERO(strcmp("ha", fileInfo->mOwner));
EXPECT_ZERO(strcmp("doop2", fileInfo->mGroup));
hdfsFreeFileInfo(fileInfo, 1);
EXPECT_ZERO(hdfsChown(fs, tmp, "ha2", NULL));
fileInfo = hdfsGetPathInfo(fs, tmp);
EXPECT_NONNULL(fileInfo);
EXPECT_ZERO(strcmp("ha2", fileInfo->mOwner));
EXPECT_ZERO(strcmp("doop2", fileInfo->mGroup));
hdfsFreeFileInfo(fileInfo, 1);
EXPECT_ZERO(hdfsDelete(fs, prefix, 1));
return 0;
}
