aboutsummaryrefslogtreecommitdiffhomepage
path: root/test/core/iomgr
diff options
context:
space:
mode:
Diffstat (limited to 'test/core/iomgr')
-rw-r--r--test/core/iomgr/BUILD84
-rw-r--r--test/core/iomgr/combiner_test.cc (renamed from test/core/iomgr/combiner_test.c)45
-rw-r--r--test/core/iomgr/endpoint_pair_test.cc (renamed from test/core/iomgr/endpoint_pair_test.c)25
-rw-r--r--test/core/iomgr/endpoint_tests.cc58
-rw-r--r--test/core/iomgr/endpoint_tests.h8
-rw-r--r--test/core/iomgr/error_test.cc (renamed from test/core/iomgr/error_test.c)0
-rw-r--r--test/core/iomgr/ev_epollsig_linux_test.cc (renamed from test/core/iomgr/ev_epollsig_linux_test.c)81
-rw-r--r--test/core/iomgr/fd_conservation_posix_test.cc (renamed from test/core/iomgr/fd_conservation_posix_test.c)6
-rw-r--r--test/core/iomgr/fd_posix_test.cc (renamed from test/core/iomgr/fd_posix_test.c)122
-rw-r--r--test/core/iomgr/load_file_test.cc (renamed from test/core/iomgr/load_file_test.c)34
-rw-r--r--test/core/iomgr/pollset_set_test.cc (renamed from test/core/iomgr/pollset_set_test.c)69
-rw-r--r--test/core/iomgr/resolve_address_posix_test.cc41
-rw-r--r--test/core/iomgr/resolve_address_test.cc (renamed from test/core/iomgr/resolve_address_test.c)65
-rw-r--r--test/core/iomgr/resource_quota_test.cc (renamed from test/core/iomgr/resource_quota_test.c)236
-rw-r--r--test/core/iomgr/sockaddr_utils_test.cc (renamed from test/core/iomgr/sockaddr_utils_test.c)48
-rw-r--r--test/core/iomgr/socket_utils_test.cc (renamed from test/core/iomgr/socket_utils_test.c)30
-rw-r--r--test/core/iomgr/tcp_client_posix_test.cc (renamed from test/core/iomgr/tcp_client_posix_test.c)47
-rw-r--r--test/core/iomgr/tcp_client_uv_test.cc (renamed from test/core/iomgr/tcp_client_uv_test.c)57
-rw-r--r--test/core/iomgr/tcp_posix_test.cc (renamed from test/core/iomgr/tcp_posix_test.c)131
-rw-r--r--test/core/iomgr/tcp_server_posix_test.cc (renamed from test/core/iomgr/tcp_server_posix_test.c)113
-rw-r--r--test/core/iomgr/tcp_server_uv_test.cc (renamed from test/core/iomgr/tcp_server_uv_test.c)96
-rw-r--r--test/core/iomgr/time_averaged_stats_test.cc (renamed from test/core/iomgr/time_averaged_stats_test.c)2
-rw-r--r--test/core/iomgr/timer_heap_test.cc (renamed from test/core/iomgr/timer_heap_test.c)41
-rw-r--r--test/core/iomgr/timer_list_test.cc (renamed from test/core/iomgr/timer_list_test.c)50
-rw-r--r--test/core/iomgr/udp_server_test.cc (renamed from test/core/iomgr/udp_server_test.c)95
-rw-r--r--test/core/iomgr/wakeup_fd_cv_test.cc (renamed from test/core/iomgr/wakeup_fd_cv_test.c)12
26 files changed, 811 insertions, 785 deletions
diff --git a/test/core/iomgr/BUILD b/test/core/iomgr/BUILD
index 7620d1de21..41e2607646 100644
--- a/test/core/iomgr/BUILD
+++ b/test/core/iomgr/BUILD
@@ -22,9 +22,9 @@ grpc_package(name = "test/core/iomgr", visibility = "public") # Useful for third
grpc_cc_library(
name = "endpoint_tests",
- srcs = ["endpoint_tests.c"],
+ srcs = ["endpoint_tests.cc"],
hdrs = ["endpoint_tests.h"],
- language = "C",
+ language = "C++",
visibility = ["//test:__subpackages__"],
deps = [
"//:gpr",
@@ -36,8 +36,8 @@ grpc_cc_library(
grpc_cc_test(
name = "combiner_test",
- srcs = ["combiner_test.c"],
- language = "C",
+ srcs = ["combiner_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -48,8 +48,8 @@ grpc_cc_test(
grpc_cc_test(
name = "endpoint_pair_test",
- srcs = ["endpoint_pair_test.c"],
- language = "C",
+ srcs = ["endpoint_pair_test.cc"],
+ language = "C++",
deps = [
":endpoint_tests",
"//:gpr",
@@ -61,20 +61,20 @@ grpc_cc_test(
grpc_cc_test(
name = "ev_epollsig_linux_test",
- srcs = ["ev_epollsig_linux_test.c"],
+ srcs = ["ev_epollsig_linux_test.cc"],
deps = [
"//:gpr",
"//:grpc",
"//test/core/util:gpr_test_util",
"//test/core/util:grpc_test_util",
],
- language = "C",
+ language = "C++",
)
grpc_cc_test(
name = "fd_conservation_posix_test",
- srcs = ["fd_conservation_posix_test.c"],
- language = "C",
+ srcs = ["fd_conservation_posix_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -85,8 +85,8 @@ grpc_cc_test(
grpc_cc_test(
name = "fd_posix_test",
- srcs = ["fd_posix_test.c"],
- language = "C",
+ srcs = ["fd_posix_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -97,8 +97,8 @@ grpc_cc_test(
grpc_cc_test(
name = "load_file_test",
- srcs = ["load_file_test.c"],
- language = "C",
+ srcs = ["load_file_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -109,8 +109,8 @@ grpc_cc_test(
grpc_cc_test(
name = "pollset_set_test",
- srcs = ["pollset_set_test.c"],
- language = "C",
+ srcs = ["pollset_set_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -121,8 +121,8 @@ grpc_cc_test(
grpc_cc_test(
name = "resolve_address_posix_test",
- srcs = ["resolve_address_posix_test.c"],
- language = "C",
+ srcs = ["resolve_address_posix_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -133,8 +133,8 @@ grpc_cc_test(
grpc_cc_test(
name = "resolve_address_test",
- srcs = ["resolve_address_test.c"],
- language = "C",
+ srcs = ["resolve_address_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -145,8 +145,8 @@ grpc_cc_test(
grpc_cc_test(
name = "resource_quota_test",
- srcs = ["resource_quota_test.c"],
- language = "C",
+ srcs = ["resource_quota_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -157,8 +157,8 @@ grpc_cc_test(
grpc_cc_test(
name = "sockaddr_utils_test",
- srcs = ["sockaddr_utils_test.c"],
- language = "C",
+ srcs = ["sockaddr_utils_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -169,8 +169,8 @@ grpc_cc_test(
grpc_cc_test(
name = "socket_utils_test",
- srcs = ["socket_utils_test.c"],
- language = "C",
+ srcs = ["socket_utils_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -181,8 +181,8 @@ grpc_cc_test(
grpc_cc_test(
name = "tcp_client_posix_test",
- srcs = ["tcp_client_posix_test.c"],
- language = "C",
+ srcs = ["tcp_client_posix_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -193,8 +193,8 @@ grpc_cc_test(
grpc_cc_test(
name = "tcp_posix_test",
- srcs = ["tcp_posix_test.c"],
- language = "C",
+ srcs = ["tcp_posix_test.cc"],
+ language = "C++",
deps = [
":endpoint_tests",
"//:gpr",
@@ -206,8 +206,8 @@ grpc_cc_test(
grpc_cc_test(
name = "tcp_server_posix_test",
- srcs = ["tcp_server_posix_test.c"],
- language = "C",
+ srcs = ["tcp_server_posix_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -218,8 +218,8 @@ grpc_cc_test(
grpc_cc_test(
name = "time_averaged_stats_test",
- srcs = ["time_averaged_stats_test.c"],
- language = "C",
+ srcs = ["time_averaged_stats_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -230,8 +230,8 @@ grpc_cc_test(
grpc_cc_test(
name = "timer_heap_test",
- srcs = ["timer_heap_test.c"],
- language = "C",
+ srcs = ["timer_heap_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -242,8 +242,8 @@ grpc_cc_test(
grpc_cc_test(
name = "timer_list_test",
- srcs = ["timer_list_test.c"],
- language = "C",
+ srcs = ["timer_list_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -254,8 +254,8 @@ grpc_cc_test(
grpc_cc_test(
name = "udp_server_test",
- srcs = ["udp_server_test.c"],
- language = "C",
+ srcs = ["udp_server_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -266,8 +266,8 @@ grpc_cc_test(
grpc_cc_test(
name = "wakeup_fd_cv_test",
- srcs = ["wakeup_fd_cv_test.c"],
- language = "C",
+ srcs = ["wakeup_fd_cv_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
diff --git a/test/core/iomgr/combiner_test.c b/test/core/iomgr/combiner_test.cc
index 121cbfe41a..9fc1890c97 100644
--- a/test/core/iomgr/combiner_test.c
+++ b/test/core/iomgr/combiner_test.cc
@@ -28,22 +28,22 @@
static void test_no_op(void) {
gpr_log(GPR_DEBUG, "test_no_op");
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
GRPC_COMBINER_UNREF(grpc_combiner_create(), "test_no_op");
grpc_exec_ctx_finish();
}
-static void set_event_to_true(void *value, grpc_error *error) {
- gpr_event_set(value, (void *)1);
+static void set_event_to_true(void* value, grpc_error* error) {
+ gpr_event_set(static_cast<gpr_event*>(value), (void*)1);
}
static void test_execute_one(void) {
gpr_log(GPR_DEBUG, "test_execute_one");
- grpc_combiner *lock = grpc_combiner_create();
+ grpc_combiner* lock = grpc_combiner_create();
gpr_event done;
gpr_event_init(&done);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
GRPC_CLOSURE_SCHED(GRPC_CLOSURE_CREATE(set_event_to_true, &done,
grpc_combiner_scheduler(lock)),
GRPC_ERROR_NONE);
@@ -56,29 +56,29 @@ static void test_execute_one(void) {
typedef struct {
size_t ctr;
- grpc_combiner *lock;
+ grpc_combiner* lock;
gpr_event done;
} thd_args;
typedef struct {
- size_t *ctr;
+ size_t* ctr;
size_t value;
} ex_args;
-static void check_one(void *a, grpc_error *error) {
- ex_args *args = a;
+static void check_one(void* a, grpc_error* error) {
+ ex_args* args = static_cast<ex_args*>(a);
GPR_ASSERT(*args->ctr == args->value - 1);
*args->ctr = args->value;
gpr_free(a);
}
-static void execute_many_loop(void *a) {
- thd_args *args = a;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+static void execute_many_loop(void* a) {
+ thd_args* args = static_cast<thd_args*>(a);
+ ExecCtx _local_exec_ctx;
size_t n = 1;
for (size_t i = 0; i < 10; i++) {
for (size_t j = 0; j < 10000; j++) {
- ex_args *c = gpr_malloc(sizeof(*c));
+ ex_args* c = static_cast<ex_args*>(gpr_malloc(sizeof(*c)));
c->ctr = &args->ctr;
c->value = n++;
GRPC_CLOSURE_SCHED(GRPC_CLOSURE_CREATE(
@@ -99,7 +99,7 @@ static void execute_many_loop(void *a) {
static void test_execute_many(void) {
gpr_log(GPR_DEBUG, "test_execute_many");
- grpc_combiner *lock = grpc_combiner_create();
+ grpc_combiner* lock = grpc_combiner_create();
gpr_thd_id thds[100];
thd_args ta[GPR_ARRAY_SIZE(thds)];
for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {
@@ -115,28 +115,29 @@ static void test_execute_many(void) {
gpr_inf_future(GPR_CLOCK_REALTIME)) != NULL);
gpr_thd_join(thds[i]);
}
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
GRPC_COMBINER_UNREF(lock, "test_execute_many");
grpc_exec_ctx_finish();
}
static gpr_event got_in_finally;
-static void in_finally(void *arg, grpc_error *error) {
- gpr_event_set(&got_in_finally, (void *)1);
+static void in_finally(void* arg, grpc_error* error) {
+ gpr_event_set(&got_in_finally, (void*)1);
}
-static void add_finally(void *arg, grpc_error *error) {
+static void add_finally(void* arg, grpc_error* error) {
GRPC_CLOSURE_SCHED(GRPC_CLOSURE_CREATE(in_finally, arg,
- grpc_combiner_finally_scheduler(arg)),
+ grpc_combiner_finally_scheduler(
+ static_cast<grpc_combiner*>(arg))),
GRPC_ERROR_NONE);
}
static void test_execute_finally(void) {
gpr_log(GPR_DEBUG, "test_execute_finally");
- grpc_combiner *lock = grpc_combiner_create();
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ grpc_combiner* lock = grpc_combiner_create();
+ ExecCtx _local_exec_ctx;
gpr_event_init(&got_in_finally);
GRPC_CLOSURE_SCHED(
GRPC_CLOSURE_CREATE(add_finally, lock, grpc_combiner_scheduler(lock)),
@@ -148,7 +149,7 @@ static void test_execute_finally(void) {
grpc_exec_ctx_finish();
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
grpc_init();
test_no_op();
diff --git a/test/core/iomgr/endpoint_pair_test.c b/test/core/iomgr/endpoint_pair_test.cc
index 989cc80016..bddeadd329 100644
--- a/test/core/iomgr/endpoint_pair_test.c
+++ b/test/core/iomgr/endpoint_pair_test.cc
@@ -25,19 +25,20 @@
#include "test/core/iomgr/endpoint_tests.h"
#include "test/core/util/test_config.h"
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
static void clean_up(void) {}
static grpc_endpoint_test_fixture create_fixture_endpoint_pair(
size_t slice_size) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_endpoint_test_fixture f;
- grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
- .type = GRPC_ARG_INTEGER,
- .value.integer = (int)slice_size}};
- grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+ grpc_arg a[1];
+ a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+ a[0].type = GRPC_ARG_INTEGER;
+ a[0].value.integer = (int)slice_size;
+ grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
grpc_endpoint_pair p = grpc_iomgr_create_endpoint_pair("test", &args);
f.client_ep = p.client;
@@ -53,16 +54,16 @@ static grpc_endpoint_test_config configs[] = {
{"tcp/tcp_socketpair", create_fixture_endpoint_pair, clean_up},
};
-static void destroy_pollset(void *p, grpc_error *error) {
- grpc_pollset_destroy(p);
+static void destroy_pollset(void* p, grpc_error* error) {
+ grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_test_init(argc, argv);
grpc_init();
- g_pollset = gpr_zalloc(grpc_pollset_size());
+ g_pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
grpc_pollset_init(g_pollset, &g_mu);
grpc_endpoint_tests(configs[0], g_pollset, g_mu);
GRPC_CLOSURE_INIT(&destroyed, destroy_pollset, g_pollset,
diff --git a/test/core/iomgr/endpoint_tests.cc b/test/core/iomgr/endpoint_tests.cc
index a6ac24a261..10e80fc71b 100644
--- a/test/core/iomgr/endpoint_tests.cc
+++ b/test/core/iomgr/endpoint_tests.cc
@@ -46,14 +46,14 @@
*/
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
-size_t count_slices(grpc_slice *slices, size_t nslices, int *current_data) {
+size_t count_slices(grpc_slice* slices, size_t nslices, int* current_data) {
size_t num_bytes = 0;
size_t i;
size_t j;
- unsigned char *buf;
+ unsigned char* buf;
for (i = 0; i < nslices; ++i) {
buf = GRPC_SLICE_START_PTR(slices[i]);
for (j = 0; j < GRPC_SLICE_LENGTH(slices[i]); ++j) {
@@ -66,7 +66,7 @@ size_t count_slices(grpc_slice *slices, size_t nslices, int *current_data) {
}
static grpc_endpoint_test_fixture begin_test(grpc_endpoint_test_config config,
- const char *test_name,
+ const char* test_name,
size_t slice_size) {
gpr_log(GPR_INFO, "%s/%s", test_name, config.name);
return config.create_fixture(slice_size);
@@ -74,14 +74,14 @@ static grpc_endpoint_test_fixture begin_test(grpc_endpoint_test_config config,
static void end_test(grpc_endpoint_test_config config) { config.clean_up(); }
-static grpc_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
- size_t *num_blocks, uint8_t *current_data) {
+static grpc_slice* allocate_blocks(size_t num_bytes, size_t slice_size,
+ size_t* num_blocks, uint8_t* current_data) {
size_t nslices = num_bytes / slice_size + (num_bytes % slice_size ? 1 : 0);
- grpc_slice *slices = (grpc_slice *)gpr_malloc(sizeof(grpc_slice) * nslices);
+ grpc_slice* slices = (grpc_slice*)gpr_malloc(sizeof(grpc_slice) * nslices);
size_t num_bytes_left = num_bytes;
size_t i;
size_t j;
- unsigned char *buf;
+ unsigned char* buf;
*num_blocks = nslices;
for (i = 0; i < nslices; ++i) {
@@ -99,8 +99,8 @@ static grpc_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
}
struct read_and_write_test_state {
- grpc_endpoint *read_ep;
- grpc_endpoint *write_ep;
+ grpc_endpoint* read_ep;
+ grpc_endpoint* write_ep;
size_t target_bytes;
size_t bytes_read;
size_t current_write_size;
@@ -115,9 +115,9 @@ struct read_and_write_test_state {
grpc_closure done_write;
};
-static void read_and_write_test_read_handler(void *data, grpc_error *error) {
- struct read_and_write_test_state *state =
- (struct read_and_write_test_state *)data;
+static void read_and_write_test_read_handler(void* data, grpc_error* error) {
+ struct read_and_write_test_state* state =
+ (struct read_and_write_test_state*)data;
state->bytes_read += count_slices(
state->incoming.slices, state->incoming.count, &state->current_read_data);
@@ -132,10 +132,10 @@ static void read_and_write_test_read_handler(void *data, grpc_error *error) {
}
}
-static void read_and_write_test_write_handler(void *data, grpc_error *error) {
- struct read_and_write_test_state *state =
- (struct read_and_write_test_state *)data;
- grpc_slice *slices = NULL;
+static void read_and_write_test_write_handler(void* data, grpc_error* error) {
+ struct read_and_write_test_state* state =
+ (struct read_and_write_test_state*)data;
+ grpc_slice* slices = NULL;
size_t nslices;
if (error == GRPC_ERROR_NONE) {
@@ -176,15 +176,17 @@ static void read_and_write_test(grpc_endpoint_test_config config,
ExecCtx _local_exec_ctx;
grpc_millis deadline =
grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(20));
- gpr_log(GPR_DEBUG, "num_bytes=%" PRIuPTR " write_size=%" PRIuPTR
- " slice_size=%" PRIuPTR " shutdown=%d",
+ gpr_log(GPR_DEBUG,
+ "num_bytes=%" PRIuPTR " write_size=%" PRIuPTR " slice_size=%" PRIuPTR
+ " shutdown=%d",
num_bytes, write_size, slice_size, shutdown);
if (shutdown) {
gpr_log(GPR_INFO, "Start read and write shutdown test");
} else {
- gpr_log(GPR_INFO, "Start read and write test with %" PRIuPTR
- " bytes, slice size %" PRIuPTR,
+ gpr_log(GPR_INFO,
+ "Start read and write test with %" PRIuPTR
+ " bytes, slice size %" PRIuPTR,
num_bytes, slice_size);
}
@@ -227,7 +229,7 @@ static void read_and_write_test(grpc_endpoint_test_config config,
gpr_mu_lock(g_mu);
while (!state.read_done || !state.write_done) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(grpc_exec_ctx_now() < deadline);
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work", grpc_pollset_work(g_pollset, &worker, deadline)));
@@ -243,20 +245,20 @@ static void read_and_write_test(grpc_endpoint_test_config config,
grpc_exec_ctx_finish();
}
-static void inc_on_failure(void *arg, grpc_error *error) {
+static void inc_on_failure(void* arg, grpc_error* error) {
gpr_mu_lock(g_mu);
- *(int *)arg += (error != GRPC_ERROR_NONE);
+ *(int*)arg += (error != GRPC_ERROR_NONE);
GPR_ASSERT(GRPC_LOG_IF_ERROR("kick", grpc_pollset_kick(g_pollset, NULL)));
gpr_mu_unlock(g_mu);
}
-static void wait_for_fail_count(int *fail_count, int want_fail_count) {
+static void wait_for_fail_count(int* fail_count, int want_fail_count) {
grpc_exec_ctx_flush();
gpr_mu_lock(g_mu);
grpc_millis deadline =
grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(10));
while (grpc_exec_ctx_now() < deadline && *fail_count < want_fail_count) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work", grpc_pollset_work(g_pollset, &worker, deadline)));
gpr_mu_unlock(g_mu);
@@ -305,7 +307,7 @@ static void multiple_shutdown_test(grpc_endpoint_test_config config) {
}
void grpc_endpoint_tests(grpc_endpoint_test_config config,
- grpc_pollset *pollset, gpr_mu *mu) {
+ grpc_pollset* pollset, gpr_mu* mu) {
size_t i;
g_pollset = pollset;
g_mu = mu;
diff --git a/test/core/iomgr/endpoint_tests.h b/test/core/iomgr/endpoint_tests.h
index def29d3224..227eeb997c 100644
--- a/test/core/iomgr/endpoint_tests.h
+++ b/test/core/iomgr/endpoint_tests.h
@@ -27,17 +27,17 @@ typedef struct grpc_endpoint_test_config grpc_endpoint_test_config;
typedef struct grpc_endpoint_test_fixture grpc_endpoint_test_fixture;
struct grpc_endpoint_test_fixture {
- grpc_endpoint *client_ep;
- grpc_endpoint *server_ep;
+ grpc_endpoint* client_ep;
+ grpc_endpoint* server_ep;
};
struct grpc_endpoint_test_config {
- const char *name;
+ const char* name;
grpc_endpoint_test_fixture (*create_fixture)(size_t slice_size);
void (*clean_up)();
};
void grpc_endpoint_tests(grpc_endpoint_test_config config,
- grpc_pollset *pollset, gpr_mu *mu);
+ grpc_pollset* pollset, gpr_mu* mu);
#endif /* GRPC_TEST_CORE_IOMGR_ENDPOINT_TESTS_H */
diff --git a/test/core/iomgr/error_test.c b/test/core/iomgr/error_test.cc
index 51f8af1957..51f8af1957 100644
--- a/test/core/iomgr/error_test.c
+++ b/test/core/iomgr/error_test.cc
diff --git a/test/core/iomgr/ev_epollsig_linux_test.c b/test/core/iomgr/ev_epollsig_linux_test.cc
index e6f9f59bd3..5dd28eac9c 100644
--- a/test/core/iomgr/ev_epollsig_linux_test.c
+++ b/test/core/iomgr/ev_epollsig_linux_test.cc
@@ -36,17 +36,17 @@
#include "test/core/util/test_config.h"
typedef struct test_pollset {
- grpc_pollset *pollset;
- gpr_mu *mu;
+ grpc_pollset* pollset;
+ gpr_mu* mu;
} test_pollset;
typedef struct test_fd {
int inner_fd;
- grpc_fd *fd;
+ grpc_fd* fd;
} test_fd;
/* num_fds should be an even number */
-static void test_fd_init(test_fd *tfds, int *fds, int num_fds) {
+static void test_fd_init(test_fd* tfds, int* fds, int num_fds) {
int i;
int r;
@@ -70,7 +70,7 @@ static void test_fd_init(test_fd *tfds, int *fds, int num_fds) {
}
}
-static void test_fd_cleanup(test_fd *tfds, int num_fds) {
+static void test_fd_cleanup(test_fd* tfds, int num_fds) {
int release_fd;
int i;
@@ -88,19 +88,20 @@ static void test_fd_cleanup(test_fd *tfds, int num_fds) {
}
}
-static void test_pollset_init(test_pollset *pollsets, int num_pollsets) {
+static void test_pollset_init(test_pollset* pollsets, int num_pollsets) {
int i;
for (i = 0; i < num_pollsets; i++) {
- pollsets[i].pollset = gpr_zalloc(grpc_pollset_size());
+ pollsets[i].pollset =
+ static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
grpc_pollset_init(pollsets[i].pollset, &pollsets[i].mu);
}
}
-static void destroy_pollset(void *p, grpc_error *error) {
- grpc_pollset_destroy(p);
+static void destroy_pollset(void* p, grpc_error* error) {
+ grpc_pollset_destroy((grpc_pollset*)p);
}
-static void test_pollset_cleanup(test_pollset *pollsets, int num_pollsets) {
+static void test_pollset_cleanup(test_pollset* pollsets, int num_pollsets) {
grpc_closure destroyed;
int i;
@@ -114,26 +115,26 @@ static void test_pollset_cleanup(test_pollset *pollsets, int num_pollsets) {
}
}
-/*
- * Cases to test:
- * case 1) Polling islands of both fd and pollset are NULL
- * case 2) Polling island of fd is NULL but that of pollset is not-NULL
- * case 3) Polling island of fd is not-NULL but that of pollset is NULL
- * case 4) Polling islands of both fd and pollset are not-NULL and:
- * case 4.1) Polling islands of fd and pollset are equal
- * case 4.2) Polling islands of fd and pollset are NOT-equal (This results
- * in a merge)
- * */
+ /*
+ * Cases to test:
+ * case 1) Polling islands of both fd and pollset are NULL
+ * case 2) Polling island of fd is NULL but that of pollset is not-NULL
+ * case 3) Polling island of fd is not-NULL but that of pollset is NULL
+ * case 4) Polling islands of both fd and pollset are not-NULL and:
+ * case 4.1) Polling islands of fd and pollset are equal
+ * case 4.2) Polling islands of fd and pollset are NOT-equal (This results
+ * in a merge)
+ * */
#define NUM_FDS 8
#define NUM_POLLSETS 4
static void test_add_fd_to_pollset() {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
test_fd tfds[NUM_FDS];
int fds[NUM_FDS];
test_pollset pollsets[NUM_POLLSETS];
- void *expected_pi = NULL;
+ void* expected_pi = NULL;
int i;
test_fd_init(tfds, fds, NUM_FDS);
@@ -218,21 +219,21 @@ static void test_add_fd_to_pollset() {
#undef NUM_POLLSETS
typedef struct threading_shared {
- gpr_mu *mu;
- grpc_pollset *pollset;
- grpc_wakeup_fd *wakeup_fd;
- grpc_fd *wakeup_desc;
+ gpr_mu* mu;
+ grpc_pollset* pollset;
+ grpc_wakeup_fd* wakeup_fd;
+ grpc_fd* wakeup_desc;
grpc_closure on_wakeup;
int wakeups;
} threading_shared;
static __thread int thread_wakeups = 0;
-static void test_threading_loop(void *arg) {
- threading_shared *shared = arg;
+static void test_threading_loop(void* arg) {
+ threading_shared* shared = static_cast<threading_shared*>(arg);
while (thread_wakeups < 1000000) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_pollset_worker *worker;
+ ExecCtx _local_exec_ctx;
+ grpc_pollset_worker* worker;
gpr_mu_lock(shared->mu);
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
@@ -242,8 +243,8 @@ static void test_threading_loop(void *arg) {
}
}
-static void test_threading_wakeup(void *arg, grpc_error *error) {
- threading_shared *shared = arg;
+static void test_threading_wakeup(void* arg, grpc_error* error) {
+ threading_shared* shared = static_cast<threading_shared*>(arg);
++shared->wakeups;
++thread_wakeups;
if (error == GRPC_ERROR_NONE) {
@@ -257,7 +258,7 @@ static void test_threading_wakeup(void *arg, grpc_error *error) {
static void test_threading(void) {
threading_shared shared;
- shared.pollset = gpr_zalloc(grpc_pollset_size());
+ shared.pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
grpc_pollset_init(shared.pollset, &shared.mu);
gpr_thd_id thds[10];
@@ -272,7 +273,7 @@ static void test_threading(void) {
shared.wakeup_desc = grpc_fd_create(fd.read_fd, "wakeup");
shared.wakeups = 0;
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_pollset_add_fd(shared.pollset, shared.wakeup_desc);
grpc_fd_notify_on_read(
shared.wakeup_desc,
@@ -288,7 +289,7 @@ static void test_threading(void) {
fd.read_fd = 0;
grpc_wakeup_fd_destroy(&fd);
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_fd_shutdown(shared.wakeup_desc, GRPC_ERROR_CANCELLED);
grpc_fd_orphan(shared.wakeup_desc, NULL, NULL, false /* already_closed */,
"done");
@@ -300,11 +301,11 @@ static void test_threading(void) {
gpr_free(shared.pollset);
}
-int main(int argc, char **argv) {
- const char *poll_strategy = NULL;
+int main(int argc, char** argv) {
+ const char* poll_strategy = NULL;
grpc_test_init(argc, argv);
grpc_init();
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
poll_strategy = grpc_get_poll_strategy_name();
if (poll_strategy != NULL && strcmp(poll_strategy, "epollsig") == 0) {
@@ -321,6 +322,6 @@ int main(int argc, char **argv) {
grpc_shutdown();
return 0;
}
-#else /* defined(GRPC_LINUX_EPOLL) */
-int main(int argc, char **argv) { return 0; }
+#else /* defined(GRPC_LINUX_EPOLL) */
+int main(int argc, char** argv) { return 0; }
#endif /* !defined(GRPC_LINUX_EPOLL) */
diff --git a/test/core/iomgr/fd_conservation_posix_test.c b/test/core/iomgr/fd_conservation_posix_test.cc
index 8fcb01efd8..a5f6d33998 100644
--- a/test/core/iomgr/fd_conservation_posix_test.c
+++ b/test/core/iomgr/fd_conservation_posix_test.cc
@@ -24,21 +24,21 @@
#include "src/core/lib/iomgr/iomgr.h"
#include "test/core/util/test_config.h"
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
int i;
struct rlimit rlim;
grpc_endpoint_pair p;
grpc_test_init(argc, argv);
grpc_init();
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
/* set max # of file descriptors to a low value, and
verify we can create and destroy many more than this number
of descriptors */
rlim.rlim_cur = rlim.rlim_max = 10;
GPR_ASSERT(0 == setrlimit(RLIMIT_NOFILE, &rlim));
- grpc_resource_quota *resource_quota =
+ grpc_resource_quota* resource_quota =
grpc_resource_quota_create("fd_conservation_posix_test");
for (i = 0; i < 100; i++) {
diff --git a/test/core/iomgr/fd_posix_test.c b/test/core/iomgr/fd_posix_test.cc
index d16b556768..9bf16923cb 100644
--- a/test/core/iomgr/fd_posix_test.c
+++ b/test/core/iomgr/fd_posix_test.cc
@@ -46,8 +46,8 @@
#include "src/core/lib/iomgr/socket_utils_posix.h"
#include "test/core/util/test_config.h"
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
/* buffer size used to send and receive data.
1024 is the minimal value to set TCP send and receive buffer. */
@@ -56,8 +56,8 @@ static grpc_pollset *g_pollset;
/* Create a test socket with the right properties for testing.
port is the TCP port to listen or connect to.
Return a socket FD and sockaddr_in. */
-static void create_test_socket(int port, int *socket_fd,
- struct sockaddr_in *sin) {
+static void create_test_socket(int port, int* socket_fd,
+ struct sockaddr_in* sin) {
int fd;
int one = 1;
int buffer_size_bytes = BUF_SIZE;
@@ -82,20 +82,20 @@ static void create_test_socket(int port, int *socket_fd,
}
/* Dummy gRPC callback */
-void no_op_cb(void *arg, int success) {}
+void no_op_cb(void* arg, int success) {}
/* =======An upload server to test notify_on_read===========
The server simply reads and counts a stream of bytes. */
/* An upload server. */
typedef struct {
- grpc_fd *em_fd; /* listening fd */
+ grpc_fd* em_fd; /* listening fd */
ssize_t read_bytes_total; /* total number of received bytes */
int done; /* set to 1 when a server finishes serving */
grpc_closure listen_closure;
} server;
-static void server_init(server *sv) {
+static void server_init(server* sv) {
sv->read_bytes_total = 0;
sv->done = 0;
}
@@ -103,18 +103,18 @@ static void server_init(server *sv) {
/* An upload session.
Created when a new upload request arrives in the server. */
typedef struct {
- server *sv; /* not owned by a single session */
- grpc_fd *em_fd; /* fd to read upload bytes */
+ server* sv; /* not owned by a single session */
+ grpc_fd* em_fd; /* fd to read upload bytes */
char read_buf[BUF_SIZE]; /* buffer to store upload bytes */
grpc_closure session_read_closure;
} session;
/* Called when an upload session can be safely shutdown.
Close session FD and start to shutdown listen FD. */
-static void session_shutdown_cb(void *arg, /*session */
+static void session_shutdown_cb(void* arg, /*session */
bool success) {
- session *se = arg;
- server *sv = se->sv;
+ session* se = static_cast<session*>(arg);
+ server* sv = se->sv;
grpc_fd_orphan(se->em_fd, NULL, NULL, false /* already_closed */, "a");
gpr_free(se);
/* Start to shutdown listen fd. */
@@ -123,9 +123,9 @@ static void session_shutdown_cb(void *arg, /*session */
}
/* Called when data become readable in a session. */
-static void session_read_cb(void *arg, /*session */
- grpc_error *error) {
- session *se = arg;
+static void session_read_cb(void* arg, /*session */
+ grpc_error* error) {
+ session* se = static_cast<session*>(arg);
int fd = grpc_fd_wrapped_fd(se->em_fd);
ssize_t read_once = 0;
@@ -168,8 +168,8 @@ static void session_read_cb(void *arg, /*session */
/* Called when the listen FD can be safely shutdown.
Close listen FD and signal that server can be shutdown. */
-static void listen_shutdown_cb(void *arg /*server */, int success) {
- server *sv = arg;
+static void listen_shutdown_cb(void* arg /*server */, int success) {
+ server* sv = static_cast<server*>(arg);
grpc_fd_orphan(sv->em_fd, NULL, NULL, false /* already_closed */, "b");
@@ -181,27 +181,27 @@ static void listen_shutdown_cb(void *arg /*server */, int success) {
}
/* Called when a new TCP connection request arrives in the listening port. */
-static void listen_cb(void *arg, /*=sv_arg*/
- grpc_error *error) {
- server *sv = arg;
+static void listen_cb(void* arg, /*=sv_arg*/
+ grpc_error* error) {
+ server* sv = static_cast<server*>(arg);
int fd;
int flags;
- session *se;
+ session* se;
struct sockaddr_storage ss;
socklen_t slen = sizeof(ss);
- grpc_fd *listen_em_fd = sv->em_fd;
+ grpc_fd* listen_em_fd = sv->em_fd;
if (error != GRPC_ERROR_NONE) {
listen_shutdown_cb(arg, 1);
return;
}
- fd = accept(grpc_fd_wrapped_fd(listen_em_fd), (struct sockaddr *)&ss, &slen);
+ fd = accept(grpc_fd_wrapped_fd(listen_em_fd), (struct sockaddr*)&ss, &slen);
GPR_ASSERT(fd >= 0);
GPR_ASSERT(fd < FD_SETSIZE);
flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
- se = gpr_malloc(sizeof(*se));
+ se = static_cast<session*>(gpr_malloc(sizeof(*se)));
se->sv = sv;
se->em_fd = grpc_fd_create(fd, "listener");
grpc_pollset_add_fd(g_pollset, se->em_fd);
@@ -219,7 +219,7 @@ static void listen_cb(void *arg, /*=sv_arg*/
listen_cb() is registered to be interested in reading from listen_fd.
When connection request arrives, listen_cb() is called to accept the
connection request. */
-static int server_start(server *sv) {
+static int server_start(server* sv) {
int port = 0;
int fd;
struct sockaddr_in sin;
@@ -227,8 +227,8 @@ static int server_start(server *sv) {
create_test_socket(port, &fd, &sin);
addr_len = sizeof(sin);
- GPR_ASSERT(bind(fd, (struct sockaddr *)&sin, addr_len) == 0);
- GPR_ASSERT(getsockname(fd, (struct sockaddr *)&sin, &addr_len) == 0);
+ GPR_ASSERT(bind(fd, (struct sockaddr*)&sin, addr_len) == 0);
+ GPR_ASSERT(getsockname(fd, (struct sockaddr*)&sin, &addr_len) == 0);
port = ntohs(sin.sin_port);
GPR_ASSERT(listen(fd, MAX_NUM_FD) == 0);
@@ -243,11 +243,11 @@ static int server_start(server *sv) {
}
/* Wait and shutdown a sever. */
-static void server_wait_and_shutdown(server *sv) {
+static void server_wait_and_shutdown(server* sv) {
gpr_mu_lock(g_mu);
while (!sv->done) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_pollset_worker *worker = NULL;
+ ExecCtx _local_exec_ctx;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(g_pollset, &worker, GRPC_MILLIS_INF_FUTURE)));
@@ -267,7 +267,7 @@ static void server_wait_and_shutdown(server *sv) {
/* An upload client. */
typedef struct {
- grpc_fd *em_fd;
+ grpc_fd* em_fd;
char write_buf[CLIENT_WRITE_BUF_SIZE];
ssize_t write_bytes_total;
/* Number of times that the client fills up the write buffer and calls
@@ -278,7 +278,7 @@ typedef struct {
grpc_closure write_closure;
} client;
-static void client_init(client *cl) {
+static void client_init(client* cl) {
memset(cl->write_buf, 0, sizeof(cl->write_buf));
cl->write_bytes_total = 0;
cl->client_write_cnt = 0;
@@ -286,8 +286,8 @@ static void client_init(client *cl) {
}
/* Called when a client upload session is ready to shutdown. */
-static void client_session_shutdown_cb(void *arg /*client */, int success) {
- client *cl = arg;
+static void client_session_shutdown_cb(void* arg /*client */, int success) {
+ client* cl = static_cast<client*>(arg);
grpc_fd_orphan(cl->em_fd, NULL, NULL, false /* already_closed */, "c");
cl->done = 1;
GPR_ASSERT(
@@ -295,9 +295,9 @@ static void client_session_shutdown_cb(void *arg /*client */, int success) {
}
/* Write as much as possible, then register notify_on_write. */
-static void client_session_write(void *arg, /*client */
- grpc_error *error) {
- client *cl = arg;
+static void client_session_write(void* arg, /*client */
+ grpc_error* error) {
+ client* cl = static_cast<client*>(arg);
int fd = grpc_fd_wrapped_fd(cl->em_fd);
ssize_t write_once = 0;
@@ -331,11 +331,11 @@ static void client_session_write(void *arg, /*client */
}
/* Start a client to send a stream of bytes. */
-static void client_start(client *cl, int port) {
+static void client_start(client* cl, int port) {
int fd;
struct sockaddr_in sin;
create_test_socket(port, &fd, &sin);
- if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)) == -1) {
+ if (connect(fd, (struct sockaddr*)&sin, sizeof(sin)) == -1) {
if (errno == EINPROGRESS) {
struct pollfd pfd;
pfd.fd = fd;
@@ -358,11 +358,11 @@ static void client_start(client *cl, int port) {
}
/* Wait for the signal to shutdown a client. */
-static void client_wait_and_shutdown(client *cl) {
+static void client_wait_and_shutdown(client* cl) {
gpr_mu_lock(g_mu);
while (!cl->done) {
- grpc_pollset_worker *worker = NULL;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ grpc_pollset_worker* worker = NULL;
+ ExecCtx _local_exec_ctx;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(g_pollset, &worker, GRPC_MILLIS_INF_FUTURE)));
@@ -380,7 +380,7 @@ static void test_grpc_fd(void) {
server sv;
client cl;
int port;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
server_init(&sv);
port = server_start(&sv);
@@ -397,13 +397,13 @@ typedef struct fd_change_data {
grpc_iomgr_cb_func cb_that_ran;
} fd_change_data;
-void init_change_data(fd_change_data *fdc) { fdc->cb_that_ran = NULL; }
+void init_change_data(fd_change_data* fdc) { fdc->cb_that_ran = NULL; }
-void destroy_change_data(fd_change_data *fdc) {}
+void destroy_change_data(fd_change_data* fdc) {}
-static void first_read_callback(void *arg /* fd_change_data */,
- grpc_error *error) {
- fd_change_data *fdc = arg;
+static void first_read_callback(void* arg /* fd_change_data */,
+ grpc_error* error) {
+ fd_change_data* fdc = static_cast<fd_change_data*>(arg);
gpr_mu_lock(g_mu);
fdc->cb_that_ran = first_read_callback;
@@ -412,9 +412,9 @@ static void first_read_callback(void *arg /* fd_change_data */,
gpr_mu_unlock(g_mu);
}
-static void second_read_callback(void *arg /* fd_change_data */,
- grpc_error *error) {
- fd_change_data *fdc = arg;
+static void second_read_callback(void* arg /* fd_change_data */,
+ grpc_error* error) {
+ fd_change_data* fdc = static_cast<fd_change_data*>(arg);
gpr_mu_lock(g_mu);
fdc->cb_that_ran = second_read_callback;
@@ -428,7 +428,7 @@ static void second_read_callback(void *arg /* fd_change_data */,
point is to have two different function pointers and two different data
pointers and make sure that changing both really works. */
static void test_grpc_fd_change(void) {
- grpc_fd *em_fd;
+ grpc_fd* em_fd;
fd_change_data a, b;
int flags;
int sv[2];
@@ -436,7 +436,7 @@ static void test_grpc_fd_change(void) {
ssize_t result;
grpc_closure first_closure;
grpc_closure second_closure;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
GRPC_CLOSURE_INIT(&first_closure, first_read_callback, &a,
grpc_schedule_on_exec_ctx);
@@ -464,7 +464,7 @@ static void test_grpc_fd_change(void) {
/* And now wait for it to run. */
gpr_mu_lock(g_mu);
while (a.cb_that_ran == NULL) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(g_pollset, &worker, GRPC_MILLIS_INF_FUTURE)));
@@ -488,7 +488,7 @@ static void test_grpc_fd_change(void) {
gpr_mu_lock(g_mu);
while (b.cb_that_ran == NULL) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(g_pollset, &worker, GRPC_MILLIS_INF_FUTURE)));
@@ -507,16 +507,16 @@ static void test_grpc_fd_change(void) {
close(sv[1]);
}
-static void destroy_pollset(void *p, grpc_error *error) {
- grpc_pollset_destroy(p);
+static void destroy_pollset(void* p, grpc_error* error) {
+ grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_test_init(argc, argv);
grpc_init();
- g_pollset = gpr_zalloc(grpc_pollset_size());
+ g_pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
grpc_pollset_init(g_pollset, &g_mu);
test_grpc_fd();
test_grpc_fd_change();
@@ -532,6 +532,6 @@ int main(int argc, char **argv) {
#else /* GRPC_POSIX_SOCKET */
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
#endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/iomgr/load_file_test.c b/test/core/iomgr/load_file_test.cc
index 537c3430b1..2c9e7c33f4 100644
--- a/test/core/iomgr/load_file_test.c
+++ b/test/core/iomgr/load_file_test.cc
@@ -33,11 +33,11 @@
static const char prefix[] = "file_test";
static void test_load_empty_file(void) {
- FILE *tmp = NULL;
+ FILE* tmp = NULL;
grpc_slice slice;
grpc_slice slice_with_null_term;
- grpc_error *error;
- char *tmp_name;
+ grpc_error* error;
+ char* tmp_name;
LOG_TEST_NAME("test_load_empty_file");
@@ -62,10 +62,10 @@ static void test_load_empty_file(void) {
}
static void test_load_failure(void) {
- FILE *tmp = NULL;
+ FILE* tmp = NULL;
grpc_slice slice;
- grpc_error *error;
- char *tmp_name;
+ grpc_error* error;
+ char* tmp_name;
LOG_TEST_NAME("test_load_failure");
@@ -84,12 +84,12 @@ static void test_load_failure(void) {
}
static void test_load_small_file(void) {
- FILE *tmp = NULL;
+ FILE* tmp = NULL;
grpc_slice slice;
grpc_slice slice_with_null_term;
- grpc_error *error;
- char *tmp_name;
- const char *blah = "blah";
+ grpc_error* error;
+ char* tmp_name;
+ const char* blah = "blah";
LOG_TEST_NAME("test_load_small_file");
@@ -107,7 +107,7 @@ static void test_load_small_file(void) {
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),
+ GPR_ASSERT(strcmp((const char*)GRPC_SLICE_START_PTR(slice_with_null_term),
blah) == 0);
remove(tmp_name);
@@ -117,13 +117,13 @@ static void test_load_small_file(void) {
}
static void test_load_big_file(void) {
- FILE *tmp = NULL;
+ FILE* tmp = NULL;
grpc_slice slice;
- grpc_error *error;
- char *tmp_name;
+ grpc_error* error;
+ char* tmp_name;
static const size_t buffer_size = 124631;
- unsigned char *buffer = gpr_malloc(buffer_size);
- unsigned char *current;
+ unsigned char* buffer = static_cast<unsigned char*>(gpr_malloc(buffer_size));
+ unsigned char* current;
size_t i;
LOG_TEST_NAME("test_load_big_file");
@@ -150,7 +150,7 @@ static void test_load_big_file(void) {
gpr_free(buffer);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
test_load_empty_file();
test_load_failure();
diff --git a/test/core/iomgr/pollset_set_test.c b/test/core/iomgr/pollset_set_test.cc
index 7ab31e0006..ba794ca192 100644
--- a/test/core/iomgr/pollset_set_test.c
+++ b/test/core/iomgr/pollset_set_test.cc
@@ -24,6 +24,7 @@
#include <string.h>
#include <unistd.h>
+#include <grpc/grpc.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <grpc/support/useful.h>
@@ -36,15 +37,17 @@
* test_pollset_set
*/
-typedef struct test_pollset_set { grpc_pollset_set *pss; } test_pollset_set;
+typedef struct test_pollset_set {
+ grpc_pollset_set* pss;
+} test_pollset_set;
-void init_test_pollset_sets(test_pollset_set *pollset_sets, const int num_pss) {
+void init_test_pollset_sets(test_pollset_set* pollset_sets, const int num_pss) {
for (int i = 0; i < num_pss; i++) {
pollset_sets[i].pss = grpc_pollset_set_create();
}
}
-void cleanup_test_pollset_sets(test_pollset_set *pollset_sets,
+void cleanup_test_pollset_sets(test_pollset_set* pollset_sets,
const int num_pss) {
for (int i = 0; i < num_pss; i++) {
grpc_pollset_set_destroy(pollset_sets[i].pss);
@@ -57,22 +60,23 @@ void cleanup_test_pollset_sets(test_pollset_set *pollset_sets,
*/
typedef struct test_pollset {
- grpc_pollset *ps;
- gpr_mu *mu;
+ grpc_pollset* ps;
+ gpr_mu* mu;
} test_pollset;
-static void init_test_pollsets(test_pollset *pollsets, const int num_pollsets) {
+static void init_test_pollsets(test_pollset* pollsets, const int num_pollsets) {
for (int i = 0; i < num_pollsets; i++) {
- pollsets[i].ps = gpr_zalloc(grpc_pollset_size());
+ pollsets[i].ps =
+ static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
grpc_pollset_init(pollsets[i].ps, &pollsets[i].mu);
}
}
-static void destroy_pollset(void *p, grpc_error *error) {
- grpc_pollset_destroy(p);
+static void destroy_pollset(void* p, grpc_error* error) {
+ grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
}
-static void cleanup_test_pollsets(test_pollset *pollsets,
+static void cleanup_test_pollsets(test_pollset* pollsets,
const int num_pollsets) {
grpc_closure destroyed;
for (int i = 0; i < num_pollsets; i++) {
@@ -91,18 +95,18 @@ static void cleanup_test_pollsets(test_pollset *pollsets,
*/
typedef struct test_fd {
- grpc_fd *fd;
+ grpc_fd* fd;
grpc_wakeup_fd wakeup_fd;
bool is_on_readable_called; /* Is on_readable closure is called ? */
grpc_closure on_readable; /* Closure to call when this fd is readable */
} test_fd;
-void on_readable(void *tfd, grpc_error *error) {
- ((test_fd *)tfd)->is_on_readable_called = true;
+void on_readable(void* tfd, grpc_error* error) {
+ ((test_fd*)tfd)->is_on_readable_called = true;
}
-static void reset_test_fd(test_fd *tfd) {
+static void reset_test_fd(test_fd* tfd) {
tfd->is_on_readable_called = false;
GRPC_CLOSURE_INIT(&tfd->on_readable, on_readable, tfd,
@@ -110,7 +114,7 @@ static void reset_test_fd(test_fd *tfd) {
grpc_fd_notify_on_read(tfd->fd, &tfd->on_readable);
}
-static void init_test_fds(test_fd *tfds, const int num_fds) {
+static void init_test_fds(test_fd* tfds, const int num_fds) {
for (int i = 0; i < num_fds; i++) {
GPR_ASSERT(GRPC_ERROR_NONE == grpc_wakeup_fd_init(&tfds[i].wakeup_fd));
tfds[i].fd = grpc_fd_create(GRPC_WAKEUP_FD_GET_READ_FD(&tfds[i].wakeup_fd),
@@ -119,7 +123,7 @@ static void init_test_fds(test_fd *tfds, const int num_fds) {
}
}
-static void cleanup_test_fds(test_fd *tfds, const int num_fds) {
+static void cleanup_test_fds(test_fd* tfds, const int num_fds) {
int release_fd;
for (int i = 0; i < num_fds; i++) {
@@ -140,13 +144,13 @@ static void cleanup_test_fds(test_fd *tfds, const int num_fds) {
}
}
-static void make_test_fds_readable(test_fd *tfds, const int num_fds) {
+static void make_test_fds_readable(test_fd* tfds, const int num_fds) {
for (int i = 0; i < num_fds; i++) {
GPR_ASSERT(GRPC_ERROR_NONE == grpc_wakeup_fd_wakeup(&tfds[i].wakeup_fd));
}
}
-static void verify_readable_and_reset(test_fd *tfds, const int num_fds) {
+static void verify_readable_and_reset(test_fd* tfds, const int num_fds) {
for (int i = 0; i < num_fds; i++) {
/* Verify that the on_readable callback was called */
GPR_ASSERT(tfds[i].is_on_readable_called);
@@ -195,8 +199,8 @@ static void pollset_set_test_basic() {
* |
* +---> FD9 (Added after PS2 is added to PSS0)
*/
- exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_pollset_worker *worker;
+ ExecCtx _local_exec_ctx;
+ grpc_pollset_worker* worker;
grpc_millis deadline;
test_fd tfds[10];
@@ -298,8 +302,8 @@ void pollset_set_test_dup_fds() {
* | +--> FD2
* +---> FD1
*/
- exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_pollset_worker *worker;
+ ExecCtx _local_exec_ctx;
+ grpc_pollset_worker* worker;
grpc_millis deadline;
test_fd tfds[3];
@@ -369,8 +373,8 @@ void pollset_set_test_empty_pollset() {
* |
* +---> FD2
*/
- exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_pollset_worker *worker;
+ ExecCtx _local_exec_ctx;
+ grpc_pollset_worker* worker;
grpc_millis deadline;
test_fd tfds[3];
@@ -419,15 +423,14 @@ void pollset_set_test_empty_pollset() {
grpc_exec_ctx_finish();
}
-int main(int argc, char **argv) {
- const char *poll_strategy = grpc_get_poll_strategy_name();
- exec_ctx = GRPC_EXEC_CTX_INIT;
+int main(int argc, char** argv) {
+ ExecCtx _local_exec_ctx;
grpc_test_init(argc, argv);
- grpc_iomgr_init();
- grpc_iomgr_start();
+ grpc_init();
+ const char* poll_strategy = grpc_get_poll_strategy_name();
if (poll_strategy != NULL &&
- (strcmp(poll_strategy, "epoll") == 0 ||
+ (strcmp(poll_strategy, "epollsig") == 0 ||
strcmp(poll_strategy, "epoll-threadpool") == 0)) {
pollset_set_test_basic();
pollset_set_test_dup_fds();
@@ -439,10 +442,10 @@ int main(int argc, char **argv) {
poll_strategy);
}
- grpc_iomgr_shutdown();
grpc_exec_ctx_finish();
+ grpc_shutdown();
return 0;
}
-#else /* defined(GRPC_LINUX_EPOLL) */
-int main(int argc, char **argv) { return 0; }
+#else /* defined(GRPC_LINUX_EPOLL) */
+int main(int argc, char** argv) { return 0; }
#endif /* !defined(GRPC_LINUX_EPOLL) */
diff --git a/test/core/iomgr/resolve_address_posix_test.cc b/test/core/iomgr/resolve_address_posix_test.cc
index 05c17fbf60..d06777d86f 100644
--- a/test/core/iomgr/resolve_address_posix_test.cc
+++ b/test/core/iomgr/resolve_address_posix_test.cc
@@ -39,25 +39,25 @@ static gpr_timespec test_deadline(void) {
typedef struct args_struct {
gpr_event ev;
- grpc_resolved_addresses *addrs;
+ grpc_resolved_addresses* addrs;
gpr_atm done_atm;
- gpr_mu *mu;
- grpc_pollset *pollset;
- grpc_pollset_set *pollset_set;
+ gpr_mu* mu;
+ grpc_pollset* pollset;
+ grpc_pollset_set* pollset_set;
} args_struct;
-static void do_nothing(void *arg, grpc_error *error) {}
+static void do_nothing(void* arg, grpc_error* error) {}
-void args_init(args_struct *args) {
+void args_init(args_struct* args) {
gpr_event_init(&args->ev);
- args->pollset = gpr_zalloc(grpc_pollset_size());
+ args->pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
grpc_pollset_init(args->pollset, &args->mu);
args->pollset_set = grpc_pollset_set_create();
grpc_pollset_set_add_pollset(args->pollset_set, args->pollset);
args->addrs = NULL;
}
-void args_finish(args_struct *args) {
+void args_finish(args_struct* args) {
GPR_ASSERT(gpr_event_wait(&args->ev, test_deadline()));
grpc_resolved_addresses_destroy(args->addrs);
grpc_pollset_set_del_pollset(args->pollset_set, args->pollset);
@@ -77,8 +77,8 @@ static grpc_millis n_sec_deadline(int seconds) {
grpc_timeout_seconds_to_deadline(seconds));
}
-static void actually_poll(void *argsp) {
- args_struct *args = argsp;
+static void actually_poll(void* argsp) {
+ args_struct* args = static_cast<args_struct*>(argsp);
ExecCtx _local_exec_ctx;
grpc_millis deadline = n_sec_deadline(10);
while (true) {
@@ -89,33 +89,33 @@ static void actually_poll(void *argsp) {
grpc_millis time_left = deadline - grpc_exec_ctx_now();
gpr_log(GPR_DEBUG, "done=%d, time_left=%" PRIdPTR, done, time_left);
GPR_ASSERT(time_left >= 0);
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
gpr_mu_lock(args->mu);
GRPC_LOG_IF_ERROR("pollset_work", grpc_pollset_work(args->pollset, &worker,
n_sec_deadline(1)));
gpr_mu_unlock(args->mu);
grpc_exec_ctx_flush();
}
- gpr_event_set(&args->ev, (void *)1);
+ gpr_event_set(&args->ev, (void*)1);
grpc_exec_ctx_finish();
}
-static void poll_pollset_until_request_done(args_struct *args) {
+static void poll_pollset_until_request_done(args_struct* args) {
gpr_atm_rel_store(&args->done_atm, 0);
gpr_thd_id id;
gpr_thd_new(&id, actually_poll, args, NULL);
}
-static void must_succeed(void *argsp, grpc_error *err) {
- args_struct *args = argsp;
+static void must_succeed(void* argsp, grpc_error* err) {
+ args_struct* args = static_cast<args_struct*>(argsp);
GPR_ASSERT(err == GRPC_ERROR_NONE);
GPR_ASSERT(args->addrs != NULL);
GPR_ASSERT(args->addrs->naddrs > 0);
gpr_atm_rel_store(&args->done_atm, 1);
}
-static void must_fail(void *argsp, grpc_error *err) {
- args_struct *args = argsp;
+static void must_fail(void* argsp, grpc_error* err) {
+ args_struct* args = static_cast<args_struct*>(argsp);
GPR_ASSERT(err != GRPC_ERROR_NONE);
gpr_atm_rel_store(&args->done_atm, 1);
}
@@ -139,8 +139,9 @@ static void test_unix_socket_path_name_too_long(void) {
args_init(&args);
const char prefix[] = "unix:/path/name";
size_t path_name_length =
- GPR_ARRAY_SIZE(((struct sockaddr_un *)0)->sun_path) + 6;
- char *path_name = gpr_malloc(sizeof(char) * path_name_length);
+ GPR_ARRAY_SIZE(((struct sockaddr_un*)0)->sun_path) + 6;
+ char* path_name =
+ static_cast<char*>(gpr_malloc(sizeof(char) * path_name_length));
memset(path_name, 'a', path_name_length);
memcpy(path_name, prefix, strlen(prefix) - 1);
path_name[path_name_length - 1] = '\0';
@@ -155,7 +156,7 @@ static void test_unix_socket_path_name_too_long(void) {
grpc_exec_ctx_finish();
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
grpc_init();
ExecCtx _local_exec_ctx;
diff --git a/test/core/iomgr/resolve_address_test.c b/test/core/iomgr/resolve_address_test.cc
index 7a59ee3dcc..1eb753dc85 100644
--- a/test/core/iomgr/resolve_address_test.c
+++ b/test/core/iomgr/resolve_address_test.cc
@@ -32,18 +32,18 @@ static gpr_timespec test_deadline(void) {
typedef struct args_struct {
gpr_event ev;
- grpc_resolved_addresses *addrs;
+ grpc_resolved_addresses* addrs;
gpr_atm done_atm;
- gpr_mu *mu;
- grpc_pollset *pollset;
- grpc_pollset_set *pollset_set;
+ gpr_mu* mu;
+ grpc_pollset* pollset;
+ grpc_pollset_set* pollset_set;
} args_struct;
-static void do_nothing(void *arg, grpc_error *error) {}
+static void do_nothing(void* arg, grpc_error* error) {}
-void args_init(args_struct *args) {
+void args_init(args_struct* args) {
gpr_event_init(&args->ev);
- args->pollset = gpr_zalloc(grpc_pollset_size());
+ args->pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
grpc_pollset_init(args->pollset, &args->mu);
args->pollset_set = grpc_pollset_set_create();
grpc_pollset_set_add_pollset(args->pollset_set, args->pollset);
@@ -51,7 +51,7 @@ void args_init(args_struct *args) {
gpr_atm_rel_store(&args->done_atm, 0);
}
-void args_finish(args_struct *args) {
+void args_finish(args_struct* args) {
GPR_ASSERT(gpr_event_wait(&args->ev, test_deadline()));
grpc_resolved_addresses_destroy(args->addrs);
grpc_pollset_set_del_pollset(args->pollset_set, args->pollset);
@@ -73,8 +73,8 @@ static grpc_millis n_sec_deadline(int seconds) {
grpc_timeout_seconds_to_deadline(seconds));
}
-static void poll_pollset_until_request_done(args_struct *args) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+static void poll_pollset_until_request_done(args_struct* args) {
+ ExecCtx _local_exec_ctx;
grpc_millis deadline = n_sec_deadline(10);
while (true) {
bool done = gpr_atm_acq_load(&args->done_atm) != 0;
@@ -84,19 +84,19 @@ static void poll_pollset_until_request_done(args_struct *args) {
grpc_millis time_left = deadline - grpc_exec_ctx_now();
gpr_log(GPR_DEBUG, "done=%d, time_left=%" PRIdPTR, done, time_left);
GPR_ASSERT(time_left >= 0);
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
gpr_mu_lock(args->mu);
GRPC_LOG_IF_ERROR("pollset_work", grpc_pollset_work(args->pollset, &worker,
n_sec_deadline(1)));
gpr_mu_unlock(args->mu);
grpc_exec_ctx_flush();
}
- gpr_event_set(&args->ev, (void *)1);
+ gpr_event_set(&args->ev, (void*)1);
grpc_exec_ctx_finish();
}
-static void must_succeed(void *argsp, grpc_error *err) {
- args_struct *args = argsp;
+static void must_succeed(void* argsp, grpc_error* err) {
+ args_struct* args = static_cast<args_struct*>(argsp);
GPR_ASSERT(err == GRPC_ERROR_NONE);
GPR_ASSERT(args->addrs != NULL);
GPR_ASSERT(args->addrs->naddrs > 0);
@@ -106,8 +106,8 @@ static void must_succeed(void *argsp, grpc_error *err) {
gpr_mu_unlock(args->mu);
}
-static void must_fail(void *argsp, grpc_error *err) {
- args_struct *args = argsp;
+static void must_fail(void* argsp, grpc_error* err) {
+ args_struct* args = static_cast<args_struct*>(argsp);
GPR_ASSERT(err != GRPC_ERROR_NONE);
gpr_atm_rel_store(&args->done_atm, 1);
gpr_mu_lock(args->mu);
@@ -116,7 +116,7 @@ static void must_fail(void *argsp, grpc_error *err) {
}
static void test_localhost(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
args_struct args;
args_init(&args);
grpc_resolve_address(
@@ -130,7 +130,7 @@ static void test_localhost(void) {
}
static void test_default_port(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
args_struct args;
args_init(&args);
grpc_resolve_address(
@@ -144,7 +144,7 @@ static void test_default_port(void) {
}
static void test_non_numeric_default_port(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
args_struct args;
args_init(&args);
grpc_resolve_address(
@@ -158,7 +158,7 @@ static void test_non_numeric_default_port(void) {
}
static void test_missing_default_port(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
args_struct args;
args_init(&args);
grpc_resolve_address(
@@ -172,7 +172,7 @@ static void test_missing_default_port(void) {
}
static void test_ipv6_with_port(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
args_struct args;
args_init(&args);
grpc_resolve_address(
@@ -186,12 +186,14 @@ static void test_ipv6_with_port(void) {
}
static void test_ipv6_without_port(void) {
- const char *const kCases[] = {
- "2001:db8::1", "2001:db8::1.2.3.4", "[2001:db8::1]",
+ const char* const kCases[] = {
+ "2001:db8::1",
+ "2001:db8::1.2.3.4",
+ "[2001:db8::1]",
};
unsigned i;
for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
args_struct args;
args_init(&args);
grpc_resolve_address(
@@ -206,12 +208,13 @@ static void test_ipv6_without_port(void) {
}
static void test_invalid_ip_addresses(void) {
- const char *const kCases[] = {
- "293.283.1238.3:1", "[2001:db8::11111]:1",
+ const char* const kCases[] = {
+ "293.283.1238.3:1",
+ "[2001:db8::11111]:1",
};
unsigned i;
for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
args_struct args;
args_init(&args);
grpc_resolve_address(
@@ -226,12 +229,12 @@ static void test_invalid_ip_addresses(void) {
}
static void test_unparseable_hostports(void) {
- const char *const kCases[] = {
+ const char* const kCases[] = {
"[", "[::1", "[::1]bad", "[1.2.3.4]", "[localhost]", "[localhost]:1",
};
unsigned i;
for (i = 0; i < sizeof(kCases) / sizeof(*kCases); i++) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
args_struct args;
args_init(&args);
grpc_resolve_address(
@@ -245,10 +248,10 @@ static void test_unparseable_hostports(void) {
}
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
grpc_init();
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
test_localhost();
test_default_port();
test_non_numeric_default_port();
diff --git a/test/core/iomgr/resource_quota_test.c b/test/core/iomgr/resource_quota_test.cc
index 648e5f27d2..bee9373ff6 100644
--- a/test/core/iomgr/resource_quota_test.c
+++ b/test/core/iomgr/resource_quota_test.cc
@@ -27,14 +27,14 @@
gpr_mu g_mu;
gpr_cv g_cv;
-static void inc_int_cb(void *a, grpc_error *error) {
+static void inc_int_cb(void* a, grpc_error* error) {
gpr_mu_lock(&g_mu);
- ++*(int *)a;
+ ++*(int*)a;
gpr_cv_signal(&g_cv);
gpr_mu_unlock(&g_mu);
}
-static void assert_counter_becomes(int *ctr, int value) {
+static void assert_counter_becomes(int* ctr, int value) {
gpr_mu_lock(&g_mu);
gpr_timespec deadline = grpc_timeout_seconds_to_deadline(5);
while (*ctr != value) {
@@ -43,46 +43,48 @@ static void assert_counter_becomes(int *ctr, int value) {
gpr_mu_unlock(&g_mu);
}
-static void set_event_cb(void *a, grpc_error *error) {
- gpr_event_set((gpr_event *)a, (void *)1);
+static void set_event_cb(void* a, grpc_error* error) {
+ gpr_event_set((gpr_event*)a, (void*)1);
}
-grpc_closure *set_event(gpr_event *ev) {
+grpc_closure* set_event(gpr_event* ev) {
return GRPC_CLOSURE_CREATE(set_event_cb, ev, grpc_schedule_on_exec_ctx);
}
typedef struct {
size_t size;
- grpc_resource_user *resource_user;
- grpc_closure *then;
+ grpc_resource_user* resource_user;
+ grpc_closure* then;
} reclaimer_args;
-static void reclaimer_cb(void *args, grpc_error *error) {
+
+static void reclaimer_cb(void* args, grpc_error* error) {
GPR_ASSERT(error == GRPC_ERROR_NONE);
- reclaimer_args *a = args;
+ reclaimer_args* a = static_cast<reclaimer_args*>(args);
grpc_resource_user_free(a->resource_user, a->size);
grpc_resource_user_finish_reclamation(a->resource_user);
GRPC_CLOSURE_RUN(a->then, GRPC_ERROR_NONE);
gpr_free(a);
}
-grpc_closure *make_reclaimer(grpc_resource_user *resource_user, size_t size,
- grpc_closure *then) {
- reclaimer_args *a = gpr_malloc(sizeof(*a));
+
+grpc_closure* make_reclaimer(grpc_resource_user* resource_user, size_t size,
+ grpc_closure* then) {
+ reclaimer_args* a = static_cast<reclaimer_args*>(gpr_malloc(sizeof(*a)));
a->size = size;
a->resource_user = resource_user;
a->then = then;
return GRPC_CLOSURE_CREATE(reclaimer_cb, a, grpc_schedule_on_exec_ctx);
}
-static void unused_reclaimer_cb(void *arg, grpc_error *error) {
+static void unused_reclaimer_cb(void* arg, grpc_error* error) {
GPR_ASSERT(error == GRPC_ERROR_CANCELLED);
- GRPC_CLOSURE_RUN(arg, GRPC_ERROR_NONE);
+ GRPC_CLOSURE_RUN(static_cast<grpc_closure*>(arg), GRPC_ERROR_NONE);
}
-grpc_closure *make_unused_reclaimer(grpc_closure *then) {
+grpc_closure* make_unused_reclaimer(grpc_closure* then) {
return GRPC_CLOSURE_CREATE(unused_reclaimer_cb, then,
grpc_schedule_on_exec_ctx);
}
-static void destroy_user(grpc_resource_user *usr) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+static void destroy_user(grpc_resource_user* usr) {
+ ExecCtx _local_exec_ctx;
grpc_resource_user_unref(usr);
grpc_exec_ctx_finish();
}
@@ -94,7 +96,7 @@ static void test_no_op(void) {
static void test_resize_then_destroy(void) {
gpr_log(GPR_INFO, "** test_resize_then_destroy **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_resize_then_destroy");
grpc_resource_quota_resize(q, 1024 * 1024);
grpc_resource_quota_unref(q);
@@ -102,26 +104,26 @@ static void test_resize_then_destroy(void) {
static void test_resource_user_no_op(void) {
gpr_log(GPR_INFO, "** test_resource_user_no_op **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_resource_user_no_op");
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
grpc_resource_quota_unref(q);
destroy_user(usr);
}
static void test_instant_alloc_then_free(void) {
gpr_log(GPR_INFO, "** test_instant_alloc_then_free **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_instant_alloc_then_free");
grpc_resource_quota_resize(q, 1024 * 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, NULL);
grpc_exec_ctx_finish();
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr, 1024);
grpc_exec_ctx_finish();
}
@@ -131,12 +133,12 @@ static void test_instant_alloc_then_free(void) {
static void test_instant_alloc_free_pair(void) {
gpr_log(GPR_INFO, "** test_instant_alloc_free_pair **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_instant_alloc_free_pair");
grpc_resource_quota_resize(q, 1024 * 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, NULL);
grpc_resource_user_free(usr, 1024);
grpc_exec_ctx_finish();
@@ -147,21 +149,21 @@ static void test_instant_alloc_free_pair(void) {
static void test_simple_async_alloc(void) {
gpr_log(GPR_INFO, "** test_simple_async_alloc **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_simple_async_alloc");
grpc_resource_quota_resize(q, 1024 * 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
NULL);
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr, 1024);
grpc_exec_ctx_finish();
}
@@ -171,14 +173,14 @@ static void test_simple_async_alloc(void) {
static void test_async_alloc_blocked_by_size(void) {
gpr_log(GPR_INFO, "** test_async_alloc_blocked_by_size **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_async_alloc_blocked_by_size");
grpc_resource_quota_resize(q, 1);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
gpr_event ev;
gpr_event_init(&ev);
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(
@@ -188,7 +190,7 @@ static void test_async_alloc_blocked_by_size(void) {
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) != NULL);
;
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr, 1024);
grpc_exec_ctx_finish();
}
@@ -198,14 +200,14 @@ static void test_async_alloc_blocked_by_size(void) {
static void test_scavenge(void) {
gpr_log(GPR_INFO, "** test_scavenge **");
- grpc_resource_quota *q = grpc_resource_quota_create("test_scavenge");
+ grpc_resource_quota* q = grpc_resource_quota_create("test_scavenge");
grpc_resource_quota_resize(q, 1024);
- grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
- grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
+ grpc_resource_user* usr1 = grpc_resource_user_create(q, "usr1");
+ grpc_resource_user* usr2 = grpc_resource_user_create(q, "usr2");
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr1, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
@@ -213,14 +215,14 @@ static void test_scavenge(void) {
;
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr1, 1024);
grpc_exec_ctx_finish();
}
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr2, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
@@ -228,7 +230,7 @@ static void test_scavenge(void) {
;
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr2, 1024);
grpc_exec_ctx_finish();
}
@@ -239,14 +241,14 @@ static void test_scavenge(void) {
static void test_scavenge_blocked(void) {
gpr_log(GPR_INFO, "** test_scavenge_blocked **");
- grpc_resource_quota *q = grpc_resource_quota_create("test_scavenge_blocked");
+ grpc_resource_quota* q = grpc_resource_quota_create("test_scavenge_blocked");
grpc_resource_quota_resize(q, 1024);
- grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
- grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
+ grpc_resource_user* usr1 = grpc_resource_user_create(q, "usr1");
+ grpc_resource_user* usr2 = grpc_resource_user_create(q, "usr2");
gpr_event ev;
{
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr1, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
@@ -255,14 +257,14 @@ static void test_scavenge_blocked(void) {
}
{
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr2, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(
&ev, grpc_timeout_milliseconds_to_deadline(100)) == NULL);
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr1, 1024);
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
@@ -270,7 +272,7 @@ static void test_scavenge_blocked(void) {
;
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr2, 1024);
grpc_exec_ctx_finish();
}
@@ -281,14 +283,14 @@ static void test_scavenge_blocked(void) {
static void test_blocked_until_scheduled_reclaim(void) {
gpr_log(GPR_INFO, "** test_blocked_until_scheduled_reclaim **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_blocked_until_scheduled_reclaim");
grpc_resource_quota_resize(q, 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
@@ -298,7 +300,7 @@ static void test_blocked_until_scheduled_reclaim(void) {
gpr_event reclaim_done;
gpr_event_init(&reclaim_done);
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_post_reclaimer(
usr, false, make_reclaimer(usr, 1024, set_event(&reclaim_done)));
grpc_exec_ctx_finish();
@@ -306,7 +308,7 @@ static void test_blocked_until_scheduled_reclaim(void) {
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&reclaim_done,
@@ -316,7 +318,7 @@ static void test_blocked_until_scheduled_reclaim(void) {
;
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr, 1024);
grpc_exec_ctx_finish();
}
@@ -326,15 +328,15 @@ static void test_blocked_until_scheduled_reclaim(void) {
static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
gpr_log(GPR_INFO, "** test_blocked_until_scheduled_reclaim_and_scavenge **");
- grpc_resource_quota *q = grpc_resource_quota_create(
+ grpc_resource_quota* q = grpc_resource_quota_create(
"test_blocked_until_scheduled_reclaim_and_scavenge");
grpc_resource_quota_resize(q, 1024);
- grpc_resource_user *usr1 = grpc_resource_user_create(q, "usr1");
- grpc_resource_user *usr2 = grpc_resource_user_create(q, "usr2");
+ grpc_resource_user* usr1 = grpc_resource_user_create(q, "usr1");
+ grpc_resource_user* usr2 = grpc_resource_user_create(q, "usr2");
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr1, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
@@ -344,7 +346,7 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
gpr_event reclaim_done;
gpr_event_init(&reclaim_done);
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_post_reclaimer(
usr1, false, make_reclaimer(usr1, 1024, set_event(&reclaim_done)));
grpc_exec_ctx_finish();
@@ -352,7 +354,7 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr2, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&reclaim_done,
@@ -362,7 +364,7 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
;
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr2, 1024);
grpc_exec_ctx_finish();
}
@@ -373,14 +375,14 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
static void test_blocked_until_scheduled_destructive_reclaim(void) {
gpr_log(GPR_INFO, "** test_blocked_until_scheduled_destructive_reclaim **");
- grpc_resource_quota *q = grpc_resource_quota_create(
+ grpc_resource_quota* q = grpc_resource_quota_create(
"test_blocked_until_scheduled_destructive_reclaim");
grpc_resource_quota_resize(q, 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
@@ -390,7 +392,7 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
gpr_event reclaim_done;
gpr_event_init(&reclaim_done);
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_post_reclaimer(
usr, true, make_reclaimer(usr, 1024, set_event(&reclaim_done)));
grpc_exec_ctx_finish();
@@ -398,7 +400,7 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&reclaim_done,
@@ -408,7 +410,7 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
;
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr, 1024);
grpc_exec_ctx_finish();
}
@@ -418,16 +420,16 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
static void test_unused_reclaim_is_cancelled(void) {
gpr_log(GPR_INFO, "** test_unused_reclaim_is_cancelled **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_unused_reclaim_is_cancelled");
grpc_resource_quota_resize(q, 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
gpr_event benign_done;
gpr_event_init(&benign_done);
gpr_event destructive_done;
gpr_event_init(&destructive_done);
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_post_reclaimer(
usr, false, make_unused_reclaimer(set_event(&benign_done)));
grpc_resource_user_post_reclaimer(
@@ -450,10 +452,10 @@ static void test_unused_reclaim_is_cancelled(void) {
static void test_benign_reclaim_is_preferred(void) {
gpr_log(GPR_INFO, "** test_benign_reclaim_is_preferred **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_benign_reclaim_is_preferred");
grpc_resource_quota_resize(q, 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
gpr_event benign_done;
gpr_event_init(&benign_done);
gpr_event destructive_done;
@@ -461,7 +463,7 @@ static void test_benign_reclaim_is_preferred(void) {
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
@@ -469,7 +471,7 @@ static void test_benign_reclaim_is_preferred(void) {
;
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_post_reclaimer(
usr, false, make_reclaimer(usr, 1024, set_event(&benign_done)));
grpc_resource_user_post_reclaimer(
@@ -485,7 +487,7 @@ static void test_benign_reclaim_is_preferred(void) {
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&benign_done,
@@ -497,7 +499,7 @@ static void test_benign_reclaim_is_preferred(void) {
NULL);
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr, 1024);
grpc_exec_ctx_finish();
}
@@ -511,10 +513,10 @@ static void test_benign_reclaim_is_preferred(void) {
static void test_multiple_reclaims_can_be_triggered(void) {
gpr_log(GPR_INFO, "** test_multiple_reclaims_can_be_triggered **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_multiple_reclaims_can_be_triggered");
grpc_resource_quota_resize(q, 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
gpr_event benign_done;
gpr_event_init(&benign_done);
gpr_event destructive_done;
@@ -522,7 +524,7 @@ static void test_multiple_reclaims_can_be_triggered(void) {
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
@@ -530,7 +532,7 @@ static void test_multiple_reclaims_can_be_triggered(void) {
;
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_post_reclaimer(
usr, false, make_reclaimer(usr, 512, set_event(&benign_done)));
grpc_resource_user_post_reclaimer(
@@ -546,7 +548,7 @@ static void test_multiple_reclaims_can_be_triggered(void) {
{
gpr_event ev;
gpr_event_init(&ev);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&ev));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&benign_done,
@@ -558,7 +560,7 @@ static void test_multiple_reclaims_can_be_triggered(void) {
;
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr, 1024);
grpc_exec_ctx_finish();
}
@@ -573,23 +575,23 @@ static void test_multiple_reclaims_can_be_triggered(void) {
static void test_resource_user_stays_allocated_until_memory_released(void) {
gpr_log(GPR_INFO,
"** test_resource_user_stays_allocated_until_memory_released **");
- grpc_resource_quota *q = grpc_resource_quota_create(
+ grpc_resource_quota* q = grpc_resource_quota_create(
"test_resource_user_stays_allocated_until_memory_released");
grpc_resource_quota_resize(q, 1024 * 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, NULL);
grpc_exec_ctx_finish();
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_quota_unref(q);
grpc_resource_user_unref(usr);
grpc_exec_ctx_finish();
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr, 1024);
grpc_exec_ctx_finish();
}
@@ -602,16 +604,16 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
"** "
"test_resource_user_stays_allocated_and_reclaimers_unrun_until_"
"memory_released **");
- grpc_resource_quota *q = grpc_resource_quota_create(
+ grpc_resource_quota* q = grpc_resource_quota_create(
"test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_"
"released");
grpc_resource_quota_resize(q, 1024);
for (int i = 0; i < 10; i++) {
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
gpr_event reclaimer_cancelled;
gpr_event_init(&reclaimer_cancelled);
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_post_reclaimer(
usr, false, make_unused_reclaimer(set_event(&reclaimer_cancelled)));
grpc_exec_ctx_finish();
@@ -622,7 +624,7 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
{
gpr_event allocated;
gpr_event_init(&allocated);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&allocated));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&allocated,
@@ -632,7 +634,7 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
NULL);
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_unref(usr);
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
@@ -640,7 +642,7 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
NULL);
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr, 1024);
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
@@ -652,14 +654,14 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
static void test_reclaimers_can_be_posted_repeatedly(void) {
gpr_log(GPR_INFO, "** test_reclaimers_can_be_posted_repeatedly **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_reclaimers_can_be_posted_repeatedly");
grpc_resource_quota_resize(q, 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
{
gpr_event allocated;
gpr_event_init(&allocated);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&allocated));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&allocated,
@@ -669,7 +671,7 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
gpr_event reclaimer_done;
gpr_event_init(&reclaimer_done);
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_post_reclaimer(
usr, false, make_reclaimer(usr, 1024, set_event(&reclaimer_done)));
grpc_exec_ctx_finish();
@@ -680,7 +682,7 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
{
gpr_event allocated;
gpr_event_init(&allocated);
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc(usr, 1024, set_event(&allocated));
grpc_exec_ctx_finish();
GPR_ASSERT(gpr_event_wait(&allocated,
@@ -690,7 +692,7 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
}
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_free(usr, 1024);
grpc_exec_ctx_finish();
}
@@ -701,10 +703,10 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
static void test_one_slice(void) {
gpr_log(GPR_INFO, "** test_one_slice **");
- grpc_resource_quota *q = grpc_resource_quota_create("test_one_slice");
+ grpc_resource_quota* q = grpc_resource_quota_create("test_one_slice");
grpc_resource_quota_resize(q, 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
grpc_resource_user_slice_allocator alloc;
int num_allocs = 0;
@@ -715,14 +717,14 @@ static void test_one_slice(void) {
{
const int start_allocs = num_allocs;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc_slices(&alloc, 1024, 1, &buffer);
grpc_exec_ctx_finish();
assert_counter_becomes(&num_allocs, start_allocs + 1);
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_slice_buffer_destroy_internal(&buffer);
grpc_exec_ctx_finish();
}
@@ -733,11 +735,11 @@ static void test_one_slice(void) {
static void test_one_slice_deleted_late(void) {
gpr_log(GPR_INFO, "** test_one_slice_deleted_late **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_one_slice_deleted_late");
grpc_resource_quota_resize(q, 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
grpc_resource_user_slice_allocator alloc;
int num_allocs = 0;
@@ -748,21 +750,21 @@ static void test_one_slice_deleted_late(void) {
{
const int start_allocs = num_allocs;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc_slices(&alloc, 1024, 1, &buffer);
grpc_exec_ctx_finish();
assert_counter_becomes(&num_allocs, start_allocs + 1);
}
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_unref(usr);
grpc_exec_ctx_finish();
}
grpc_resource_quota_unref(q);
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_slice_buffer_destroy_internal(&buffer);
grpc_exec_ctx_finish();
}
@@ -770,18 +772,18 @@ static void test_one_slice_deleted_late(void) {
static void test_resize_to_zero(void) {
gpr_log(GPR_INFO, "** test_resize_to_zero **");
- grpc_resource_quota *q = grpc_resource_quota_create("test_resize_to_zero");
+ grpc_resource_quota* q = grpc_resource_quota_create("test_resize_to_zero");
grpc_resource_quota_resize(q, 0);
grpc_resource_quota_unref(q);
}
static void test_negative_rq_free_pool(void) {
gpr_log(GPR_INFO, "** test_negative_rq_free_pool **");
- grpc_resource_quota *q =
+ grpc_resource_quota* q =
grpc_resource_quota_create("test_negative_rq_free_pool");
grpc_resource_quota_resize(q, 1024);
- grpc_resource_user *usr = grpc_resource_user_create(q, "usr");
+ grpc_resource_user* usr = grpc_resource_user_create(q, "usr");
grpc_resource_user_slice_allocator alloc;
int num_allocs = 0;
@@ -792,7 +794,7 @@ static void test_negative_rq_free_pool(void) {
{
const int start_allocs = num_allocs;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_alloc_slices(&alloc, 1024, 1, &buffer);
grpc_exec_ctx_finish();
assert_counter_becomes(&num_allocs, start_allocs + 1);
@@ -805,20 +807,20 @@ static void test_negative_rq_free_pool(void) {
GPR_ASSERT(grpc_resource_quota_get_memory_pressure(q) > 1 - eps);
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resource_user_unref(usr);
grpc_exec_ctx_finish();
}
grpc_resource_quota_unref(q);
{
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_slice_buffer_destroy_internal(&buffer);
grpc_exec_ctx_finish();
}
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
grpc_init();
gpr_mu_init(&g_mu);
diff --git a/test/core/iomgr/sockaddr_utils_test.c b/test/core/iomgr/sockaddr_utils_test.cc
index e4a4ddaa99..40f2157ba3 100644
--- a/test/core/iomgr/sockaddr_utils_test.c
+++ b/test/core/iomgr/sockaddr_utils_test.cc
@@ -20,8 +20,8 @@
using that endpoint. Because of various transitive includes in uv.h,
including windows.h on Windows, uv.h must be included before other system
headers. Therefore, sockaddr.h must always be included first */
-#include "src/core/lib/iomgr/sockaddr.h"
#include "src/core/lib/iomgr/sockaddr_utils.h"
+#include "src/core/lib/iomgr/sockaddr.h"
#include <errno.h>
#include <string.h>
@@ -31,9 +31,9 @@
#include <grpc/support/port_platform.h>
#include "test/core/util/test_config.h"
-static grpc_resolved_address make_addr4(const uint8_t *data, size_t data_len) {
+static grpc_resolved_address make_addr4(const uint8_t* data, size_t data_len) {
grpc_resolved_address resolved_addr4;
- struct sockaddr_in *addr4 = (struct sockaddr_in *)resolved_addr4.addr;
+ struct sockaddr_in* addr4 = (struct sockaddr_in*)resolved_addr4.addr;
memset(&resolved_addr4, 0, sizeof(resolved_addr4));
addr4->sin_family = AF_INET;
GPR_ASSERT(data_len == sizeof(addr4->sin_addr.s_addr));
@@ -43,9 +43,9 @@ static grpc_resolved_address make_addr4(const uint8_t *data, size_t data_len) {
return resolved_addr4;
}
-static grpc_resolved_address make_addr6(const uint8_t *data, size_t data_len) {
+static grpc_resolved_address make_addr6(const uint8_t* data, size_t data_len) {
grpc_resolved_address resolved_addr6;
- struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)resolved_addr6.addr;
+ struct sockaddr_in6* addr6 = (struct sockaddr_in6*)resolved_addr6.addr;
memset(&resolved_addr6, 0, sizeof(resolved_addr6));
addr6->sin6_family = AF_INET6;
GPR_ASSERT(data_len == sizeof(addr6->sin6_addr.s6_addr));
@@ -55,8 +55,8 @@ static grpc_resolved_address make_addr6(const uint8_t *data, size_t data_len) {
return resolved_addr6;
}
-static void set_addr6_scope_id(grpc_resolved_address *addr, uint32_t scope_id) {
- struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr->addr;
+static void set_addr6_scope_id(grpc_resolved_address* addr, uint32_t scope_id) {
+ struct sockaddr_in6* addr6 = (struct sockaddr_in6*)addr->addr;
GPR_ASSERT(addr6->sin6_family == AF_INET6);
addr6->sin6_scope_id = scope_id;
}
@@ -128,9 +128,9 @@ static void test_sockaddr_is_wildcard(void) {
grpc_resolved_address wild6;
grpc_resolved_address wild_mapped;
grpc_resolved_address dummy;
- struct sockaddr_in *wild4_addr;
- struct sockaddr_in6 *wild6_addr;
- struct sockaddr_in6 *wild_mapped_addr;
+ struct sockaddr_in* wild4_addr;
+ struct sockaddr_in6* wild6_addr;
+ struct sockaddr_in6* wild_mapped_addr;
int port;
gpr_log(GPR_INFO, "%s", "test_sockaddr_is_wildcard");
@@ -143,7 +143,7 @@ static void test_sockaddr_is_wildcard(void) {
port = -1;
GPR_ASSERT(grpc_sockaddr_is_wildcard(&wild4, &port));
GPR_ASSERT(port == 555);
- wild4_addr = (struct sockaddr_in *)&wild4.addr;
+ wild4_addr = (struct sockaddr_in*)&wild4.addr;
memset(&wild4_addr->sin_addr.s_addr, 0xbd, 1);
GPR_ASSERT(!grpc_sockaddr_is_wildcard(&wild4, &port));
@@ -151,7 +151,7 @@ static void test_sockaddr_is_wildcard(void) {
port = -1;
GPR_ASSERT(grpc_sockaddr_is_wildcard(&wild6, &port));
GPR_ASSERT(port == 555);
- wild6_addr = (struct sockaddr_in6 *)&wild6.addr;
+ wild6_addr = (struct sockaddr_in6*)&wild6.addr;
memset(&wild6_addr->sin6_addr.s6_addr, 0xbd, 1);
GPR_ASSERT(!grpc_sockaddr_is_wildcard(&wild6, &port));
@@ -159,7 +159,7 @@ static void test_sockaddr_is_wildcard(void) {
port = -1;
GPR_ASSERT(grpc_sockaddr_is_wildcard(&wild_mapped, &port));
GPR_ASSERT(port == 555);
- wild_mapped_addr = (struct sockaddr_in6 *)&wild_mapped.addr;
+ wild_mapped_addr = (struct sockaddr_in6*)&wild_mapped.addr;
memset(&wild_mapped_addr->sin6_addr.s6_addr, 0xbd, 1);
GPR_ASSERT(!grpc_sockaddr_is_wildcard(&wild_mapped, &port));
@@ -170,10 +170,10 @@ static void test_sockaddr_is_wildcard(void) {
GPR_ASSERT(port == -1);
}
-static void expect_sockaddr_str(const char *expected,
- grpc_resolved_address *addr, int normalize) {
+static void expect_sockaddr_str(const char* expected,
+ grpc_resolved_address* addr, int normalize) {
int result;
- char *str;
+ char* str;
gpr_log(GPR_INFO, " expect_sockaddr_str(%s)", expected);
result = grpc_sockaddr_to_string(&str, addr, normalize);
GPR_ASSERT(str != NULL);
@@ -183,9 +183,9 @@ static void expect_sockaddr_str(const char *expected,
gpr_free(str);
}
-static void expect_sockaddr_uri(const char *expected,
- grpc_resolved_address *addr) {
- char *str;
+static void expect_sockaddr_uri(const char* expected,
+ grpc_resolved_address* addr) {
+ char* str;
gpr_log(GPR_INFO, " expect_sockaddr_uri(%s)", expected);
str = grpc_sockaddr_to_uri(addr);
GPR_ASSERT(str != NULL);
@@ -197,7 +197,7 @@ static void test_sockaddr_to_string(void) {
grpc_resolved_address input4;
grpc_resolved_address input6;
grpc_resolved_address dummy;
- struct sockaddr *dummy_addr;
+ struct sockaddr* dummy_addr;
gpr_log(GPR_INFO, "%s", "test_sockaddr_to_string");
@@ -234,7 +234,7 @@ static void test_sockaddr_to_string(void) {
expect_sockaddr_uri("ipv6:[::fffe:c000:263]:12345", &input6);
memset(&dummy, 0, sizeof(dummy));
- dummy_addr = (struct sockaddr *)dummy.addr;
+ dummy_addr = (struct sockaddr*)dummy.addr;
dummy_addr->sa_family = 123;
expect_sockaddr_str("(sockaddr family=123)", &dummy, 0);
expect_sockaddr_str("(sockaddr family=123)", &dummy, 1);
@@ -245,7 +245,7 @@ static void test_sockaddr_set_get_port(void) {
grpc_resolved_address input4;
grpc_resolved_address input6;
grpc_resolved_address dummy;
- struct sockaddr *dummy_addr;
+ struct sockaddr* dummy_addr;
gpr_log(GPR_DEBUG, "test_sockaddr_set_get_port");
@@ -260,13 +260,13 @@ static void test_sockaddr_set_get_port(void) {
GPR_ASSERT(grpc_sockaddr_get_port(&input6) == 54321);
memset(&dummy, 0, sizeof(dummy));
- dummy_addr = (struct sockaddr *)dummy.addr;
+ dummy_addr = (struct sockaddr*)dummy.addr;
dummy_addr->sa_family = 123;
GPR_ASSERT(grpc_sockaddr_get_port(&dummy) == 0);
GPR_ASSERT(grpc_sockaddr_set_port(&dummy, 1234) == 0);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
test_sockaddr_is_v4mapped();
diff --git a/test/core/iomgr/socket_utils_test.c b/test/core/iomgr/socket_utils_test.cc
index 30f0c943dc..49c6f799e7 100644
--- a/test/core/iomgr/socket_utils_test.c
+++ b/test/core/iomgr/socket_utils_test.cc
@@ -39,10 +39,10 @@ struct test_socket_mutator {
int option_value;
};
-static bool mutate_fd(int fd, grpc_socket_mutator *mutator) {
+static bool mutate_fd(int fd, grpc_socket_mutator* mutator) {
int newval;
socklen_t intlen = sizeof(newval);
- struct test_socket_mutator *m = (struct test_socket_mutator *)mutator;
+ struct test_socket_mutator* m = (struct test_socket_mutator*)mutator;
if (0 != setsockopt(fd, IPPROTO_IP, IP_TOS, &m->option_value,
sizeof(m->option_value))) {
@@ -57,24 +57,24 @@ static bool mutate_fd(int fd, grpc_socket_mutator *mutator) {
return true;
}
-static void destroy_test_mutator(grpc_socket_mutator *mutator) {
- struct test_socket_mutator *m = (struct test_socket_mutator *)mutator;
+static void destroy_test_mutator(grpc_socket_mutator* mutator) {
+ struct test_socket_mutator* m = (struct test_socket_mutator*)mutator;
gpr_free(m);
}
-static int compare_test_mutator(grpc_socket_mutator *a,
- grpc_socket_mutator *b) {
- struct test_socket_mutator *ma = (struct test_socket_mutator *)a;
- struct test_socket_mutator *mb = (struct test_socket_mutator *)b;
+static int compare_test_mutator(grpc_socket_mutator* a,
+ grpc_socket_mutator* b) {
+ struct test_socket_mutator* ma = (struct test_socket_mutator*)a;
+ struct test_socket_mutator* mb = (struct test_socket_mutator*)b;
return GPR_ICMP(ma->option_value, mb->option_value);
}
static const grpc_socket_mutator_vtable mutator_vtable = {
mutate_fd, compare_test_mutator, destroy_test_mutator};
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
int sock;
- grpc_error *err;
+ grpc_error* err;
grpc_test_init(argc, argv);
sock = socket(PF_INET, SOCK_STREAM, 0);
@@ -103,20 +103,20 @@ int main(int argc, char **argv) {
mutator.option_value = IPTOS_LOWDELAY;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"set_socket_with_mutator",
- grpc_set_socket_with_mutator(sock, (grpc_socket_mutator *)&mutator)));
+ grpc_set_socket_with_mutator(sock, (grpc_socket_mutator*)&mutator)));
mutator.option_value = IPTOS_THROUGHPUT;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"set_socket_with_mutator",
- grpc_set_socket_with_mutator(sock, (grpc_socket_mutator *)&mutator)));
+ grpc_set_socket_with_mutator(sock, (grpc_socket_mutator*)&mutator)));
mutator.option_value = IPTOS_RELIABILITY;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"set_socket_with_mutator",
- grpc_set_socket_with_mutator(sock, (grpc_socket_mutator *)&mutator)));
+ grpc_set_socket_with_mutator(sock, (grpc_socket_mutator*)&mutator)));
mutator.option_value = -1;
- err = grpc_set_socket_with_mutator(sock, (grpc_socket_mutator *)&mutator);
+ err = grpc_set_socket_with_mutator(sock, (grpc_socket_mutator*)&mutator);
GPR_ASSERT(err != GRPC_ERROR_NONE);
GRPC_ERROR_UNREF(err);
@@ -127,6 +127,6 @@ int main(int argc, char **argv) {
#else /* GRPC_POSIX_SOCKET */
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
#endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/iomgr/tcp_client_posix_test.c b/test/core/iomgr/tcp_client_posix_test.cc
index 1640cb4153..7fad3b08be 100644
--- a/test/core/iomgr/tcp_client_posix_test.c
+++ b/test/core/iomgr/tcp_client_posix_test.cc
@@ -40,11 +40,11 @@
#include "src/core/lib/iomgr/timer.h"
#include "test/core/util/test_config.h"
-static grpc_pollset_set *g_pollset_set;
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static grpc_pollset_set* g_pollset_set;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
static int g_connections_complete = 0;
-static grpc_endpoint *g_connecting = NULL;
+static grpc_endpoint* g_connecting = NULL;
static grpc_millis test_deadline(void) {
return grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(10));
@@ -53,14 +53,14 @@ static grpc_millis test_deadline(void) {
static void finish_connection() {
gpr_mu_lock(g_mu);
g_connections_complete++;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
GPR_ASSERT(
GRPC_LOG_IF_ERROR("pollset_kick", grpc_pollset_kick(g_pollset, NULL)));
grpc_exec_ctx_finish();
gpr_mu_unlock(g_mu);
}
-static void must_succeed(void *arg, grpc_error *error) {
+static void must_succeed(void* arg, grpc_error* error) {
GPR_ASSERT(g_connecting != NULL);
GPR_ASSERT(error == GRPC_ERROR_NONE);
grpc_endpoint_shutdown(g_connecting, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -70,7 +70,7 @@ static void must_succeed(void *arg, grpc_error *error) {
finish_connection();
}
-static void must_fail(void *arg, grpc_error *error) {
+static void must_fail(void* arg, grpc_error* error) {
GPR_ASSERT(g_connecting == NULL);
GPR_ASSERT(error != GRPC_ERROR_NONE);
finish_connection();
@@ -78,12 +78,12 @@ static void must_fail(void *arg, grpc_error *error) {
void test_succeeds(void) {
grpc_resolved_address resolved_addr;
- struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
+ struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
int svr_fd;
int r;
int connections_complete_before;
grpc_closure done;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
gpr_log(GPR_DEBUG, "test_succeeds");
@@ -95,7 +95,7 @@ void test_succeeds(void) {
svr_fd = socket(AF_INET, SOCK_STREAM, 0);
GPR_ASSERT(svr_fd >= 0);
GPR_ASSERT(
- 0 == bind(svr_fd, (struct sockaddr *)addr, (socklen_t)resolved_addr.len));
+ 0 == bind(svr_fd, (struct sockaddr*)addr, (socklen_t)resolved_addr.len));
GPR_ASSERT(0 == listen(svr_fd, 1));
gpr_mu_lock(g_mu);
@@ -103,8 +103,8 @@ void test_succeeds(void) {
gpr_mu_unlock(g_mu);
/* connect to it */
- GPR_ASSERT(getsockname(svr_fd, (struct sockaddr *)addr,
- (socklen_t *)&resolved_addr.len) == 0);
+ GPR_ASSERT(getsockname(svr_fd, (struct sockaddr*)addr,
+ (socklen_t*)&resolved_addr.len) == 0);
GRPC_CLOSURE_INIT(&done, must_succeed, NULL, grpc_schedule_on_exec_ctx);
grpc_tcp_client_connect(&done, &g_connecting, g_pollset_set, NULL,
&resolved_addr, GRPC_MILLIS_INF_FUTURE);
@@ -112,8 +112,7 @@ void test_succeeds(void) {
/* await the connection */
do {
resolved_addr.len = sizeof(addr);
- r = accept(svr_fd, (struct sockaddr *)addr,
- (socklen_t *)&resolved_addr.len);
+ r = accept(svr_fd, (struct sockaddr*)addr, (socklen_t*)&resolved_addr.len);
} while (r == -1 && errno == EINTR);
GPR_ASSERT(r >= 0);
close(r);
@@ -121,7 +120,7 @@ void test_succeeds(void) {
gpr_mu_lock(g_mu);
while (g_connections_complete == connections_complete_before) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(g_pollset, &worker,
@@ -139,10 +138,10 @@ void test_succeeds(void) {
void test_fails(void) {
grpc_resolved_address resolved_addr;
- struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
+ struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
int connections_complete_before;
grpc_closure done;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
gpr_log(GPR_DEBUG, "test_fails");
@@ -163,7 +162,7 @@ void test_fails(void) {
/* wait for the connection callback to finish */
while (g_connections_complete == connections_complete_before) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
grpc_millis polling_deadline = test_deadline();
switch (grpc_timer_check(&polling_deadline)) {
case GRPC_TIMERS_FIRED:
@@ -186,17 +185,17 @@ void test_fails(void) {
grpc_exec_ctx_finish();
}
-static void destroy_pollset(void *p, grpc_error *error) {
- grpc_pollset_destroy(p);
+static void destroy_pollset(void* p, grpc_error* error) {
+ grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_test_init(argc, argv);
grpc_init();
g_pollset_set = grpc_pollset_set_create();
- g_pollset = gpr_zalloc(grpc_pollset_size());
+ g_pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
grpc_pollset_init(g_pollset, &g_mu);
grpc_pollset_set_add_pollset(g_pollset_set, g_pollset);
grpc_exec_ctx_finish();
@@ -215,6 +214,6 @@ int main(int argc, char **argv) {
#else /* GRPC_POSIX_SOCKET */
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
#endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/iomgr/tcp_client_uv_test.c b/test/core/iomgr/tcp_client_uv_test.cc
index 393c183fa9..dd98fb2275 100644
--- a/test/core/iomgr/tcp_client_uv_test.c
+++ b/test/core/iomgr/tcp_client_uv_test.cc
@@ -37,10 +37,10 @@
#include "src/core/lib/iomgr/timer.h"
#include "test/core/util/test_config.h"
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
static int g_connections_complete = 0;
-static grpc_endpoint *g_connecting = NULL;
+static grpc_endpoint* g_connecting = NULL;
static grpc_millis test_deadline(void) {
return grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(10));
@@ -54,7 +54,7 @@ static void finish_connection() {
gpr_mu_unlock(g_mu);
}
-static void must_succeed(void *arg, grpc_error *error) {
+static void must_succeed(void* arg, grpc_error* error) {
GPR_ASSERT(g_connecting != NULL);
GPR_ASSERT(error == GRPC_ERROR_NONE);
grpc_endpoint_shutdown(g_connecting, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -64,29 +64,30 @@ static void must_succeed(void *arg, grpc_error *error) {
finish_connection();
}
-static void must_fail(void *arg, grpc_error *error) {
+static void must_fail(void* arg, grpc_error* error) {
GPR_ASSERT(g_connecting == NULL);
GPR_ASSERT(error != GRPC_ERROR_NONE);
finish_connection();
}
-static void close_cb(uv_handle_t *handle) { gpr_free(handle); }
+static void close_cb(uv_handle_t* handle) { gpr_free(handle); }
-static void connection_cb(uv_stream_t *server, int status) {
- uv_tcp_t *client_handle = gpr_malloc(sizeof(uv_tcp_t));
+static void connection_cb(uv_stream_t* server, int status) {
+ uv_tcp_t* client_handle =
+ static_cast<uv_tcp_t*>(gpr_malloc(sizeof(uv_tcp_t)));
GPR_ASSERT(0 == status);
GPR_ASSERT(0 == uv_tcp_init(uv_default_loop(), client_handle));
- GPR_ASSERT(0 == uv_accept(server, (uv_stream_t *)client_handle));
- uv_close((uv_handle_t *)client_handle, close_cb);
+ GPR_ASSERT(0 == uv_accept(server, (uv_stream_t*)client_handle));
+ uv_close((uv_handle_t*)client_handle, close_cb);
}
void test_succeeds(void) {
grpc_resolved_address resolved_addr;
- struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
- uv_tcp_t *svr_handle = gpr_malloc(sizeof(uv_tcp_t));
+ struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+ uv_tcp_t* svr_handle = static_cast<uv_tcp_t*>(gpr_malloc(sizeof(uv_tcp_t)));
int connections_complete_before;
grpc_closure done;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
gpr_log(GPR_DEBUG, "test_succeeds");
@@ -96,16 +97,16 @@ void test_succeeds(void) {
/* create a dummy server */
GPR_ASSERT(0 == uv_tcp_init(uv_default_loop(), svr_handle));
- GPR_ASSERT(0 == uv_tcp_bind(svr_handle, (struct sockaddr *)addr, 0));
- GPR_ASSERT(0 == uv_listen((uv_stream_t *)svr_handle, 1, connection_cb));
+ GPR_ASSERT(0 == uv_tcp_bind(svr_handle, (struct sockaddr*)addr, 0));
+ GPR_ASSERT(0 == uv_listen((uv_stream_t*)svr_handle, 1, connection_cb));
gpr_mu_lock(g_mu);
connections_complete_before = g_connections_complete;
gpr_mu_unlock(g_mu);
/* connect to it */
- GPR_ASSERT(uv_tcp_getsockname(svr_handle, (struct sockaddr *)addr,
- (int *)&resolved_addr.len) == 0);
+ GPR_ASSERT(uv_tcp_getsockname(svr_handle, (struct sockaddr*)addr,
+ (int*)&resolved_addr.len) == 0);
GRPC_CLOSURE_INIT(&done, must_succeed, NULL, grpc_schedule_on_exec_ctx);
grpc_tcp_client_connect(&done, &g_connecting, NULL, NULL, &resolved_addr,
GRPC_MILLIS_INF_FUTURE);
@@ -113,7 +114,7 @@ void test_succeeds(void) {
gpr_mu_lock(g_mu);
while (g_connections_complete == connections_complete_before) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(g_pollset, &worker,
@@ -125,7 +126,7 @@ void test_succeeds(void) {
}
// This will get cleaned up when the pollset runs again or gets shutdown
- uv_close((uv_handle_t *)svr_handle, close_cb);
+ uv_close((uv_handle_t*)svr_handle, close_cb);
gpr_mu_unlock(g_mu);
@@ -134,10 +135,10 @@ void test_succeeds(void) {
void test_fails(void) {
grpc_resolved_address resolved_addr;
- struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
+ struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
int connections_complete_before;
grpc_closure done;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
gpr_log(GPR_DEBUG, "test_fails");
@@ -158,7 +159,7 @@ void test_fails(void) {
/* wait for the connection callback to finish */
while (g_connections_complete == connections_complete_before) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
gpr_timespec now = gpr_now(GPR_CLOCK_MONOTONIC);
grpc_millis polling_deadline = test_deadline();
switch (grpc_timer_check(&polling_deadline)) {
@@ -182,16 +183,16 @@ void test_fails(void) {
grpc_exec_ctx_finish();
}
-static void destroy_pollset(void *p, grpc_error *error) {
- grpc_pollset_destroy(p);
+static void destroy_pollset(void* p, grpc_error* error) {
+ grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_test_init(argc, argv);
grpc_init();
- g_pollset = gpr_malloc(grpc_pollset_size());
+ g_pollset = static_cast<grpc_pollset*>(gpr_malloc(grpc_pollset_size()));
grpc_pollset_init(g_pollset, &g_mu);
grpc_exec_ctx_finish();
test_succeeds();
@@ -208,6 +209,6 @@ int main(int argc, char **argv) {
#else /* GRPC_UV */
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
#endif /* GRPC_UV */
diff --git a/test/core/iomgr/tcp_posix_test.c b/test/core/iomgr/tcp_posix_test.cc
index 83f1ad424d..e4126fb05a 100644
--- a/test/core/iomgr/tcp_posix_test.c
+++ b/test/core/iomgr/tcp_posix_test.cc
@@ -40,8 +40,8 @@
#include "test/core/iomgr/endpoint_tests.h"
#include "test/core/util/test_config.h"
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
/*
General test notes:
@@ -89,7 +89,7 @@ static ssize_t fill_socket(int fd) {
static size_t fill_socket_partial(int fd, size_t bytes) {
ssize_t write_bytes;
size_t total_bytes = 0;
- unsigned char *buf = (unsigned char *)gpr_malloc(bytes);
+ unsigned char* buf = (unsigned char*)gpr_malloc(bytes);
unsigned i;
for (i = 0; i < bytes; ++i) {
buf[i] = (uint8_t)(i % 256);
@@ -108,18 +108,18 @@ static size_t fill_socket_partial(int fd, size_t bytes) {
}
struct read_socket_state {
- grpc_endpoint *ep;
+ grpc_endpoint* ep;
size_t read_bytes;
size_t target_read_bytes;
grpc_slice_buffer incoming;
grpc_closure read_cb;
};
-static size_t count_slices(grpc_slice *slices, size_t nslices,
- int *current_data) {
+static size_t count_slices(grpc_slice* slices, size_t nslices,
+ int* current_data) {
size_t num_bytes = 0;
unsigned i, j;
- unsigned char *buf;
+ unsigned char* buf;
for (i = 0; i < nslices; ++i) {
buf = GRPC_SLICE_START_PTR(slices[i]);
for (j = 0; j < GRPC_SLICE_LENGTH(slices[i]); ++j) {
@@ -131,8 +131,8 @@ static size_t count_slices(grpc_slice *slices, size_t nslices,
return num_bytes;
}
-static void read_cb(void *user_data, grpc_error *error) {
- struct read_socket_state *state = (struct read_socket_state *)user_data;
+static void read_cb(void* user_data, grpc_error* error) {
+ struct read_socket_state* state = (struct read_socket_state*)user_data;
size_t read_bytes;
int current_data;
@@ -157,22 +157,22 @@ static void read_cb(void *user_data, grpc_error *error) {
/* Write to a socket, then read from it using the grpc_tcp API. */
static void read_test(size_t num_bytes, size_t slice_size) {
int sv[2];
- grpc_endpoint *ep;
+ grpc_endpoint* ep;
struct read_socket_state state;
size_t written_bytes;
grpc_millis deadline =
grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(20));
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
gpr_log(GPR_INFO, "Read test of size %" PRIuPTR ", slice size %" PRIuPTR,
num_bytes, slice_size);
create_sockets(sv);
- grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
- .type = GRPC_ARG_INTEGER,
- .value.integer = (int)slice_size}};
- grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+ grpc_arg a[1];
+ a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+ a[0].type = GRPC_ARG_INTEGER, a[0].value.integer = (int)slice_size;
+ grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
ep = grpc_tcp_create(grpc_fd_create(sv[1], "read_test"), &args, "test");
grpc_endpoint_add_to_pollset(ep, g_pollset);
@@ -189,7 +189,7 @@ static void read_test(size_t num_bytes, size_t slice_size) {
gpr_mu_lock(g_mu);
while (state.read_bytes < state.target_read_bytes) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work", grpc_pollset_work(g_pollset, &worker, deadline)));
gpr_mu_unlock(g_mu);
@@ -208,21 +208,22 @@ static void read_test(size_t num_bytes, size_t slice_size) {
API. */
static void large_read_test(size_t slice_size) {
int sv[2];
- grpc_endpoint *ep;
+ grpc_endpoint* ep;
struct read_socket_state state;
ssize_t written_bytes;
grpc_millis deadline =
grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(20));
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
gpr_log(GPR_INFO, "Start large read test, slice size %" PRIuPTR, slice_size);
create_sockets(sv);
- grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
- .type = GRPC_ARG_INTEGER,
- .value.integer = (int)slice_size}};
- grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+ grpc_arg a[1];
+ a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+ a[0].type = GRPC_ARG_INTEGER;
+ a[0].value.integer = (int)slice_size;
+ grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
ep = grpc_tcp_create(grpc_fd_create(sv[1], "large_read_test"), &args, "test");
grpc_endpoint_add_to_pollset(ep, g_pollset);
@@ -239,7 +240,7 @@ static void large_read_test(size_t slice_size) {
gpr_mu_lock(g_mu);
while (state.read_bytes < state.target_read_bytes) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work", grpc_pollset_work(g_pollset, &worker, deadline)));
gpr_mu_unlock(g_mu);
@@ -255,17 +256,17 @@ static void large_read_test(size_t slice_size) {
}
struct write_socket_state {
- grpc_endpoint *ep;
+ grpc_endpoint* ep;
int write_done;
};
-static grpc_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
- size_t *num_blocks, uint8_t *current_data) {
+static grpc_slice* allocate_blocks(size_t num_bytes, size_t slice_size,
+ size_t* num_blocks, uint8_t* current_data) {
size_t nslices = num_bytes / slice_size + (num_bytes % slice_size ? 1u : 0u);
- grpc_slice *slices = (grpc_slice *)gpr_malloc(sizeof(grpc_slice) * nslices);
+ grpc_slice* slices = (grpc_slice*)gpr_malloc(sizeof(grpc_slice) * nslices);
size_t num_bytes_left = num_bytes;
unsigned i, j;
- unsigned char *buf;
+ unsigned char* buf;
*num_blocks = nslices;
for (i = 0; i < nslices; ++i) {
@@ -282,9 +283,9 @@ static grpc_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
return slices;
}
-static void write_done(void *user_data /* write_socket_state */,
- grpc_error *error) {
- struct write_socket_state *state = (struct write_socket_state *)user_data;
+static void write_done(void* user_data /* write_socket_state */,
+ grpc_error* error) {
+ struct write_socket_state* state = (struct write_socket_state*)user_data;
gpr_log(GPR_INFO, "Write done callback called");
gpr_mu_lock(g_mu);
gpr_log(GPR_INFO, "Signalling write done");
@@ -295,19 +296,19 @@ static void write_done(void *user_data /* write_socket_state */,
}
void drain_socket_blocking(int fd, size_t num_bytes, size_t read_size) {
- unsigned char *buf = (unsigned char *)gpr_malloc(read_size);
+ unsigned char* buf = (unsigned char*)gpr_malloc(read_size);
ssize_t bytes_read;
size_t bytes_left = num_bytes;
int flags;
int current = 0;
int i;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
flags = fcntl(fd, F_GETFL, 0);
GPR_ASSERT(fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) == 0);
for (;;) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
gpr_mu_lock(g_mu);
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
@@ -339,16 +340,16 @@ void drain_socket_blocking(int fd, size_t num_bytes, size_t read_size) {
socket in parallel with the read. */
static void write_test(size_t num_bytes, size_t slice_size) {
int sv[2];
- grpc_endpoint *ep;
+ grpc_endpoint* ep;
struct write_socket_state state;
size_t num_blocks;
- grpc_slice *slices;
+ grpc_slice* slices;
uint8_t current_data = 0;
grpc_slice_buffer outgoing;
grpc_closure write_done_closure;
grpc_millis deadline =
grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(20));
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
gpr_log(GPR_INFO,
"Start write test with %" PRIuPTR " bytes, slice size %" PRIuPTR,
@@ -356,10 +357,10 @@ static void write_test(size_t num_bytes, size_t slice_size) {
create_sockets(sv);
- grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
- .type = GRPC_ARG_INTEGER,
- .value.integer = (int)slice_size}};
- grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+ grpc_arg a[1];
+ a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+ a[0].type = GRPC_ARG_INTEGER, a[0].value.integer = (int)slice_size;
+ grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
ep = grpc_tcp_create(grpc_fd_create(sv[1], "write_test"), &args, "test");
grpc_endpoint_add_to_pollset(ep, g_pollset);
@@ -377,7 +378,7 @@ static void write_test(size_t num_bytes, size_t slice_size) {
drain_socket_blocking(sv[0], num_bytes, num_bytes);
gpr_mu_lock(g_mu);
for (;;) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
if (state.write_done) {
break;
}
@@ -395,8 +396,8 @@ static void write_test(size_t num_bytes, size_t slice_size) {
grpc_exec_ctx_finish();
}
-void on_fd_released(void *arg, grpc_error *errors) {
- int *done = (int *)arg;
+void on_fd_released(void* arg, grpc_error* errors) {
+ int* done = (int*)arg;
*done = 1;
GPR_ASSERT(
GRPC_LOG_IF_ERROR("pollset_kick", grpc_pollset_kick(g_pollset, NULL)));
@@ -406,13 +407,13 @@ void on_fd_released(void *arg, grpc_error *errors) {
grpc_tcp_fd() is available before the fd is released. */
static void release_fd_test(size_t num_bytes, size_t slice_size) {
int sv[2];
- grpc_endpoint *ep;
+ grpc_endpoint* ep;
struct read_socket_state state;
size_t written_bytes;
int fd;
grpc_millis deadline =
grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(20));
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_closure fd_released_cb;
int fd_released_done = 0;
GRPC_CLOSURE_INIT(&fd_released_cb, &on_fd_released, &fd_released_done,
@@ -424,10 +425,11 @@ static void release_fd_test(size_t num_bytes, size_t slice_size) {
create_sockets(sv);
- grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
- .type = GRPC_ARG_INTEGER,
- .value.integer = (int)slice_size}};
- grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+ grpc_arg a[1];
+ a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+ a[0].type = GRPC_ARG_INTEGER;
+ a[0].value.integer = (int)slice_size;
+ grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
ep = grpc_tcp_create(grpc_fd_create(sv[1], "read_test"), &args, "test");
GPR_ASSERT(grpc_tcp_fd(ep) == sv[1] && sv[1] >= 0);
grpc_endpoint_add_to_pollset(ep, g_pollset);
@@ -445,7 +447,7 @@ static void release_fd_test(size_t num_bytes, size_t slice_size) {
gpr_mu_lock(g_mu);
while (state.read_bytes < state.target_read_bytes) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work", grpc_pollset_work(g_pollset, &worker, deadline)));
gpr_log(GPR_DEBUG, "wakeup: read=%" PRIdPTR " target=%" PRIdPTR,
@@ -462,7 +464,7 @@ static void release_fd_test(size_t num_bytes, size_t slice_size) {
grpc_exec_ctx_flush();
gpr_mu_lock(g_mu);
while (!fd_released_done) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work", grpc_pollset_work(g_pollset, &worker, deadline)));
gpr_log(GPR_DEBUG, "wakeup: fd_released_done=%d", fd_released_done);
@@ -508,15 +510,16 @@ static grpc_endpoint_test_fixture create_fixture_tcp_socketpair(
size_t slice_size) {
int sv[2];
grpc_endpoint_test_fixture f;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
create_sockets(sv);
- grpc_resource_quota *resource_quota =
+ grpc_resource_quota* resource_quota =
grpc_resource_quota_create("tcp_posix_test_socketpair");
- grpc_arg a[] = {{.key = GRPC_ARG_TCP_READ_CHUNK_SIZE,
- .type = GRPC_ARG_INTEGER,
- .value.integer = (int)slice_size}};
- grpc_channel_args args = {.num_args = GPR_ARRAY_SIZE(a), .args = a};
+ grpc_arg a[1];
+ a[0].key = const_cast<char*>(GRPC_ARG_TCP_READ_CHUNK_SIZE);
+ a[0].type = GRPC_ARG_INTEGER;
+ a[0].value.integer = (int)slice_size;
+ grpc_channel_args args = {GPR_ARRAY_SIZE(a), a};
f.client_ep =
grpc_tcp_create(grpc_fd_create(sv[0], "fixture:client"), &args, "test");
f.server_ep =
@@ -534,16 +537,16 @@ static grpc_endpoint_test_config configs[] = {
{"tcp/tcp_socketpair", create_fixture_tcp_socketpair, clean_up},
};
-static void destroy_pollset(void *p, grpc_error *error) {
- grpc_pollset_destroy((grpc_pollset *)p);
+static void destroy_pollset(void* p, grpc_error* error) {
+ grpc_pollset_destroy((grpc_pollset*)p);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_test_init(argc, argv);
grpc_init();
- g_pollset = (grpc_pollset *)gpr_zalloc(grpc_pollset_size());
+ g_pollset = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
grpc_pollset_init(g_pollset, &g_mu);
grpc_endpoint_tests(configs[0], g_pollset, g_mu);
run_tests();
@@ -559,6 +562,6 @@ int main(int argc, char **argv) {
#else /* GRPC_POSIX_SOCKET */
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
#endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/iomgr/tcp_server_posix_test.c b/test/core/iomgr/tcp_server_posix_test.cc
index a1684fe72c..3707634c29 100644
--- a/test/core/iomgr/tcp_server_posix_test.c
+++ b/test/core/iomgr/tcp_server_posix_test.cc
@@ -47,20 +47,20 @@
#define LOG_TEST(x) gpr_log(GPR_INFO, "%s", #x)
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
static int g_nconnects = 0;
typedef struct {
/* Owns a ref to server. */
- grpc_tcp_server *server;
+ grpc_tcp_server* server;
unsigned port_index;
unsigned fd_index;
int server_fd;
} on_connect_result;
typedef struct {
- grpc_tcp_server *server;
+ grpc_tcp_server* server;
/* arg is this server_weak_ref. */
grpc_closure server_shutdown;
@@ -81,7 +81,7 @@ typedef struct {
static on_connect_result g_result = {NULL, 0, 0, -1};
static char family_name_buf[1024];
-static const char *sock_family_name(int family) {
+static const char* sock_family_name(int family) {
if (family == AF_INET) {
return "AF_INET";
} else if (family == AF_INET6) {
@@ -94,15 +94,15 @@ static const char *sock_family_name(int family) {
}
}
-static void on_connect_result_init(on_connect_result *result) {
+static void on_connect_result_init(on_connect_result* result) {
result->server = NULL;
result->port_index = 0;
result->fd_index = 0;
result->server_fd = -1;
}
-static void on_connect_result_set(on_connect_result *result,
- const grpc_tcp_server_acceptor *acceptor) {
+static void on_connect_result_set(on_connect_result* result,
+ const grpc_tcp_server_acceptor* acceptor) {
result->server = grpc_tcp_server_ref(acceptor->from_server);
result->port_index = acceptor->port_index;
result->fd_index = acceptor->fd_index;
@@ -110,12 +110,12 @@ static void on_connect_result_set(on_connect_result *result,
result->server, acceptor->port_index, acceptor->fd_index);
}
-static void server_weak_ref_shutdown(void *arg, grpc_error *error) {
- server_weak_ref *weak_ref = arg;
+static void server_weak_ref_shutdown(void* arg, grpc_error* error) {
+ server_weak_ref* weak_ref = static_cast<server_weak_ref*>(arg);
weak_ref->server = NULL;
}
-static void server_weak_ref_init(server_weak_ref *weak_ref) {
+static void server_weak_ref_init(server_weak_ref* weak_ref) {
weak_ref->server = NULL;
GRPC_CLOSURE_INIT(&weak_ref->server_shutdown, server_weak_ref_shutdown,
weak_ref, grpc_schedule_on_exec_ctx);
@@ -126,14 +126,14 @@ static void server_weak_ref_init(server_weak_ref *weak_ref) {
weak_ref->server_shutdown has returned. A strong ref on grpc_tcp_server
should be held until server_weak_ref_set() returns to avoid a race where the
server is deleted before the shutdown_starting cb is added. */
-static void server_weak_ref_set(server_weak_ref *weak_ref,
- grpc_tcp_server *server) {
+static void server_weak_ref_set(server_weak_ref* weak_ref,
+ grpc_tcp_server* server) {
grpc_tcp_server_shutdown_starting_add(server, &weak_ref->server_shutdown);
weak_ref->server = server;
}
-static void test_addr_init_str(test_addr *addr) {
- char *str = NULL;
+static void test_addr_init_str(test_addr* addr) {
+ char* str = NULL;
if (grpc_sockaddr_to_string(&str, &addr->addr, 0) != -1) {
size_t str_len;
memcpy(addr->str, str, (str_len = strnlen(str, sizeof(addr->str) - 1)));
@@ -144,8 +144,8 @@ static void test_addr_init_str(test_addr *addr) {
}
}
-static void on_connect(void *arg, grpc_endpoint *tcp, grpc_pollset *pollset,
- grpc_tcp_server_acceptor *acceptor) {
+static void on_connect(void* arg, grpc_endpoint* tcp, grpc_pollset* pollset,
+ grpc_tcp_server_acceptor* acceptor) {
grpc_endpoint_shutdown(tcp,
GRPC_ERROR_CREATE_FROM_STATIC_STRING("Connected"));
grpc_endpoint_destroy(tcp);
@@ -163,16 +163,16 @@ static void on_connect(void *arg, grpc_endpoint *tcp, grpc_pollset *pollset,
}
static void test_no_op(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_tcp_server *s;
+ ExecCtx _local_exec_ctx;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE == grpc_tcp_server_create(NULL, NULL, &s));
grpc_tcp_server_unref(s);
grpc_exec_ctx_finish();
}
static void test_no_op_with_start(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_tcp_server *s;
+ ExecCtx _local_exec_ctx;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE == grpc_tcp_server_create(NULL, NULL, &s));
LOG_TEST("test_no_op_with_start");
grpc_tcp_server_start(s, NULL, 0, on_connect, NULL);
@@ -181,10 +181,10 @@ static void test_no_op_with_start(void) {
}
static void test_no_op_with_port(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resolved_address resolved_addr;
- struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
- grpc_tcp_server *s;
+ struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE == grpc_tcp_server_create(NULL, NULL, &s));
LOG_TEST("test_no_op_with_port");
@@ -201,10 +201,10 @@ static void test_no_op_with_port(void) {
}
static void test_no_op_with_port_and_start(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resolved_address resolved_addr;
- struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
- grpc_tcp_server *s;
+ struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE == grpc_tcp_server_create(NULL, NULL, &s));
LOG_TEST("test_no_op_with_port_and_start");
int port = -1;
@@ -222,14 +222,14 @@ static void test_no_op_with_port_and_start(void) {
grpc_exec_ctx_finish();
}
-static grpc_error *tcp_connect(const test_addr *remote,
- on_connect_result *result) {
+static grpc_error* tcp_connect(const test_addr* remote,
+ on_connect_result* result) {
grpc_millis deadline =
grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(10));
int clifd;
int nconnects_before;
- const struct sockaddr *remote_addr =
- (const struct sockaddr *)remote->addr.addr;
+ const struct sockaddr* remote_addr =
+ (const struct sockaddr*)remote->addr.addr;
gpr_log(GPR_INFO, "Connecting to %s", remote->str);
gpr_mu_lock(g_mu);
@@ -248,8 +248,8 @@ static grpc_error *tcp_connect(const test_addr *remote,
}
gpr_log(GPR_DEBUG, "wait");
while (g_nconnects == nconnects_before && deadline > grpc_exec_ctx_now()) {
- grpc_pollset_worker *worker = NULL;
- grpc_error *err;
+ grpc_pollset_worker* worker = NULL;
+ grpc_error* err;
if ((err = grpc_pollset_work(g_pollset, &worker, deadline)) !=
GRPC_ERROR_NONE) {
gpr_mu_unlock(g_mu);
@@ -283,21 +283,21 @@ static grpc_error *tcp_connect(const test_addr *remote,
each destination address, set grpc_resolved_address::len=0 for failures, but
don't fail the overall unitest. */
static void test_connect(size_t num_connects,
- const grpc_channel_args *channel_args,
- test_addrs *dst_addrs, bool test_dst_addrs) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ const grpc_channel_args* channel_args,
+ test_addrs* dst_addrs, bool test_dst_addrs) {
+ ExecCtx _local_exec_ctx;
grpc_resolved_address resolved_addr;
grpc_resolved_address resolved_addr1;
- struct sockaddr_storage *const addr =
- (struct sockaddr_storage *)resolved_addr.addr;
- struct sockaddr_storage *const addr1 =
- (struct sockaddr_storage *)resolved_addr1.addr;
+ struct sockaddr_storage* const addr =
+ (struct sockaddr_storage*)resolved_addr.addr;
+ struct sockaddr_storage* const addr1 =
+ (struct sockaddr_storage*)resolved_addr1.addr;
unsigned svr_fd_count;
int port;
int svr_port;
unsigned svr1_fd_count;
int svr1_port;
- grpc_tcp_server *s;
+ grpc_tcp_server* s;
const unsigned num_ports = 2;
GPR_ASSERT(GRPC_ERROR_NONE == grpc_tcp_server_create(NULL, channel_args, &s));
unsigned port_num;
@@ -354,7 +354,7 @@ static void test_connect(size_t num_connects,
for (dst_idx = 0; dst_idx < dst_addrs->naddrs; ++dst_idx) {
test_addr dst = dst_addrs->addrs[dst_idx];
on_connect_result result;
- grpc_error *err;
+ grpc_error* err;
if (dst.addr.len == 0) {
gpr_log(GPR_DEBUG, "Skipping test of non-functional local IP %s",
dst.str);
@@ -386,8 +386,8 @@ static void test_connect(size_t num_connects,
test_addr dst;
GPR_ASSERT(fd >= 0);
dst.addr.len = sizeof(dst.addr.addr);
- GPR_ASSERT(getsockname(fd, (struct sockaddr *)dst.addr.addr,
- (socklen_t *)&dst.addr.len) == 0);
+ GPR_ASSERT(getsockname(fd, (struct sockaddr*)dst.addr.addr,
+ (socklen_t*)&dst.addr.len) == 0);
GPR_ASSERT(dst.addr.len <= sizeof(dst.addr.addr));
test_addr_init_str(&dst);
gpr_log(GPR_INFO, "(%d, %d) fd %d family %s listening on %s", port_num,
@@ -419,23 +419,26 @@ static void test_connect(size_t num_connects,
GPR_ASSERT(weak_ref.server == NULL);
}
-static void destroy_pollset(void *p, grpc_error *error) {
- grpc_pollset_destroy(p);
+static void destroy_pollset(void* p, grpc_error* error) {
+ grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
- exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_arg chan_args[] = {
- {GRPC_ARG_INTEGER, GRPC_ARG_EXPAND_WILDCARD_ADDRS, {.integer = 1}}};
+ ExecCtx _local_exec_ctx;
+ grpc_arg chan_args[1];
+ chan_args[0].type = GRPC_ARG_INTEGER;
+ chan_args[0].key = const_cast<char*>(GRPC_ARG_EXPAND_WILDCARD_ADDRS);
+ chan_args[0].value.integer = 1;
const grpc_channel_args channel_args = {1, chan_args};
- struct ifaddrs *ifa = NULL;
- struct ifaddrs *ifa_it;
+ struct ifaddrs* ifa = NULL;
+ struct ifaddrs* ifa_it;
// Zalloc dst_addrs to avoid oversized frames.
- test_addrs *dst_addrs = gpr_zalloc(sizeof(*dst_addrs));
+ test_addrs* dst_addrs =
+ static_cast<test_addrs*>(gpr_zalloc(sizeof(*dst_addrs)));
grpc_test_init(argc, argv);
grpc_init();
- g_pollset = gpr_zalloc(grpc_pollset_size());
+ g_pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
grpc_pollset_init(g_pollset, &g_mu);
test_no_op();
@@ -495,6 +498,6 @@ int main(int argc, char **argv) {
#else /* GRPC_POSIX_SOCKET */
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
#endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/iomgr/tcp_server_uv_test.c b/test/core/iomgr/tcp_server_uv_test.cc
index 08873a8860..2a0ada225c 100644
--- a/test/core/iomgr/tcp_server_uv_test.c
+++ b/test/core/iomgr/tcp_server_uv_test.cc
@@ -41,19 +41,19 @@
#define LOG_TEST(x) gpr_log(GPR_INFO, "%s", #x)
-static gpr_mu *g_mu;
-static grpc_pollset *g_pollset;
+static gpr_mu* g_mu;
+static grpc_pollset* g_pollset;
static int g_nconnects = 0;
typedef struct on_connect_result {
/* Owns a ref to server. */
- grpc_tcp_server *server;
+ grpc_tcp_server* server;
unsigned port_index;
unsigned fd_index;
} on_connect_result;
typedef struct server_weak_ref {
- grpc_tcp_server *server;
+ grpc_tcp_server* server;
/* arg is this server_weak_ref. */
grpc_closure server_shutdown;
@@ -61,25 +61,25 @@ typedef struct server_weak_ref {
static on_connect_result g_result = {NULL, 0, 0};
-static void on_connect_result_init(on_connect_result *result) {
+static void on_connect_result_init(on_connect_result* result) {
result->server = NULL;
result->port_index = 0;
result->fd_index = 0;
}
-static void on_connect_result_set(on_connect_result *result,
- const grpc_tcp_server_acceptor *acceptor) {
+static void on_connect_result_set(on_connect_result* result,
+ const grpc_tcp_server_acceptor* acceptor) {
result->server = grpc_tcp_server_ref(acceptor->from_server);
result->port_index = acceptor->port_index;
result->fd_index = acceptor->fd_index;
}
-static void server_weak_ref_shutdown(void *arg, grpc_error *error) {
- server_weak_ref *weak_ref = arg;
+static void server_weak_ref_shutdown(void* arg, grpc_error* error) {
+ server_weak_ref* weak_ref = static_cast<server_weak_ref*>(arg);
weak_ref->server = NULL;
}
-static void server_weak_ref_init(server_weak_ref *weak_ref) {
+static void server_weak_ref_init(server_weak_ref* weak_ref) {
weak_ref->server = NULL;
GRPC_CLOSURE_INIT(&weak_ref->server_shutdown, server_weak_ref_shutdown,
weak_ref, grpc_schedule_on_exec_ctx);
@@ -90,14 +90,14 @@ static void server_weak_ref_init(server_weak_ref *weak_ref) {
weak_ref->server_shutdown has returned. A strong ref on grpc_tcp_server
should be held until server_weak_ref_set() returns to avoid a race where the
server is deleted before the shutdown_starting cb is added. */
-static void server_weak_ref_set(server_weak_ref *weak_ref,
- grpc_tcp_server *server) {
+static void server_weak_ref_set(server_weak_ref* weak_ref,
+ grpc_tcp_server* server) {
grpc_tcp_server_shutdown_starting_add(server, &weak_ref->server_shutdown);
weak_ref->server = server;
}
-static void on_connect(void *arg, grpc_endpoint *tcp, grpc_pollset *pollset,
- grpc_tcp_server_acceptor *acceptor) {
+static void on_connect(void* arg, grpc_endpoint* tcp, grpc_pollset* pollset,
+ grpc_tcp_server_acceptor* acceptor) {
grpc_endpoint_shutdown(tcp,
GRPC_ERROR_CREATE_FROM_STATIC_STRING("Connected"));
grpc_endpoint_destroy(tcp);
@@ -115,16 +115,16 @@ static void on_connect(void *arg, grpc_endpoint *tcp, grpc_pollset *pollset,
}
static void test_no_op(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_tcp_server *s;
+ ExecCtx _local_exec_ctx;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE == grpc_tcp_server_create(NULL, NULL, &s));
grpc_tcp_server_unref(s);
grpc_exec_ctx_finish();
}
static void test_no_op_with_start(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_tcp_server *s;
+ ExecCtx _local_exec_ctx;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE == grpc_tcp_server_create(NULL, NULL, &s));
LOG_TEST("test_no_op_with_start");
grpc_tcp_server_start(s, NULL, 0, on_connect, NULL);
@@ -133,10 +133,10 @@ static void test_no_op_with_start(void) {
}
static void test_no_op_with_port(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resolved_address resolved_addr;
- struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
- grpc_tcp_server *s;
+ struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE == grpc_tcp_server_create(NULL, NULL, &s));
LOG_TEST("test_no_op_with_port");
@@ -153,10 +153,10 @@ static void test_no_op_with_port(void) {
}
static void test_no_op_with_port_and_start(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resolved_address resolved_addr;
- struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
- grpc_tcp_server *s;
+ struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE == grpc_tcp_server_create(NULL, NULL, &s));
LOG_TEST("test_no_op_with_port_and_start");
int port;
@@ -174,18 +174,20 @@ static void test_no_op_with_port_and_start(void) {
grpc_exec_ctx_finish();
}
-static void connect_cb(uv_connect_t *req, int status) {
+static void connect_cb(uv_connect_t* req, int status) {
GPR_ASSERT(status == 0);
gpr_free(req);
}
-static void close_cb(uv_handle_t *handle) { gpr_free(handle); }
+static void close_cb(uv_handle_t* handle) { gpr_free(handle); }
-static void tcp_connect(const struct sockaddr *remote, socklen_t remote_len,
- on_connect_result *result) {
+static void tcp_connect(const struct sockaddr* remote, socklen_t remote_len,
+ on_connect_result* result) {
gpr_timespec deadline = grpc_timeout_seconds_to_deadline(10);
- uv_tcp_t *client_handle = gpr_malloc(sizeof(uv_tcp_t));
- uv_connect_t *req = gpr_malloc(sizeof(uv_connect_t));
+ uv_tcp_t* client_handle =
+ static_cast<uv_tcp_t*>(gpr_malloc(sizeof(uv_tcp_t)));
+ uv_connect_t* req =
+ static_cast<uv_connect_t*>(gpr_malloc(sizeof(uv_connect_t)));
int nconnects_before;
gpr_mu_lock(g_mu);
@@ -197,7 +199,7 @@ static void tcp_connect(const struct sockaddr *remote, socklen_t remote_len,
gpr_log(GPR_DEBUG, "wait");
while (g_nconnects == nconnects_before &&
gpr_time_cmp(deadline, gpr_now(deadline.clock_type)) > 0) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(g_pollset, &worker,
@@ -208,7 +210,7 @@ static void tcp_connect(const struct sockaddr *remote, socklen_t remote_len,
}
gpr_log(GPR_DEBUG, "wait done");
GPR_ASSERT(g_nconnects == nconnects_before + 1);
- uv_close((uv_handle_t *)client_handle, close_cb);
+ uv_close((uv_handle_t*)client_handle, close_cb);
*result = g_result;
gpr_mu_unlock(g_mu);
@@ -216,15 +218,15 @@ static void tcp_connect(const struct sockaddr *remote, socklen_t remote_len,
/* Tests a tcp server with multiple ports. */
static void test_connect(unsigned n) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resolved_address resolved_addr;
grpc_resolved_address resolved_addr1;
- struct sockaddr_storage *addr = (struct sockaddr_storage *)resolved_addr.addr;
- struct sockaddr_storage *addr1 =
- (struct sockaddr_storage *)resolved_addr1.addr;
+ struct sockaddr_storage* addr = (struct sockaddr_storage*)resolved_addr.addr;
+ struct sockaddr_storage* addr1 =
+ (struct sockaddr_storage*)resolved_addr1.addr;
int svr_port;
int svr1_port;
- grpc_tcp_server *s;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE == grpc_tcp_server_create(NULL, NULL, &s));
unsigned i;
server_weak_ref weak_ref;
@@ -239,7 +241,7 @@ static void test_connect(unsigned n) {
GPR_ASSERT(GRPC_ERROR_NONE ==
grpc_tcp_server_add_port(s, &resolved_addr, &svr_port));
GPR_ASSERT(svr_port > 0);
- GPR_ASSERT((uv_ip6_addr("::", svr_port, (struct sockaddr_in6 *)addr)) == 0);
+ GPR_ASSERT((uv_ip6_addr("::", svr_port, (struct sockaddr_in6*)addr)) == 0);
/* Cannot use wildcard (port==0), because add_port() will try to reuse the
same port as a previous add_port(). */
svr1_port = grpc_pick_unused_port_or_die();
@@ -250,12 +252,12 @@ static void test_connect(unsigned n) {
grpc_tcp_server_start(s, &g_pollset, 1, on_connect, NULL);
- GPR_ASSERT(uv_ip6_addr("::", svr_port, (struct sockaddr_in6 *)addr1) == 0);
+ GPR_ASSERT(uv_ip6_addr("::", svr_port, (struct sockaddr_in6*)addr1) == 0);
for (i = 0; i < n; i++) {
on_connect_result result;
on_connect_result_init(&result);
- tcp_connect((struct sockaddr *)addr, (socklen_t)resolved_addr.len, &result);
+ tcp_connect((struct sockaddr*)addr, (socklen_t)resolved_addr.len, &result);
GPR_ASSERT(result.port_index == 0);
GPR_ASSERT(result.server == s);
if (weak_ref.server == NULL) {
@@ -264,7 +266,7 @@ static void test_connect(unsigned n) {
grpc_tcp_server_unref(result.server);
on_connect_result_init(&result);
- tcp_connect((struct sockaddr *)addr1, (socklen_t)resolved_addr1.len,
+ tcp_connect((struct sockaddr*)addr1, (socklen_t)resolved_addr1.len,
&result);
GPR_ASSERT(result.port_index == 1);
GPR_ASSERT(result.server == s);
@@ -281,16 +283,16 @@ static void test_connect(unsigned n) {
GPR_ASSERT(weak_ref.server == NULL);
}
-static void destroy_pollset(void *p, grpc_error *error) {
- grpc_pollset_destroy(p);
+static void destroy_pollset(void* p, grpc_error* error) {
+ grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_test_init(argc, argv);
grpc_init();
- g_pollset = gpr_malloc(grpc_pollset_size());
+ g_pollset = static_cast<grpc_pollset*>(gpr_malloc(grpc_pollset_size()));
grpc_pollset_init(g_pollset, &g_mu);
test_no_op();
@@ -311,6 +313,6 @@ int main(int argc, char **argv) {
#else /* GRPC_UV */
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
#endif /* GRPC_UV */
diff --git a/test/core/iomgr/time_averaged_stats_test.c b/test/core/iomgr/time_averaged_stats_test.cc
index 508e3c5bf8..b932e62d1f 100644
--- a/test/core/iomgr/time_averaged_stats_test.c
+++ b/test/core/iomgr/time_averaged_stats_test.cc
@@ -179,7 +179,7 @@ static void some_regress_some_persist_test(void) {
EXPECT_DOUBLE_EQ(2.8304, tas.aggregate_total_weight);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
no_regress_no_persist_test_1();
no_regress_no_persist_test_2();
diff --git a/test/core/iomgr/timer_heap_test.c b/test/core/iomgr/timer_heap_test.cc
index ee5a474fd1..20a383371d 100644
--- a/test/core/iomgr/timer_heap_test.c
+++ b/test/core/iomgr/timer_heap_test.cc
@@ -34,8 +34,9 @@
static gpr_atm random_deadline(void) { return rand(); }
-static grpc_timer *create_test_elements(size_t num_elements) {
- grpc_timer *elems = gpr_malloc(num_elements * sizeof(grpc_timer));
+static grpc_timer* create_test_elements(size_t num_elements) {
+ grpc_timer* elems =
+ static_cast<grpc_timer*>(gpr_malloc(num_elements * sizeof(grpc_timer)));
size_t i;
for (i = 0; i < num_elements; i++) {
elems[i].deadline = random_deadline();
@@ -43,7 +44,7 @@ static grpc_timer *create_test_elements(size_t num_elements) {
return elems;
}
-static int contains(grpc_timer_heap *pq, grpc_timer *el) {
+static int contains(grpc_timer_heap* pq, grpc_timer* el) {
size_t i;
for (i = 0; i < pq->timer_count; i++) {
if (pq->timers[i] == el) return 1;
@@ -51,7 +52,7 @@ static int contains(grpc_timer_heap *pq, grpc_timer *el) {
return 0;
}
-static void check_valid(grpc_timer_heap *pq) {
+static void check_valid(grpc_timer_heap* pq) {
size_t i;
for (i = 0; i < pq->timer_count; ++i) {
size_t left_child = 1u + 2u * i;
@@ -74,8 +75,8 @@ static void test1(void) {
const size_t num_test_elements = 200;
const size_t num_test_operations = 10000;
size_t i;
- grpc_timer *test_elements = create_test_elements(num_test_elements);
- uint8_t *inpq = gpr_malloc(num_test_elements);
+ grpc_timer* test_elements = create_test_elements(num_test_elements);
+ uint8_t* inpq = static_cast<uint8_t*>(gpr_malloc(num_test_elements));
gpr_log(GPR_INFO, "test1");
@@ -102,7 +103,7 @@ static void test1(void) {
for (i = 0; i < num_test_operations; ++i) {
size_t elem_num = (size_t)rand() % num_test_elements;
- grpc_timer *el = &test_elements[elem_num];
+ grpc_timer* el = &test_elements[elem_num];
if (!inpq[elem_num]) { /* not in pq */
GPR_ASSERT(!contains(&pq, el));
el->deadline = random_deadline();
@@ -133,9 +134,10 @@ typedef struct {
bool inserted;
} elem_struct;
-static elem_struct *search_elems(elem_struct *elems, size_t count,
+static elem_struct* search_elems(elem_struct* elems, size_t count,
bool inserted) {
- size_t *search_order = gpr_malloc(count * sizeof(*search_order));
+ size_t* search_order =
+ static_cast<size_t*>(gpr_malloc(count * sizeof(*search_order)));
for (size_t i = 0; i < count; i++) {
search_order[i] = i;
}
@@ -144,7 +146,7 @@ static elem_struct *search_elems(elem_struct *elems, size_t count,
size_t b = (size_t)rand() % count;
GPR_SWAP(size_t, search_order[a], search_order[b]);
}
- elem_struct *out = NULL;
+ elem_struct* out = NULL;
for (size_t i = 0; out == NULL && i < count; i++) {
if (elems[search_order[i]].inserted == inserted) {
out = &elems[search_order[i]];
@@ -160,7 +162,8 @@ static void test2(void) {
grpc_timer_heap pq;
static const size_t elems_size = 1000;
- elem_struct *elems = gpr_malloc(elems_size * sizeof(elem_struct));
+ elem_struct* elems =
+ static_cast<elem_struct*>(gpr_malloc(elems_size * sizeof(elem_struct)));
size_t num_inserted = 0;
grpc_timer_heap_init(&pq);
@@ -170,7 +173,7 @@ static void test2(void) {
int r = rand() % 1000;
if (r <= 550) {
/* 55% of the time we try to add something */
- elem_struct *el = search_elems(elems, GPR_ARRAY_SIZE(elems), false);
+ elem_struct* el = search_elems(elems, GPR_ARRAY_SIZE(elems), false);
if (el != NULL) {
el->elem.deadline = random_deadline();
grpc_timer_heap_add(&pq, &el->elem);
@@ -180,7 +183,7 @@ static void test2(void) {
}
} else if (r <= 650) {
/* 10% of the time we try to remove something */
- elem_struct *el = search_elems(elems, GPR_ARRAY_SIZE(elems), true);
+ elem_struct* el = search_elems(elems, GPR_ARRAY_SIZE(elems), true);
if (el != NULL) {
grpc_timer_heap_remove(&pq, &el->elem);
el->inserted = false;
@@ -190,7 +193,7 @@ static void test2(void) {
} else {
/* the remaining times we pop */
if (num_inserted > 0) {
- grpc_timer *top = grpc_timer_heap_top(&pq);
+ grpc_timer* top = grpc_timer_heap_top(&pq);
grpc_timer_heap_pop(&pq);
for (size_t i = 0; i < elems_size; i++) {
if (top == &elems[i].elem) {
@@ -204,7 +207,7 @@ static void test2(void) {
}
if (num_inserted) {
- gpr_atm *min_deadline = NULL;
+ gpr_atm* min_deadline = NULL;
for (size_t i = 0; i < elems_size; i++) {
if (elems[i].inserted) {
if (min_deadline == NULL) {
@@ -246,7 +249,7 @@ static void shrink_test(void) {
/* Remove elements until the Size is 1/4 the original size. */
while (pq.timer_count > num_elements / 4) {
- grpc_timer *const te = pq.timers[pq.timer_count - 1];
+ grpc_timer* const te = pq.timers[pq.timer_count - 1];
grpc_timer_heap_remove(&pq, te);
gpr_free(te);
}
@@ -263,7 +266,7 @@ static void shrink_test(void) {
expected_size = pq.timer_count;
while (pq.timer_count > 0) {
const size_t which = (size_t)rand() % pq.timer_count;
- grpc_timer *te = pq.timers[which];
+ grpc_timer* te = pq.timers[which];
grpc_timer_heap_remove(&pq, te);
gpr_free(te);
expected_size--;
@@ -283,7 +286,7 @@ static void shrink_test(void) {
grpc_timer_heap_destroy(&pq);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
int i;
grpc_test_init(argc, argv);
@@ -299,6 +302,6 @@ int main(int argc, char **argv) {
#else /* GRPC_TIMER_USE_GENERIC */
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
#endif /* GRPC_TIMER_USE_GENERIC */
diff --git a/test/core/iomgr/timer_list_test.c b/test/core/iomgr/timer_list_test.cc
index 1ef4501a36..07dfec168c 100644
--- a/test/core/iomgr/timer_list_test.c
+++ b/test/core/iomgr/timer_list_test.cc
@@ -31,19 +31,19 @@
#define MAX_CB 30
-extern grpc_tracer_flag grpc_timer_trace;
-extern grpc_tracer_flag grpc_timer_check_trace;
+extern "C" grpc_tracer_flag grpc_timer_trace;
+extern "C" grpc_tracer_flag grpc_timer_check_trace;
static int cb_called[MAX_CB][2];
-static void cb(void *arg, grpc_error *error) {
+static void cb(void* arg, grpc_error* error) {
cb_called[(intptr_t)arg][error == GRPC_ERROR_NONE]++;
}
static void add_test(void) {
int i;
grpc_timer timers[20];
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
gpr_log(GPR_INFO, "add_test");
@@ -56,20 +56,20 @@ static void add_test(void) {
/* 10 ms timers. will expire in the current epoch */
for (i = 0; i < 10; i++) {
- grpc_timer_init(&timers[i], start + 10,
- GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)i,
- grpc_schedule_on_exec_ctx));
+ grpc_timer_init(
+ &timers[i], start + 10,
+ GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)i, grpc_schedule_on_exec_ctx));
}
/* 1010 ms timers. will expire in the next epoch */
for (i = 10; i < 20; i++) {
- grpc_timer_init(&timers[i], start + 1010,
- GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)i,
- grpc_schedule_on_exec_ctx));
+ grpc_timer_init(
+ &timers[i], start + 1010,
+ GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)i, grpc_schedule_on_exec_ctx));
}
/* collect timers. Only the first batch should be ready. */
- exec_ctx.now = start + 500;
+ exec_ctx->now = start + 500;
GPR_ASSERT(grpc_timer_check(NULL) == GRPC_TIMERS_FIRED);
grpc_exec_ctx_finish();
for (i = 0; i < 20; i++) {
@@ -77,7 +77,7 @@ static void add_test(void) {
GPR_ASSERT(cb_called[i][0] == 0);
}
- exec_ctx.now = start + 600;
+ exec_ctx->now = start + 600;
GPR_ASSERT(grpc_timer_check(NULL) == GRPC_TIMERS_CHECKED_AND_EMPTY);
grpc_exec_ctx_finish();
for (i = 0; i < 30; i++) {
@@ -86,7 +86,7 @@ static void add_test(void) {
}
/* collect the rest of the timers */
- exec_ctx.now = start + 1500;
+ exec_ctx->now = start + 1500;
GPR_ASSERT(grpc_timer_check(NULL) == GRPC_TIMERS_FIRED);
grpc_exec_ctx_finish();
for (i = 0; i < 30; i++) {
@@ -94,7 +94,7 @@ static void add_test(void) {
GPR_ASSERT(cb_called[i][0] == 0);
}
- exec_ctx.now = start + 1600;
+ exec_ctx->now = start + 1600;
GPR_ASSERT(grpc_timer_check(NULL) == GRPC_TIMERS_CHECKED_AND_EMPTY);
for (i = 0; i < 30; i++) {
GPR_ASSERT(cb_called[i][1] == (i < 20));
@@ -108,12 +108,12 @@ static void add_test(void) {
/* Cleaning up a list with pending timers. */
void destruction_test(void) {
grpc_timer timers[5];
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
gpr_log(GPR_INFO, "destruction_test");
- exec_ctx.now_is_valid = true;
- exec_ctx.now = 0;
+ exec_ctx->now_is_valid = true;
+ exec_ctx->now = 0;
grpc_timer_list_init();
grpc_timer_trace.value = 1;
grpc_timer_check_trace.value = 1;
@@ -121,20 +121,20 @@ void destruction_test(void) {
grpc_timer_init(
&timers[0], 100,
- GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)0, grpc_schedule_on_exec_ctx));
+ GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)0, grpc_schedule_on_exec_ctx));
grpc_timer_init(
&timers[1], 3,
- GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)1, grpc_schedule_on_exec_ctx));
+ GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)1, grpc_schedule_on_exec_ctx));
grpc_timer_init(
&timers[2], 100,
- GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)2, grpc_schedule_on_exec_ctx));
+ GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)2, grpc_schedule_on_exec_ctx));
grpc_timer_init(
&timers[3], 3,
- GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)3, grpc_schedule_on_exec_ctx));
+ GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)3, grpc_schedule_on_exec_ctx));
grpc_timer_init(
&timers[4], 1,
- GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)4, grpc_schedule_on_exec_ctx));
- exec_ctx.now = 2;
+ GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)4, grpc_schedule_on_exec_ctx));
+ exec_ctx->now = 2;
GPR_ASSERT(grpc_timer_check(NULL) == GRPC_TIMERS_FIRED);
grpc_exec_ctx_finish();
GPR_ASSERT(1 == cb_called[4][1]);
@@ -150,7 +150,7 @@ void destruction_test(void) {
GPR_ASSERT(1 == cb_called[2][0]);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
gpr_set_log_verbosity(GPR_LOG_SEVERITY_DEBUG);
add_test();
@@ -160,6 +160,6 @@ int main(int argc, char **argv) {
#else /* GRPC_TIMER_USE_GENERIC */
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
#endif /* GRPC_TIMER_USE_GENERIC */
diff --git a/test/core/iomgr/udp_server_test.c b/test/core/iomgr/udp_server_test.cc
index 2e2643749c..c079dbf716 100644
--- a/test/core/iomgr/udp_server_test.c
+++ b/test/core/iomgr/udp_server_test.cc
@@ -43,14 +43,14 @@
#define LOG_TEST(x) gpr_log(GPR_INFO, "%s", #x)
-static grpc_pollset *g_pollset;
-static gpr_mu *g_mu;
+static grpc_pollset* g_pollset;
+static gpr_mu* g_mu;
static int g_number_of_reads = 0;
static int g_number_of_writes = 0;
static int g_number_of_bytes_read = 0;
static int g_number_of_orphan_calls = 0;
-static void on_read(grpc_fd *emfd, void *user_data) {
+static void on_read(grpc_fd* emfd, void* user_data) {
char read_buffer[512];
ssize_t byte_count;
@@ -66,7 +66,7 @@ static void on_read(grpc_fd *emfd, void *user_data) {
gpr_mu_unlock(g_mu);
}
-static void on_write(grpc_fd *emfd, void *user_data) {
+static void on_write(grpc_fd* emfd, void* user_data) {
gpr_mu_lock(g_mu);
g_number_of_writes++;
@@ -75,8 +75,8 @@ static void on_write(grpc_fd *emfd, void *user_data) {
gpr_mu_unlock(g_mu);
}
-static void on_fd_orphaned(grpc_fd *emfd, grpc_closure *closure,
- void *user_data) {
+static void on_fd_orphaned(grpc_fd* emfd, grpc_closure* closure,
+ void* user_data) {
gpr_log(GPR_INFO, "gRPC FD about to be orphaned: %d",
grpc_fd_wrapped_fd(emfd));
g_number_of_orphan_calls++;
@@ -89,27 +89,27 @@ struct test_socket_factory {
};
typedef struct test_socket_factory test_socket_factory;
-static int test_socket_factory_socket(grpc_socket_factory *factory, int domain,
+static int test_socket_factory_socket(grpc_socket_factory* factory, int domain,
int type, int protocol) {
- test_socket_factory *f = (test_socket_factory *)factory;
+ test_socket_factory* f = (test_socket_factory*)factory;
f->number_of_socket_calls++;
return socket(domain, type, protocol);
}
-static int test_socket_factory_bind(grpc_socket_factory *factory, int sockfd,
- const grpc_resolved_address *addr) {
- test_socket_factory *f = (test_socket_factory *)factory;
+static int test_socket_factory_bind(grpc_socket_factory* factory, int sockfd,
+ const grpc_resolved_address* addr) {
+ test_socket_factory* f = (test_socket_factory*)factory;
f->number_of_bind_calls++;
- return bind(sockfd, (struct sockaddr *)addr->addr, (socklen_t)addr->len);
+ return bind(sockfd, (struct sockaddr*)addr->addr, (socklen_t)addr->len);
}
-static int test_socket_factory_compare(grpc_socket_factory *a,
- grpc_socket_factory *b) {
+static int test_socket_factory_compare(grpc_socket_factory* a,
+ grpc_socket_factory* b) {
return GPR_ICMP(a, b);
}
-static void test_socket_factory_destroy(grpc_socket_factory *factory) {
- test_socket_factory *f = (test_socket_factory *)factory;
+static void test_socket_factory_destroy(grpc_socket_factory* factory) {
+ test_socket_factory* f = (test_socket_factory*)factory;
gpr_free(f);
}
@@ -117,8 +117,9 @@ static const grpc_socket_factory_vtable test_socket_factory_vtable = {
test_socket_factory_socket, test_socket_factory_bind,
test_socket_factory_compare, test_socket_factory_destroy};
-static test_socket_factory *test_socket_factory_create(void) {
- test_socket_factory *factory = gpr_malloc(sizeof(test_socket_factory));
+static test_socket_factory* test_socket_factory_create(void) {
+ test_socket_factory* factory = static_cast<test_socket_factory*>(
+ gpr_malloc(sizeof(test_socket_factory)));
grpc_socket_factory_init(&factory->base, &test_socket_factory_vtable);
factory->number_of_socket_calls = 0;
factory->number_of_bind_calls = 0;
@@ -126,15 +127,15 @@ static test_socket_factory *test_socket_factory_create(void) {
}
static void test_no_op(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_udp_server *s = grpc_udp_server_create(NULL);
+ ExecCtx _local_exec_ctx;
+ grpc_udp_server* s = grpc_udp_server_create(NULL);
grpc_udp_server_destroy(s, NULL);
grpc_exec_ctx_finish();
}
static void test_no_op_with_start(void) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_udp_server *s = grpc_udp_server_create(NULL);
+ ExecCtx _local_exec_ctx;
+ grpc_udp_server* s = grpc_udp_server_create(NULL);
LOG_TEST("test_no_op_with_start");
grpc_udp_server_start(s, NULL, 0, NULL);
grpc_udp_server_destroy(s, NULL);
@@ -143,10 +144,10 @@ static void test_no_op_with_start(void) {
static void test_no_op_with_port(void) {
g_number_of_orphan_calls = 0;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resolved_address resolved_addr;
- struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
- grpc_udp_server *s = grpc_udp_server_create(NULL);
+ struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+ grpc_udp_server* s = grpc_udp_server_create(NULL);
LOG_TEST("test_no_op_with_port");
memset(&resolved_addr, 0, sizeof(resolved_addr));
@@ -164,16 +165,16 @@ static void test_no_op_with_port(void) {
static void test_no_op_with_port_and_socket_factory(void) {
g_number_of_orphan_calls = 0;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resolved_address resolved_addr;
- struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
+ struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
- test_socket_factory *socket_factory = test_socket_factory_create();
+ test_socket_factory* socket_factory = test_socket_factory_create();
grpc_arg socket_factory_arg =
grpc_socket_factory_to_arg(&socket_factory->base);
- grpc_channel_args *channel_args =
+ grpc_channel_args* channel_args =
grpc_channel_args_copy_and_add(NULL, &socket_factory_arg, 1);
- grpc_udp_server *s = grpc_udp_server_create(channel_args);
+ grpc_udp_server* s = grpc_udp_server_create(channel_args);
grpc_channel_args_destroy(channel_args);
LOG_TEST("test_no_op_with_port_and_socket_factory");
@@ -196,10 +197,10 @@ static void test_no_op_with_port_and_socket_factory(void) {
static void test_no_op_with_port_and_start(void) {
g_number_of_orphan_calls = 0;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resolved_address resolved_addr;
- struct sockaddr_in *addr = (struct sockaddr_in *)resolved_addr.addr;
- grpc_udp_server *s = grpc_udp_server_create(NULL);
+ struct sockaddr_in* addr = (struct sockaddr_in*)resolved_addr.addr;
+ grpc_udp_server* s = grpc_udp_server_create(NULL);
LOG_TEST("test_no_op_with_port_and_start");
memset(&resolved_addr, 0, sizeof(resolved_addr));
@@ -219,15 +220,15 @@ static void test_no_op_with_port_and_start(void) {
}
static void test_receive(int number_of_clients) {
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_resolved_address resolved_addr;
- struct sockaddr_storage *addr = (struct sockaddr_storage *)resolved_addr.addr;
+ struct sockaddr_storage* addr = (struct sockaddr_storage*)resolved_addr.addr;
int clifd, svrfd;
- grpc_udp_server *s = grpc_udp_server_create(NULL);
+ grpc_udp_server* s = grpc_udp_server_create(NULL);
int i;
int number_of_reads_before;
grpc_millis deadline;
- grpc_pollset *pollsets[1];
+ grpc_pollset* pollsets[1];
LOG_TEST("test_receive");
gpr_log(GPR_INFO, "clients=%d", number_of_clients);
@@ -242,8 +243,8 @@ static void test_receive(int number_of_clients) {
svrfd = grpc_udp_server_get_fd(s, 0);
GPR_ASSERT(svrfd >= 0);
- GPR_ASSERT(getsockname(svrfd, (struct sockaddr *)addr,
- (socklen_t *)&resolved_addr.len) == 0);
+ GPR_ASSERT(getsockname(svrfd, (struct sockaddr*)addr,
+ (socklen_t*)&resolved_addr.len) == 0);
GPR_ASSERT(resolved_addr.len <= sizeof(struct sockaddr_storage));
pollsets[0] = g_pollset;
@@ -259,12 +260,12 @@ static void test_receive(int number_of_clients) {
/* Create a socket, send a packet to the UDP server. */
clifd = socket(addr->ss_family, SOCK_DGRAM, 0);
GPR_ASSERT(clifd >= 0);
- GPR_ASSERT(connect(clifd, (struct sockaddr *)addr,
+ GPR_ASSERT(connect(clifd, (struct sockaddr*)addr,
(socklen_t)resolved_addr.len) == 0);
GPR_ASSERT(5 == write(clifd, "hello", 5));
while (g_number_of_reads == number_of_reads_before &&
deadline > grpc_exec_ctx_now()) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = NULL;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work", grpc_pollset_work(g_pollset, &worker, deadline)));
gpr_mu_unlock(g_mu);
@@ -289,16 +290,16 @@ static void test_receive(int number_of_clients) {
GPR_ASSERT(g_number_of_writes > 0);
}
-static void destroy_pollset(void *p, grpc_error *error) {
- grpc_pollset_destroy(p);
+static void destroy_pollset(void* p, grpc_error* error) {
+ grpc_pollset_destroy(static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
- exec_ctx = GRPC_EXEC_CTX_INIT;
+ ExecCtx _local_exec_ctx;
grpc_test_init(argc, argv);
grpc_init();
- g_pollset = gpr_zalloc(grpc_pollset_size());
+ g_pollset = static_cast<grpc_pollset*>(gpr_zalloc(grpc_pollset_size()));
grpc_pollset_init(g_pollset, &g_mu);
test_no_op();
@@ -320,6 +321,6 @@ int main(int argc, char **argv) {
#else /* GRPC_POSIX_SOCKET */
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
#endif /* GRPC_POSIX_SOCKET */
diff --git a/test/core/iomgr/wakeup_fd_cv_test.c b/test/core/iomgr/wakeup_fd_cv_test.cc
index 0b211274f2..dc1d77a0ab 100644
--- a/test/core/iomgr/wakeup_fd_cv_test.c
+++ b/test/core/iomgr/wakeup_fd_cv_test.cc
@@ -32,7 +32,7 @@
#include "src/core/lib/support/env.h"
typedef struct poll_args {
- struct pollfd *fds;
+ struct pollfd* fds;
nfds_t nfds;
int timeout;
int result;
@@ -57,7 +57,7 @@ void reset_socket_event() {
}
// Mocks posix poll() function
-int mock_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
+int mock_poll(struct pollfd* fds, nfds_t nfds, int timeout) {
int res = 0;
gpr_timespec poll_time;
gpr_mu_lock(&poll_mu);
@@ -84,8 +84,8 @@ int mock_poll(struct pollfd *fds, nfds_t nfds, int timeout) {
return res;
}
-void background_poll(void *args) {
- poll_args *pargs = (poll_args *)args;
+void background_poll(void* args) {
+ poll_args* pargs = (poll_args*)args;
pargs->result = grpc_poll_function(pargs->fds, pargs->nfds, pargs->timeout);
}
@@ -211,7 +211,7 @@ void test_poll_cv_trigger(void) {
GPR_ASSERT(pfds[5].revents == 0);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
gpr_setenv("GRPC_POLL_STRATEGY", "poll-cv");
grpc_poll_function = &mock_poll;
gpr_mu_init(&poll_mu);
@@ -229,6 +229,6 @@ int main(int argc, char **argv) {
#else /* GRPC_POSIX_SOCKET */
-int main(int argc, char **argv) { return 1; }
+int main(int argc, char** argv) { return 1; }
#endif /* GRPC_POSIX_SOCKET */
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-25 22:53:34 +0000