static void test_load_empty_file(void) {
FILE *tmp = NULL;
grpc_slice slice;
grpc_slice slice_with_null_term;
grpc_error *error;
char *tmp_name;
LOG_TEST_NAME("test_load_empty_file");
tmp = gpr_tmpfile(prefix, &tmp_name);
GPR_ASSERT(tmp_name != NULL);
GPR_ASSERT(tmp != NULL);
fclose(tmp);
error = grpc_load_file(tmp_name, 0, &slice);
GPR_ASSERT(error == GRPC_ERROR_NONE);
GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == 0);
error = grpc_load_file(tmp_name, 1, &slice_with_null_term);
GPR_ASSERT(error == GRPC_ERROR_NONE);
GPR_ASSERT(GRPC_SLICE_LENGTH(slice_with_null_term) == 1);
GPR_ASSERT(GRPC_SLICE_START_PTR(slice_with_null_term)[0] == 0);
remove(tmp_name);
gpr_free(tmp_name);
grpc_slice_unref(slice);
grpc_slice_unref(slice_with_null_term);
}
static void test_load_small_file(void) {
FILE *tmp = NULL;
grpc_slice slice;
grpc_slice slice_with_null_term;
grpc_error *error;
char *tmp_name;
const char *blah = "blah";
LOG_TEST_NAME("test_load_small_file");
tmp = gpr_tmpfile(prefix, &tmp_name);
GPR_ASSERT(tmp_name != NULL);
GPR_ASSERT(tmp != NULL);
GPR_ASSERT(fwrite(blah, 1, strlen(blah), tmp) == strlen(blah));
fclose(tmp);
error = grpc_load_file(tmp_name, 0, &slice);
GPR_ASSERT(error == GRPC_ERROR_NONE);
GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == strlen(blah));
GPR_ASSERT(!memcmp(GRPC_SLICE_START_PTR(slice), blah, strlen(blah)));
error = grpc_load_file(tmp_name, 1, &slice_with_null_term);
GPR_ASSERT(error == GRPC_ERROR_NONE);
GPR_ASSERT(GRPC_SLICE_LENGTH(slice_with_null_term) == (strlen(blah) + 1));
GPR_ASSERT(strcmp((const char *)GRPC_SLICE_START_PTR(slice_with_null_term),
blah) == 0);
remove(tmp_name);
gpr_free(tmp_name);
grpc_slice_unref(slice);
grpc_slice_unref(slice_with_null_term);
}
static void test_load_big_file(void) {
FILE *tmp = NULL;
grpc_slice slice;
grpc_error *error;
char *tmp_name;
static const size_t buffer_size = 124631;
unsigned char *buffer = gpr_malloc(buffer_size);
unsigned char *current;
size_t i;
LOG_TEST_NAME("test_load_big_file");
memset(buffer, 42, buffer_size);
tmp = gpr_tmpfile(prefix, &tmp_name);
GPR_ASSERT(tmp != NULL);
GPR_ASSERT(tmp_name != NULL);
GPR_ASSERT(fwrite(buffer, 1, buffer_size, tmp) == buffer_size);
fclose(tmp);
error = grpc_load_file(tmp_name, 0, &slice);
GPR_ASSERT(error == GRPC_ERROR_NONE);
GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == buffer_size);
current = GRPC_SLICE_START_PTR(slice);
for (i = 0; i < buffer_size; i++) {
GPR_ASSERT(current[i] == 42);
}
remove(tmp_name);
gpr_free(tmp_name);
grpc_slice_unref(slice);
gpr_free(buffer);
}
static void test_strjoin_sep(void) {
const char *parts[4] = {"one", "two", "three", "four"};
size_t joined_len;
char *joined;
LOG_TEST_NAME("test_strjoin_sep");
joined = gpr_strjoin_sep(parts, 4, ", ", &joined_len);
GPR_ASSERT(0 == strcmp("one, two, three, four", joined));
gpr_free(joined);
/* empty separator */
joined = gpr_strjoin_sep(parts, 4, "", &joined_len);
GPR_ASSERT(0 == strcmp("onetwothreefour", joined));
gpr_free(joined);
/* degenerated case specifying zero input parts */
joined = gpr_strjoin_sep(parts, 0, ", ", &joined_len);
GPR_ASSERT(0 == strcmp("", joined));
gpr_free(joined);
/* single part should have no separator */
joined = gpr_strjoin_sep(parts, 1, ", ", &joined_len);
GPR_ASSERT(0 == strcmp("one", joined));
gpr_free(joined);
}
static void test_parse_uint32(void) {
LOG_TEST_NAME("test_parse_uint32");
test_pu32_fail("-1");
test_pu32_fail("a");
test_pu32_fail("");
test_pu32_succeed("0", 0);
test_pu32_succeed("1", 1);
test_pu32_succeed("2", 2);
test_pu32_succeed("3", 3);
test_pu32_succeed("4", 4);
test_pu32_succeed("5", 5);
test_pu32_succeed("6", 6);
test_pu32_succeed("7", 7);
test_pu32_succeed("8", 8);
test_pu32_succeed("9", 9);
test_pu32_succeed("10", 10);
test_pu32_succeed("11", 11);
test_pu32_succeed("12", 12);
test_pu32_succeed("13", 13);
test_pu32_succeed("14", 14);
test_pu32_succeed("15", 15);
test_pu32_succeed("16", 16);
test_pu32_succeed("17", 17);
test_pu32_succeed("18", 18);
test_pu32_succeed("19", 19);
test_pu32_succeed("1234567890", 1234567890);
test_pu32_succeed("4294967295", 4294967295u);
test_pu32_fail("4294967296");
test_pu32_fail("4294967297");
test_pu32_fail("4294967298");
test_pu32_fail("4294967299");
}
static void test_load_big_file(void) {
FILE *tmp = NULL;
gpr_slice slice;
int success;
char *tmp_name;
unsigned char buffer[124631];
unsigned char *current;
size_t i;
LOG_TEST_NAME();
for (i = 0; i < sizeof(buffer); i++) {
buffer[i] = 42;
}
tmp = gpr_tmpfile(prefix, &tmp_name);
GPR_ASSERT(tmp != NULL);
GPR_ASSERT(tmp_name != NULL);
GPR_ASSERT(fwrite(buffer, 1, sizeof(buffer), tmp) == sizeof(buffer));
fclose(tmp);
slice = gpr_load_file(tmp_name, &success);
GPR_ASSERT(success == 1);
GPR_ASSERT(GPR_SLICE_LENGTH(slice) == sizeof(buffer));
current = GPR_SLICE_START_PTR(slice);
for (i = 0; i < sizeof(buffer); i++) {
GPR_ASSERT(current[i] == 42);
}
remove(tmp_name);
gpr_free(tmp_name);
gpr_slice_unref(slice);
}
static void test_dump(void) {
LOG_TEST_NAME("test_dump");
expect_dump("\x01", 1, GPR_DUMP_HEX, "01");
expect_dump("\x01", 1, GPR_DUMP_HEX | GPR_DUMP_ASCII, "01 '.'");
expect_dump("\x01\x02", 2, GPR_DUMP_HEX, "01 02");
expect_dump("\x01\x23\x45\x67\x89\xab\xcd\xef", 8, GPR_DUMP_HEX,
"01 23 45 67 89 ab cd ef");
expect_dump("ab", 2, GPR_DUMP_HEX | GPR_DUMP_ASCII, "61 62 'ab'");
}
static void test_hexdump(void) {
LOG_TEST_NAME("test_hexdump");
expect_hexdump("\x01", 1, 0, "01");
expect_hexdump("\x01", 1, GPR_HEXDUMP_PLAINTEXT, "01 '.'");
expect_hexdump("\x01\x02", 2, 0, "01 02");
expect_hexdump("\x01\x23\x45\x67\x89\xab\xcd\xef", 8, 0,
"01 23 45 67 89 ab cd ef");
expect_hexdump("ab", 2, GPR_HEXDUMP_PLAINTEXT, "61 62 'ab'");
}
static void test_strdup(void) {
static const char *src1 = "hello world";
char *dst1;
LOG_TEST_NAME("test_strdup");
dst1 = gpr_strdup(src1);
GPR_ASSERT(0 == strcmp(src1, dst1));
gpr_free(dst1);
GPR_ASSERT(NULL == gpr_strdup(NULL));
}
static void test_create_channel_stack(void) {
const grpc_channel_filter filter = {
call_func, channel_func, sizeof(int), call_init_func, call_destroy_func,
sizeof(int), channel_init_func, channel_destroy_func, "some_test_filter"};
const grpc_channel_filter *filters = &filter;
grpc_channel_stack *channel_stack;
grpc_call_stack *call_stack;
grpc_channel_element *channel_elem;
grpc_call_element *call_elem;
grpc_arg arg;
grpc_channel_args chan_args;
grpc_mdctx *metadata_context;
int *channel_data;
int *call_data;
LOG_TEST_NAME();
metadata_context = grpc_mdctx_create();
arg.type = GRPC_ARG_INTEGER;
arg.key = "test_key";
arg.value.integer = 42;
chan_args.num_args = 1;
chan_args.args = &arg;
channel_stack = gpr_malloc(grpc_channel_stack_size(&filters, 1));
grpc_channel_stack_init(&filters, 1, &chan_args, metadata_context,
channel_stack);
GPR_ASSERT(channel_stack->count == 1);
channel_elem = grpc_channel_stack_element(channel_stack, 0);
channel_data = (int *)channel_elem->channel_data;
GPR_ASSERT(*channel_data == 0);
call_stack = gpr_malloc(channel_stack->call_stack_size);
grpc_call_stack_init(channel_stack, NULL, NULL, call_stack);
GPR_ASSERT(call_stack->count == 1);
call_elem = grpc_call_stack_element(call_stack, 0);
GPR_ASSERT(call_elem->filter == channel_elem->filter);
GPR_ASSERT(call_elem->channel_data == channel_elem->channel_data);
call_data = (int *)call_elem->call_data;
GPR_ASSERT(*call_data == 0);
GPR_ASSERT(*channel_data == 1);
grpc_call_stack_destroy(call_stack);
gpr_free(call_stack);
GPR_ASSERT(*channel_data == 2);
grpc_channel_stack_destroy(channel_stack);
gpr_free(channel_stack);
grpc_mdctx_unref(metadata_context);
}
static void test_setenv_getenv(void) {
const char *name = "FOO";
const char *value = "BAR";
char *retrieved_value;
LOG_TEST_NAME("test_setenv_getenv");
gpr_setenv(name, value);
retrieved_value = gpr_getenv(name);
GPR_ASSERT(retrieved_value != NULL);
GPR_ASSERT(strcmp(value, retrieved_value) == 0);
gpr_free(retrieved_value);
}
static void test_dump_slice(void) {
static const char *text = "HELLO WORLD!";
static const char *long_text =
"It was a bright cold day in April, and the clocks were striking "
"thirteen. Winston Smith, his chin nuzzled into his breast in an effort "
"to escape the vile wind, slipped quickly through the glass doors of "
"Victory Mansions, though not quickly enough to prevent a swirl of "
"gritty dust from entering along with him.";
LOG_TEST_NAME("test_dump_slice");
expect_slice_dump(gpr_slice_from_copied_string(text), GPR_DUMP_ASCII, text);
expect_slice_dump(gpr_slice_from_copied_string(long_text), GPR_DUMP_ASCII,
long_text);
expect_slice_dump(gpr_slice_from_copied_buffer("\x01", 1), GPR_DUMP_HEX,
"01");
expect_slice_dump(gpr_slice_from_copied_buffer("\x01", 1),
GPR_DUMP_HEX | GPR_DUMP_ASCII, "01 '.'");
}
static void test_strjoin(void) {
const char *parts[4] = {"one", "two", "three", "four"};
size_t joined_len;
char *joined;
LOG_TEST_NAME("test_strjoin");
joined = gpr_strjoin(parts, 4, &joined_len);
GPR_ASSERT(0 == strcmp("onetwothreefour", joined));
gpr_free(joined);
joined = gpr_strjoin(parts, 0, &joined_len);
GPR_ASSERT(0 == strcmp("", joined));
gpr_free(joined);
joined = gpr_strjoin(parts, 1, &joined_len);
GPR_ASSERT(0 == strcmp("one", joined));
gpr_free(joined);
}
static void test_load_failure(void) {
FILE *tmp = NULL;
gpr_slice slice;
int success;
char *tmp_name;
LOG_TEST_NAME();
tmp = gpr_tmpfile(prefix, &tmp_name);
GPR_ASSERT(tmp_name != NULL);
GPR_ASSERT(tmp != NULL);
fclose(tmp);
remove(tmp_name);
slice = gpr_load_file(tmp_name, &success);
GPR_ASSERT(success == 0);
GPR_ASSERT(GPR_SLICE_LENGTH(slice) == 0);
gpr_free(tmp_name);
gpr_slice_unref(slice);
}
static void test_load_failure(void) {
FILE *tmp = NULL;
grpc_slice slice;
grpc_error *error;
char *tmp_name;
LOG_TEST_NAME("test_load_failure");
tmp = gpr_tmpfile(prefix, &tmp_name);
GPR_ASSERT(tmp_name != NULL);
GPR_ASSERT(tmp != NULL);
fclose(tmp);
remove(tmp_name);
error = grpc_load_file(tmp_name, 0, &slice);
GPR_ASSERT(error != GRPC_ERROR_NONE);
GRPC_ERROR_UNREF(error);
GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == 0);
gpr_free(tmp_name);
grpc_slice_unref(slice);
}
static void test_int64toa() {
char buf[GPR_INT64TOA_MIN_BUFSIZE];
LOG_TEST_NAME("test_int64toa");
/* zero */
GPR_ASSERT(1 == int64_ttoa(0, buf));
GPR_ASSERT(0 == strcmp("0", buf));
/* positive */
GPR_ASSERT(3 == int64_ttoa(123, buf));
GPR_ASSERT(0 == strcmp("123", buf));
/* large positive */
GPR_ASSERT(19 == int64_ttoa(9223372036854775807LL, buf));
GPR_ASSERT(0 == strcmp("9223372036854775807", buf));
/* large negative */
GPR_ASSERT(20 == int64_ttoa(-9223372036854775807LL - 1, buf));
GPR_ASSERT(0 == strcmp("-9223372036854775808", buf));
}
static void test_load_small_file(void) {
FILE *tmp = NULL;
gpr_slice slice;
int success;
char *tmp_name;
const char *blah = "blah";
LOG_TEST_NAME();
tmp = gpr_tmpfile(prefix, &tmp_name);
GPR_ASSERT(tmp_name != NULL);
GPR_ASSERT(tmp != NULL);
GPR_ASSERT(fwrite(blah, 1, strlen(blah), tmp) == strlen(blah));
fclose(tmp);
slice = gpr_load_file(tmp_name, &success);
GPR_ASSERT(success == 1);
GPR_ASSERT(GPR_SLICE_LENGTH(slice) == strlen(blah));
GPR_ASSERT(!memcmp(GPR_SLICE_START_PTR(slice), blah, strlen(blah)));
remove(tmp_name);
gpr_free(tmp_name);
gpr_slice_unref(slice);
}
static void test_ltoa() {
char *str;
char buf[GPR_LTOA_MIN_BUFSIZE];
LOG_TEST_NAME("test_ltoa");
/* zero */
GPR_ASSERT(1 == gpr_ltoa(0, buf));
GPR_ASSERT(0 == strcmp("0", buf));
/* positive number */
GPR_ASSERT(3 == gpr_ltoa(123, buf));
GPR_ASSERT(0 == strcmp("123", buf));
/* negative number */
GPR_ASSERT(6 == gpr_ltoa(-12345, buf));
GPR_ASSERT(0 == strcmp("-12345", buf));
/* large negative - we don't know the size of long in advance */
GPR_ASSERT(gpr_asprintf(&str, "%lld", (long long)LONG_MIN));
GPR_ASSERT(strlen(str) == (size_t)gpr_ltoa(LONG_MIN, buf));
GPR_ASSERT(0 == strcmp(str, buf));
gpr_free(str);
}
static void test_asprintf(void) {
char *buf;
int i, j;
LOG_TEST_NAME("test_asprintf");
/* Print an empty string. */
GPR_ASSERT(gpr_asprintf(&buf, "") == 0);
GPR_ASSERT(buf[0] == '\0');
gpr_free(buf);
/* Print strings of various lengths. */
for (i = 1; i < 100; i++) {
GPR_ASSERT(gpr_asprintf(&buf, "%0*d", i, 1) == i);
/* The buffer should resemble "000001\0". */
for (j = 0; j < i - 2; j++) {
GPR_ASSERT(buf[j] == '0');
}
GPR_ASSERT(buf[i - 1] == '1');
GPR_ASSERT(buf[i] == '\0');
gpr_free(buf);
}
}
static void test_strsplit(void) {
gpr_slice_buffer *parts;
gpr_slice str;
LOG_TEST_NAME("test_strsplit");
parts = gpr_malloc(sizeof(gpr_slice_buffer));
gpr_slice_buffer_init(parts);
str = gpr_slice_from_copied_string("one, two, three, four");
gpr_slice_split(str, ", ", parts);
GPR_ASSERT(4 == parts->count);
GPR_ASSERT(0 == gpr_slice_str_cmp(parts->slices[0], "one"));
GPR_ASSERT(0 == gpr_slice_str_cmp(parts->slices[1], "two"));
GPR_ASSERT(0 == gpr_slice_str_cmp(parts->slices[2], "three"));
GPR_ASSERT(0 == gpr_slice_str_cmp(parts->slices[3], "four"));
gpr_slice_buffer_reset_and_unref(parts);
gpr_slice_unref(str);
/* separator not present in string */
str = gpr_slice_from_copied_string("one two three four");
gpr_slice_split(str, ", ", parts);
GPR_ASSERT(1 == parts->count);
GPR_ASSERT(0 == gpr_slice_str_cmp(parts->slices[0], "one two three four"));
gpr_slice_buffer_reset_and_unref(parts);
gpr_slice_unref(str);
/* separator at the end */
str = gpr_slice_from_copied_string("foo,");
gpr_slice_split(str, ",", parts);
GPR_ASSERT(2 == parts->count);
GPR_ASSERT(0 == gpr_slice_str_cmp(parts->slices[0], "foo"));
GPR_ASSERT(0 == gpr_slice_str_cmp(parts->slices[1], ""));
gpr_slice_buffer_reset_and_unref(parts);
gpr_slice_unref(str);
/* separator at the beginning */
str = gpr_slice_from_copied_string(",foo");
gpr_slice_split(str, ",", parts);
GPR_ASSERT(2 == parts->count);
GPR_ASSERT(0 == gpr_slice_str_cmp(parts->slices[0], ""));
GPR_ASSERT(0 == gpr_slice_str_cmp(parts->slices[1], "foo"));
gpr_slice_buffer_reset_and_unref(parts);
gpr_slice_unref(str);
/* standalone separator */
str = gpr_slice_from_copied_string(",");
gpr_slice_split(str, ",", parts);
GPR_ASSERT(2 == parts->count);
GPR_ASSERT(0 == gpr_slice_str_cmp(parts->slices[0], ""));
GPR_ASSERT(0 == gpr_slice_str_cmp(parts->slices[1], ""));
gpr_slice_buffer_reset_and_unref(parts);
gpr_slice_unref(str);
/* empty input */
str = gpr_slice_from_copied_string("");
gpr_slice_split(str, ", ", parts);
GPR_ASSERT(1 == parts->count);
GPR_ASSERT(0 == gpr_slice_str_cmp(parts->slices[0], ""));
gpr_slice_buffer_reset_and_unref(parts);
gpr_slice_unref(str);
gpr_slice_buffer_destroy(parts);
gpr_free(parts);
}
