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)43
-rw-r--r--test/core/iomgr/endpoint_pair_test.cc (renamed from test/core/iomgr/endpoint_pair_test.c)23
-rw-r--r--test/core/iomgr/endpoint_tests.cc (renamed from test/core/iomgr/endpoint_tests.c)76
-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)83
-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)155
-rw-r--r--test/core/iomgr/load_file_test.cc (renamed from test/core/iomgr/load_file_test.c)50
-rw-r--r--test/core/iomgr/pollset_set_test.cc (renamed from test/core/iomgr/pollset_set_test.c)67
-rw-r--r--test/core/iomgr/resolve_address_posix_test.cc (renamed from test/core/iomgr/resolve_address_posix_test.c)55
-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)233
-rw-r--r--test/core/iomgr/sockaddr_utils_test.cc (renamed from test/core/iomgr/sockaddr_utils_test.c)60
-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)65
-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)135
-rw-r--r--test/core/iomgr/tcp_server_posix_test.cc (renamed from test/core/iomgr/tcp_server_posix_test.c)159
-rw-r--r--test/core/iomgr/tcp_server_uv_test.cc (renamed from test/core/iomgr/tcp_server_uv_test.c)92
-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)49
-rw-r--r--test/core/iomgr/timer_list_test.cc (renamed from test/core/iomgr/timer_list_test.c)51
-rw-r--r--test/core/iomgr/udp_server_test.cc (renamed from test/core/iomgr/udp_server_test.c)111
-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, 901 insertions, 870 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 38f512de0e..146a6bd553 100644
--- a/test/core/iomgr/combiner_test.c
+++ b/test/core/iomgr/combiner_test.cc
@@ -33,15 +33,15 @@ static void test_no_op(void) {
grpc_exec_ctx_finish(&exec_ctx);
}
-static void set_event_to_true(grpc_exec_ctx *exec_ctx, void *value,
- grpc_error *error) {
- gpr_event_set(value, (void *)1);
+static void set_event_to_true(grpc_exec_ctx* exec_ctx, 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);
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -51,36 +51,36 @@ static void test_execute_one(void) {
GRPC_ERROR_NONE);
grpc_exec_ctx_flush(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&done, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
GRPC_COMBINER_UNREF(&exec_ctx, lock, "test_execute_one");
grpc_exec_ctx_finish(&exec_ctx);
}
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(grpc_exec_ctx *exec_ctx, void *a, grpc_error *error) {
- ex_args *args = a;
+static void check_one(grpc_exec_ctx* exec_ctx, 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;
+static void execute_many_loop(void* a) {
+ thd_args* args = static_cast<thd_args*>(a);
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(&exec_ctx,
@@ -103,7 +103,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++) {
@@ -116,7 +116,7 @@ static void test_execute_many(void) {
}
for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {
GPR_ASSERT(gpr_event_wait(&ta[i].done,
- gpr_inf_future(GPR_CLOCK_REALTIME)) != NULL);
+ gpr_inf_future(GPR_CLOCK_REALTIME)) != nullptr);
gpr_thd_join(thds[i]);
}
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -126,21 +126,22 @@ static void test_execute_many(void) {
static gpr_event got_in_finally;
-static void in_finally(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
- gpr_event_set(&got_in_finally, (void *)1);
+static void in_finally(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+ gpr_event_set(&got_in_finally, (void*)1);
}
-static void add_finally(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
+static void add_finally(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
GRPC_CLOSURE_SCHED(exec_ctx,
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();
+ grpc_combiner* lock = grpc_combiner_create();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
gpr_event_init(&got_in_finally);
GRPC_CLOSURE_SCHED(
@@ -149,12 +150,12 @@ static void test_execute_finally(void) {
GRPC_ERROR_NONE);
grpc_exec_ctx_flush(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&got_in_finally,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
GRPC_COMBINER_UNREF(&exec_ctx, lock, "test_execute_finally");
grpc_exec_ctx_finish(&exec_ctx);
}
-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 f2ce3d0d12..30a0cb5924 100644
--- a/test/core/iomgr/endpoint_pair_test.c
+++ b/test/core/iomgr/endpoint_pair_test.cc
@@ -25,8 +25,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;
static void clean_up(void) {}
@@ -34,10 +34,11 @@ static grpc_endpoint_test_fixture create_fixture_endpoint_pair(
size_t slice_size) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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,17 +54,17 @@ static grpc_endpoint_test_config configs[] = {
{"tcp/tcp_socketpair", create_fixture_endpoint_pair, clean_up},
};
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
- grpc_error *error) {
- grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+ grpc_error* error) {
+ grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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.c b/test/core/iomgr/endpoint_tests.cc
index 61e901f645..026e34105d 100644
--- a/test/core/iomgr/endpoint_tests.c
+++ 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,10 +115,10 @@ struct read_and_write_test_state {
grpc_closure done_write;
};
-static void read_and_write_test_read_handler(grpc_exec_ctx *exec_ctx,
- 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(grpc_exec_ctx* exec_ctx,
+ 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);
@@ -127,7 +127,7 @@ static void read_and_write_test_read_handler(grpc_exec_ctx *exec_ctx,
gpr_mu_lock(g_mu);
state->read_done = 1 + (error == GRPC_ERROR_NONE);
GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, g_pollset, NULL));
+ grpc_pollset_kick(exec_ctx, g_pollset, nullptr));
gpr_mu_unlock(g_mu);
} else if (error == GRPC_ERROR_NONE) {
grpc_endpoint_read(exec_ctx, state->read_ep, &state->incoming,
@@ -135,11 +135,11 @@ static void read_and_write_test_read_handler(grpc_exec_ctx *exec_ctx,
}
}
-static void read_and_write_test_write_handler(grpc_exec_ctx *exec_ctx,
- 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(grpc_exec_ctx* exec_ctx,
+ void* data, grpc_error* error) {
+ struct read_and_write_test_state* state =
+ (struct read_and_write_test_state*)data;
+ grpc_slice* slices = nullptr;
size_t nslices;
if (error == GRPC_ERROR_NONE) {
@@ -164,7 +164,7 @@ static void read_and_write_test_write_handler(grpc_exec_ctx *exec_ctx,
gpr_mu_lock(g_mu);
state->write_done = 1 + (error == GRPC_ERROR_NONE);
GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, g_pollset, NULL));
+ grpc_pollset_kick(exec_ctx, g_pollset, nullptr));
gpr_mu_unlock(g_mu);
}
@@ -181,15 +181,17 @@ static void read_and_write_test(grpc_endpoint_test_config config,
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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);
}
@@ -235,7 +237,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 = nullptr;
GPR_ASSERT(grpc_exec_ctx_now(&exec_ctx) < deadline);
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
@@ -252,16 +254,16 @@ static void read_and_write_test(grpc_endpoint_test_config config,
grpc_exec_ctx_finish(&exec_ctx);
}
-static void inc_on_failure(grpc_exec_ctx *exec_ctx, void *arg,
- grpc_error *error) {
+static void inc_on_failure(grpc_exec_ctx* exec_ctx, void* arg,
+ grpc_error* error) {
gpr_mu_lock(g_mu);
- *(int *)arg += (error != GRPC_ERROR_NONE);
- GPR_ASSERT(
- GRPC_LOG_IF_ERROR("kick", grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+ *(int*)arg += (error != GRPC_ERROR_NONE);
+ GPR_ASSERT(GRPC_LOG_IF_ERROR(
+ "kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
gpr_mu_unlock(g_mu);
}
-static void wait_for_fail_count(grpc_exec_ctx *exec_ctx, int *fail_count,
+static void wait_for_fail_count(grpc_exec_ctx* exec_ctx, int* fail_count,
int want_fail_count) {
grpc_exec_ctx_flush(exec_ctx);
gpr_mu_lock(g_mu);
@@ -269,7 +271,7 @@ static void wait_for_fail_count(grpc_exec_ctx *exec_ctx, int *fail_count,
grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(10));
while (grpc_exec_ctx_now(exec_ctx) < deadline &&
*fail_count < want_fail_count) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = nullptr;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(exec_ctx, g_pollset, &worker, deadline)));
@@ -319,7 +321,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;
@@ -330,6 +332,6 @@ void grpc_endpoint_tests(grpc_endpoint_test_config config,
for (i = 1; i < 1000; i = GPR_MAX(i + 1, i * 5 / 4)) {
read_and_write_test(config, 40320, i, i, false);
}
- g_pollset = NULL;
- g_mu = NULL;
+ g_pollset = nullptr;
+ g_mu = nullptr;
}
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 37aadacd49..ac8b2f43d1 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(grpc_exec_ctx *exec_ctx, test_fd *tfds,
+static void test_fd_cleanup(grpc_exec_ctx* exec_ctx, test_fd* tfds,
int num_fds) {
int release_fd;
int i;
@@ -80,7 +80,7 @@ static void test_fd_cleanup(grpc_exec_ctx *exec_ctx, test_fd *tfds,
GRPC_ERROR_CREATE_FROM_STATIC_STRING("test_fd_cleanup"));
grpc_exec_ctx_flush(exec_ctx);
- grpc_fd_orphan(exec_ctx, tfds[i].fd, NULL, &release_fd,
+ grpc_fd_orphan(exec_ctx, tfds[i].fd, nullptr, &release_fd,
false /* already_closed */, "test_fd_cleanup");
grpc_exec_ctx_flush(exec_ctx);
@@ -89,21 +89,22 @@ static void test_fd_cleanup(grpc_exec_ctx *exec_ctx, test_fd *tfds,
}
}
-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(grpc_exec_ctx *exec_ctx, void *p,
- grpc_error *error) {
- grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+ grpc_error* error) {
+ grpc_pollset_destroy(exec_ctx, (grpc_pollset*)p);
}
-static void test_pollset_cleanup(grpc_exec_ctx *exec_ctx,
- test_pollset *pollsets, int num_pollsets) {
+static void test_pollset_cleanup(grpc_exec_ctx* exec_ctx,
+ test_pollset* pollsets, int num_pollsets) {
grpc_closure destroyed;
int i;
@@ -117,16 +118,16 @@ static void test_pollset_cleanup(grpc_exec_ctx *exec_ctx,
}
}
-/*
- * 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
@@ -136,7 +137,7 @@ static void test_add_fd_to_pollset() {
test_fd tfds[NUM_FDS];
int fds[NUM_FDS];
test_pollset pollsets[NUM_POLLSETS];
- void *expected_pi = NULL;
+ void* expected_pi = nullptr;
int i;
test_fd_init(tfds, fds, NUM_FDS);
@@ -221,21 +222,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) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_pollset_worker *worker;
+ grpc_pollset_worker* worker;
gpr_mu_lock(shared->mu);
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work", grpc_pollset_work(&exec_ctx, shared->pollset, &worker,
@@ -245,9 +246,9 @@ static void test_threading_loop(void *arg) {
}
}
-static void test_threading_wakeup(grpc_exec_ctx *exec_ctx, void *arg,
- grpc_error *error) {
- threading_shared *shared = arg;
+static void test_threading_wakeup(grpc_exec_ctx* exec_ctx, void* arg,
+ grpc_error* error) {
+ threading_shared* shared = static_cast<threading_shared*>(arg);
++shared->wakeups;
++thread_wakeups;
if (error == GRPC_ERROR_NONE) {
@@ -261,7 +262,7 @@ static void test_threading_wakeup(grpc_exec_ctx *exec_ctx, void *arg,
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];
@@ -294,7 +295,7 @@ static void test_threading(void) {
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_fd_shutdown(&exec_ctx, shared.wakeup_desc, GRPC_ERROR_CANCELLED);
- grpc_fd_orphan(&exec_ctx, shared.wakeup_desc, NULL, NULL,
+ grpc_fd_orphan(&exec_ctx, shared.wakeup_desc, nullptr, nullptr,
false /* already_closed */, "done");
grpc_pollset_shutdown(&exec_ctx, shared.pollset,
GRPC_CLOSURE_CREATE(destroy_pollset, shared.pollset,
@@ -304,14 +305,14 @@ 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 = nullptr;
grpc_test_init(argc, argv);
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
poll_strategy = grpc_get_poll_strategy_name();
- if (poll_strategy != NULL && strcmp(poll_strategy, "epollsig") == 0) {
+ if (poll_strategy != nullptr && strcmp(poll_strategy, "epollsig") == 0) {
test_add_fd_to_pollset();
test_threading();
} else {
@@ -325,6 +326,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 d29b1e8e41..f46430c611 100644
--- a/test/core/iomgr/fd_conservation_posix_test.c
+++ b/test/core/iomgr/fd_conservation_posix_test.cc
@@ -24,7 +24,7 @@
#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;
@@ -38,11 +38,11 @@ int main(int argc, char **argv) {
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++) {
- p = grpc_iomgr_create_endpoint_pair("test", NULL);
+ p = grpc_iomgr_create_endpoint_pair("test", nullptr);
grpc_endpoint_destroy(&exec_ctx, p.client);
grpc_endpoint_destroy(&exec_ctx, p.server);
grpc_exec_ctx_flush(&exec_ctx);
diff --git a/test/core/iomgr/fd_posix_test.c b/test/core/iomgr/fd_posix_test.cc
index 1c62f34d3e..a03d841ecd 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,20 +103,20 @@ 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(grpc_exec_ctx *exec_ctx, void *arg, /*session */
+static void session_shutdown_cb(grpc_exec_ctx* exec_ctx, void* arg, /*session */
bool success) {
- session *se = arg;
- server *sv = se->sv;
- grpc_fd_orphan(exec_ctx, se->em_fd, NULL, NULL, false /* already_closed */,
- "a");
+ session* se = static_cast<session*>(arg);
+ server* sv = se->sv;
+ grpc_fd_orphan(exec_ctx, se->em_fd, nullptr, nullptr,
+ false /* already_closed */, "a");
gpr_free(se);
/* Start to shutdown listen fd. */
grpc_fd_shutdown(exec_ctx, sv->em_fd,
@@ -124,9 +124,9 @@ static void session_shutdown_cb(grpc_exec_ctx *exec_ctx, void *arg, /*session */
}
/* Called when data become readable in a session. */
-static void session_read_cb(grpc_exec_ctx *exec_ctx, void *arg, /*session */
- grpc_error *error) {
- session *se = arg;
+static void session_read_cb(grpc_exec_ctx* exec_ctx, 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;
@@ -169,42 +169,42 @@ static void session_read_cb(grpc_exec_ctx *exec_ctx, 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(grpc_exec_ctx *exec_ctx, void *arg /*server */,
+static void listen_shutdown_cb(grpc_exec_ctx* exec_ctx, void* arg /*server */,
int success) {
- server *sv = arg;
+ server* sv = static_cast<server*>(arg);
- grpc_fd_orphan(exec_ctx, sv->em_fd, NULL, NULL, false /* already_closed */,
- "b");
+ grpc_fd_orphan(exec_ctx, sv->em_fd, nullptr, nullptr,
+ false /* already_closed */, "b");
gpr_mu_lock(g_mu);
sv->done = 1;
- GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+ GPR_ASSERT(GRPC_LOG_IF_ERROR(
+ "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
gpr_mu_unlock(g_mu);
}
/* Called when a new TCP connection request arrives in the listening port. */
-static void listen_cb(grpc_exec_ctx *exec_ctx, void *arg, /*=sv_arg*/
- grpc_error *error) {
- server *sv = arg;
+static void listen_cb(grpc_exec_ctx* exec_ctx, 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(exec_ctx, 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(exec_ctx, g_pollset, se->em_fd);
@@ -222,7 +222,7 @@ static void listen_cb(grpc_exec_ctx *exec_ctx, 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(grpc_exec_ctx *exec_ctx, server *sv) {
+static int server_start(grpc_exec_ctx* exec_ctx, server* sv) {
int port = 0;
int fd;
struct sockaddr_in sin;
@@ -230,8 +230,8 @@ static int server_start(grpc_exec_ctx *exec_ctx, 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);
@@ -246,11 +246,11 @@ static int server_start(grpc_exec_ctx *exec_ctx, 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) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = nullptr;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work", grpc_pollset_work(&exec_ctx, g_pollset, &worker,
GRPC_MILLIS_INF_FUTURE)));
@@ -270,7 +270,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
@@ -281,7 +281,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;
@@ -289,20 +289,20 @@ static void client_init(client *cl) {
}
/* Called when a client upload session is ready to shutdown. */
-static void client_session_shutdown_cb(grpc_exec_ctx *exec_ctx,
- void *arg /*client */, int success) {
- client *cl = arg;
- grpc_fd_orphan(exec_ctx, cl->em_fd, NULL, NULL, false /* already_closed */,
- "c");
+static void client_session_shutdown_cb(grpc_exec_ctx* exec_ctx,
+ void* arg /*client */, int success) {
+ client* cl = static_cast<client*>(arg);
+ grpc_fd_orphan(exec_ctx, cl->em_fd, nullptr, nullptr,
+ false /* already_closed */, "c");
cl->done = 1;
- GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+ GPR_ASSERT(GRPC_LOG_IF_ERROR(
+ "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
}
/* Write as much as possible, then register notify_on_write. */
-static void client_session_write(grpc_exec_ctx *exec_ctx, void *arg, /*client */
- grpc_error *error) {
- client *cl = arg;
+static void client_session_write(grpc_exec_ctx* exec_ctx, 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;
@@ -336,11 +336,11 @@ static void client_session_write(grpc_exec_ctx *exec_ctx, void *arg, /*client */
}
/* Start a client to send a stream of bytes. */
-static void client_start(grpc_exec_ctx *exec_ctx, client *cl, int port) {
+static void client_start(grpc_exec_ctx* exec_ctx, 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;
@@ -363,10 +363,10 @@ static void client_start(grpc_exec_ctx *exec_ctx, 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;
+ grpc_pollset_worker* worker = nullptr;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work", grpc_pollset_work(&exec_ctx, g_pollset, &worker,
@@ -402,31 +402,31 @@ 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 = nullptr; }
-void destroy_change_data(fd_change_data *fdc) {}
+void destroy_change_data(fd_change_data* fdc) {}
-static void first_read_callback(grpc_exec_ctx *exec_ctx,
- void *arg /* fd_change_data */,
- grpc_error *error) {
- fd_change_data *fdc = arg;
+static void first_read_callback(grpc_exec_ctx* exec_ctx,
+ 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;
- GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+ GPR_ASSERT(GRPC_LOG_IF_ERROR(
+ "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
gpr_mu_unlock(g_mu);
}
-static void second_read_callback(grpc_exec_ctx *exec_ctx,
- void *arg /* fd_change_data */,
- grpc_error *error) {
- fd_change_data *fdc = arg;
+static void second_read_callback(grpc_exec_ctx* exec_ctx,
+ 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;
- GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+ GPR_ASSERT(GRPC_LOG_IF_ERROR(
+ "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
gpr_mu_unlock(g_mu);
}
@@ -435,7 +435,7 @@ static void second_read_callback(grpc_exec_ctx *exec_ctx,
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];
@@ -470,8 +470,8 @@ 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;
+ while (a.cb_that_ran == nullptr) {
+ grpc_pollset_worker* worker = nullptr;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work", grpc_pollset_work(&exec_ctx, g_pollset, &worker,
GRPC_MILLIS_INF_FUTURE)));
@@ -494,8 +494,8 @@ static void test_grpc_fd_change(void) {
GPR_ASSERT(result == 1);
gpr_mu_lock(g_mu);
- while (b.cb_that_ran == NULL) {
- grpc_pollset_worker *worker = NULL;
+ while (b.cb_that_ran == nullptr) {
+ grpc_pollset_worker* worker = nullptr;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work", grpc_pollset_work(&exec_ctx, g_pollset, &worker,
GRPC_MILLIS_INF_FUTURE)));
@@ -507,24 +507,25 @@ static void test_grpc_fd_change(void) {
GPR_ASSERT(b.cb_that_ran == second_read_callback);
gpr_mu_unlock(g_mu);
- grpc_fd_orphan(&exec_ctx, em_fd, NULL, NULL, false /* already_closed */, "d");
+ grpc_fd_orphan(&exec_ctx, em_fd, nullptr, nullptr, false /* already_closed */,
+ "d");
grpc_exec_ctx_finish(&exec_ctx);
destroy_change_data(&a);
destroy_change_data(&b);
close(sv[1]);
}
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
- grpc_error *error) {
- grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+ grpc_error* error) {
+ grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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();
@@ -540,6 +541,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..9f360badcc 100644
--- a/test/core/iomgr/load_file_test.c
+++ b/test/core/iomgr/load_file_test.cc
@@ -33,17 +33,17 @@
static const char prefix[] = "file_test";
static void test_load_empty_file(void) {
- FILE *tmp = NULL;
+ FILE* tmp = nullptr;
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");
tmp = gpr_tmpfile(prefix, &tmp_name);
- GPR_ASSERT(tmp_name != NULL);
- GPR_ASSERT(tmp != NULL);
+ GPR_ASSERT(tmp_name != nullptr);
+ GPR_ASSERT(tmp != nullptr);
fclose(tmp);
error = grpc_load_file(tmp_name, 0, &slice);
@@ -62,16 +62,16 @@ static void test_load_empty_file(void) {
}
static void test_load_failure(void) {
- FILE *tmp = NULL;
+ FILE* tmp = nullptr;
grpc_slice slice;
- grpc_error *error;
- char *tmp_name;
+ grpc_error* error;
+ char* tmp_name;
LOG_TEST_NAME("test_load_failure");
tmp = gpr_tmpfile(prefix, &tmp_name);
- GPR_ASSERT(tmp_name != NULL);
- GPR_ASSERT(tmp != NULL);
+ GPR_ASSERT(tmp_name != nullptr);
+ GPR_ASSERT(tmp != nullptr);
fclose(tmp);
remove(tmp_name);
@@ -84,18 +84,18 @@ static void test_load_failure(void) {
}
static void test_load_small_file(void) {
- FILE *tmp = NULL;
+ FILE* tmp = nullptr;
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");
tmp = gpr_tmpfile(prefix, &tmp_name);
- GPR_ASSERT(tmp_name != NULL);
- GPR_ASSERT(tmp != NULL);
+ GPR_ASSERT(tmp_name != nullptr);
+ GPR_ASSERT(tmp != nullptr);
GPR_ASSERT(fwrite(blah, 1, strlen(blah), tmp) == strlen(blah));
fclose(tmp);
@@ -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 = nullptr;
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");
@@ -131,8 +131,8 @@ static void test_load_big_file(void) {
memset(buffer, 42, buffer_size);
tmp = gpr_tmpfile(prefix, &tmp_name);
- GPR_ASSERT(tmp != NULL);
- GPR_ASSERT(tmp_name != NULL);
+ GPR_ASSERT(tmp != nullptr);
+ GPR_ASSERT(tmp_name != nullptr);
GPR_ASSERT(fwrite(buffer, 1, buffer_size, tmp) == buffer_size);
fclose(tmp);
@@ -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 cddc146ce0..719eab91fe 100644
--- a/test/core/iomgr/pollset_set_test.c
+++ b/test/core/iomgr/pollset_set_test.cc
@@ -37,20 +37,22 @@
* 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(grpc_exec_ctx *exec_ctx,
- test_pollset_set *pollset_sets,
+void cleanup_test_pollset_sets(grpc_exec_ctx* exec_ctx,
+ test_pollset_set* pollset_sets,
const int num_pss) {
for (int i = 0; i < num_pss; i++) {
grpc_pollset_set_destroy(exec_ctx, pollset_sets[i].pss);
- pollset_sets[i].pss = NULL;
+ pollset_sets[i].pss = nullptr;
}
}
@@ -59,24 +61,25 @@ void cleanup_test_pollset_sets(grpc_exec_ctx *exec_ctx,
*/
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(grpc_exec_ctx *exec_ctx, void *p,
- grpc_error *error) {
- grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+ grpc_error* error) {
+ grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
}
-static void cleanup_test_pollsets(grpc_exec_ctx *exec_ctx,
- test_pollset *pollsets,
+static void cleanup_test_pollsets(grpc_exec_ctx* exec_ctx,
+ test_pollset* pollsets,
const int num_pollsets) {
grpc_closure destroyed;
for (int i = 0; i < num_pollsets; i++) {
@@ -86,7 +89,7 @@ static void cleanup_test_pollsets(grpc_exec_ctx *exec_ctx,
grpc_exec_ctx_flush(exec_ctx);
gpr_free(pollsets[i].ps);
- pollsets[i].ps = NULL;
+ pollsets[i].ps = nullptr;
}
}
@@ -95,18 +98,18 @@ static void cleanup_test_pollsets(grpc_exec_ctx *exec_ctx,
*/
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(grpc_exec_ctx *exec_ctx, void *tfd, grpc_error *error) {
- ((test_fd *)tfd)->is_on_readable_called = true;
+void on_readable(grpc_exec_ctx* exec_ctx, void* tfd, grpc_error* error) {
+ ((test_fd*)tfd)->is_on_readable_called = true;
}
-static void reset_test_fd(grpc_exec_ctx *exec_ctx, test_fd *tfd) {
+static void reset_test_fd(grpc_exec_ctx* exec_ctx, test_fd* tfd) {
tfd->is_on_readable_called = false;
GRPC_CLOSURE_INIT(&tfd->on_readable, on_readable, tfd,
@@ -114,7 +117,7 @@ static void reset_test_fd(grpc_exec_ctx *exec_ctx, test_fd *tfd) {
grpc_fd_notify_on_read(exec_ctx, tfd->fd, &tfd->on_readable);
}
-static void init_test_fds(grpc_exec_ctx *exec_ctx, test_fd *tfds,
+static void init_test_fds(grpc_exec_ctx* exec_ctx, 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));
@@ -124,7 +127,7 @@ static void init_test_fds(grpc_exec_ctx *exec_ctx, test_fd *tfds,
}
}
-static void cleanup_test_fds(grpc_exec_ctx *exec_ctx, test_fd *tfds,
+static void cleanup_test_fds(grpc_exec_ctx* exec_ctx, test_fd* tfds,
const int num_fds) {
int release_fd;
@@ -138,7 +141,7 @@ static void cleanup_test_fds(grpc_exec_ctx *exec_ctx, test_fd *tfds,
* grpc_wakeup_fd and we would like to destroy it ourselves (by calling
* grpc_wakeup_fd_destroy). To prevent grpc_fd from calling close() on the
* underlying fd, call it with a non-NULL 'release_fd' parameter */
- grpc_fd_orphan(exec_ctx, tfds[i].fd, NULL, &release_fd,
+ grpc_fd_orphan(exec_ctx, tfds[i].fd, nullptr, &release_fd,
false /* already_closed */, "test_fd_cleanup");
grpc_exec_ctx_flush(exec_ctx);
@@ -146,13 +149,13 @@ static void cleanup_test_fds(grpc_exec_ctx *exec_ctx, test_fd *tfds,
}
}
-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(grpc_exec_ctx *exec_ctx, test_fd *tfds,
+static void verify_readable_and_reset(grpc_exec_ctx* exec_ctx, test_fd* tfds,
const int num_fds) {
for (int i = 0; i < num_fds; i++) {
/* Verify that the on_readable callback was called */
@@ -203,7 +206,7 @@ static void pollset_set_test_basic() {
* +---> FD9 (Added after PS2 is added to PSS0)
*/
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_pollset_worker *worker;
+ grpc_pollset_worker* worker;
grpc_millis deadline;
test_fd tfds[10];
@@ -308,7 +311,7 @@ void pollset_set_test_dup_fds() {
* +---> FD1
*/
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_pollset_worker *worker;
+ grpc_pollset_worker* worker;
grpc_millis deadline;
test_fd tfds[3];
@@ -381,7 +384,7 @@ void pollset_set_test_empty_pollset() {
* +---> FD2
*/
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_pollset_worker *worker;
+ grpc_pollset_worker* worker;
grpc_millis deadline;
test_fd tfds[3];
@@ -430,13 +433,13 @@ void pollset_set_test_empty_pollset() {
grpc_exec_ctx_finish(&exec_ctx);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_test_init(argc, argv);
grpc_init();
- const char *poll_strategy = grpc_get_poll_strategy_name();
+ const char* poll_strategy = grpc_get_poll_strategy_name();
- if (poll_strategy != NULL &&
+ if (poll_strategy != nullptr &&
(strcmp(poll_strategy, "epollsig") == 0 ||
strcmp(poll_strategy, "epoll-threadpool") == 0)) {
pollset_set_test_basic();
@@ -453,6 +456,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/resolve_address_posix_test.c b/test/core/iomgr/resolve_address_posix_test.cc
index cb9d6080fb..1a5eb9ace1 100644
--- a/test/core/iomgr/resolve_address_posix_test.c
+++ b/test/core/iomgr/resolve_address_posix_test.cc
@@ -39,31 +39,31 @@ 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(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {}
+static void do_nothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
-void args_init(grpc_exec_ctx *exec_ctx, args_struct *args) {
+void args_init(grpc_exec_ctx* exec_ctx, 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(exec_ctx, args->pollset_set, args->pollset);
- args->addrs = NULL;
+ args->addrs = nullptr;
}
-void args_finish(grpc_exec_ctx *exec_ctx, args_struct *args) {
+void args_finish(grpc_exec_ctx* exec_ctx, args_struct* args) {
GPR_ASSERT(gpr_event_wait(&args->ev, test_deadline()));
grpc_resolved_addresses_destroy(args->addrs);
grpc_pollset_set_del_pollset(exec_ctx, args->pollset_set, args->pollset);
grpc_pollset_set_destroy(exec_ctx, args->pollset_set);
grpc_closure do_nothing_cb;
- GRPC_CLOSURE_INIT(&do_nothing_cb, do_nothing, NULL,
+ GRPC_CLOSURE_INIT(&do_nothing_cb, do_nothing, nullptr,
grpc_schedule_on_exec_ctx);
grpc_pollset_shutdown(exec_ctx, args->pollset, &do_nothing_cb);
// exec_ctx needs to be flushed before calling grpc_pollset_destroy()
@@ -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);
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_millis deadline = n_sec_deadline(10);
while (true) {
@@ -89,7 +89,7 @@ static void actually_poll(void *argsp) {
grpc_millis time_left = deadline - grpc_exec_ctx_now(&exec_ctx);
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 = nullptr;
gpr_mu_lock(args->mu);
GRPC_LOG_IF_ERROR("pollset_work",
grpc_pollset_work(&exec_ctx, args->pollset, &worker,
@@ -97,27 +97,27 @@ static void actually_poll(void *argsp) {
gpr_mu_unlock(args->mu);
grpc_exec_ctx_flush(&exec_ctx);
}
- gpr_event_set(&args->ev, (void *)1);
+ gpr_event_set(&args->ev, (void*)1);
grpc_exec_ctx_finish(&exec_ctx);
}
-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);
+ gpr_thd_new(&id, actually_poll, args, nullptr);
}
-static void must_succeed(grpc_exec_ctx *exec_ctx, void *argsp,
- grpc_error *err) {
- args_struct *args = argsp;
+static void must_succeed(grpc_exec_ctx* exec_ctx, 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 != nullptr);
GPR_ASSERT(args->addrs->naddrs > 0);
gpr_atm_rel_store(&args->done_atm, 1);
}
-static void must_fail(grpc_exec_ctx *exec_ctx, void *argsp, grpc_error *err) {
- args_struct *args = argsp;
+static void must_fail(grpc_exec_ctx* exec_ctx, 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);
}
@@ -128,7 +128,7 @@ static void test_unix_socket(void) {
args_init(&exec_ctx, &args);
poll_pollset_until_request_done(&args);
grpc_resolve_address(
- &exec_ctx, "unix:/path/name", NULL, args.pollset_set,
+ &exec_ctx, "unix:/path/name", nullptr, args.pollset_set,
GRPC_CLOSURE_CREATE(must_succeed, &args, grpc_schedule_on_exec_ctx),
&args.addrs);
args_finish(&exec_ctx, &args);
@@ -141,15 +141,16 @@ static void test_unix_socket_path_name_too_long(void) {
args_init(&exec_ctx, &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*)nullptr)->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';
poll_pollset_until_request_done(&args);
grpc_resolve_address(
- &exec_ctx, path_name, NULL, args.pollset_set,
+ &exec_ctx, path_name, nullptr, args.pollset_set,
GRPC_CLOSURE_CREATE(must_fail, &args, grpc_schedule_on_exec_ctx),
&args.addrs);
gpr_free(path_name);
@@ -157,7 +158,7 @@ static void test_unix_socket_path_name_too_long(void) {
grpc_exec_ctx_finish(&exec_ctx);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
diff --git a/test/core/iomgr/resolve_address_test.c b/test/core/iomgr/resolve_address_test.cc
index 178bbbb95f..1c5aa38a95 100644
--- a/test/core/iomgr/resolve_address_test.c
+++ b/test/core/iomgr/resolve_address_test.cc
@@ -32,32 +32,32 @@ 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(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {}
+static void do_nothing(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {}
-void args_init(grpc_exec_ctx *exec_ctx, args_struct *args) {
+void args_init(grpc_exec_ctx* exec_ctx, 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(exec_ctx, args->pollset_set, args->pollset);
- args->addrs = NULL;
+ args->addrs = nullptr;
gpr_atm_rel_store(&args->done_atm, 0);
}
-void args_finish(grpc_exec_ctx *exec_ctx, args_struct *args) {
+void args_finish(grpc_exec_ctx* exec_ctx, args_struct* args) {
GPR_ASSERT(gpr_event_wait(&args->ev, test_deadline()));
grpc_resolved_addresses_destroy(args->addrs);
grpc_pollset_set_del_pollset(exec_ctx, args->pollset_set, args->pollset);
grpc_pollset_set_destroy(exec_ctx, args->pollset_set);
grpc_closure do_nothing_cb;
- GRPC_CLOSURE_INIT(&do_nothing_cb, do_nothing, NULL,
+ GRPC_CLOSURE_INIT(&do_nothing_cb, do_nothing, nullptr,
grpc_schedule_on_exec_ctx);
gpr_mu_lock(args->mu);
grpc_pollset_shutdown(exec_ctx, args->pollset, &do_nothing_cb);
@@ -73,7 +73,7 @@ static grpc_millis n_sec_deadline(int seconds) {
grpc_timeout_seconds_to_deadline(seconds));
}
-static void poll_pollset_until_request_done(args_struct *args) {
+static void poll_pollset_until_request_done(args_struct* args) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_millis deadline = n_sec_deadline(10);
while (true) {
@@ -84,7 +84,7 @@ static void poll_pollset_until_request_done(args_struct *args) {
grpc_millis time_left = deadline - grpc_exec_ctx_now(&exec_ctx);
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 = nullptr;
gpr_mu_lock(args->mu);
GRPC_LOG_IF_ERROR("pollset_work",
grpc_pollset_work(&exec_ctx, args->pollset, &worker,
@@ -92,30 +92,30 @@ static void poll_pollset_until_request_done(args_struct *args) {
gpr_mu_unlock(args->mu);
grpc_exec_ctx_flush(&exec_ctx);
}
- gpr_event_set(&args->ev, (void *)1);
+ gpr_event_set(&args->ev, (void*)1);
grpc_exec_ctx_finish(&exec_ctx);
}
-static void must_succeed(grpc_exec_ctx *exec_ctx, void *argsp,
- grpc_error *err) {
- args_struct *args = argsp;
+static void must_succeed(grpc_exec_ctx* exec_ctx, 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 != nullptr);
GPR_ASSERT(args->addrs->naddrs > 0);
gpr_atm_rel_store(&args->done_atm, 1);
gpr_mu_lock(args->mu);
GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, args->pollset, NULL));
+ grpc_pollset_kick(exec_ctx, args->pollset, nullptr));
gpr_mu_unlock(args->mu);
}
-static void must_fail(grpc_exec_ctx *exec_ctx, void *argsp, grpc_error *err) {
- args_struct *args = argsp;
+static void must_fail(grpc_exec_ctx* exec_ctx, 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);
GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, args->pollset, NULL));
+ grpc_pollset_kick(exec_ctx, args->pollset, nullptr));
gpr_mu_unlock(args->mu);
}
@@ -124,7 +124,7 @@ static void test_localhost(void) {
args_struct args;
args_init(&exec_ctx, &args);
grpc_resolve_address(
- &exec_ctx, "localhost:1", NULL, args.pollset_set,
+ &exec_ctx, "localhost:1", nullptr, args.pollset_set,
GRPC_CLOSURE_CREATE(must_succeed, &args, grpc_schedule_on_exec_ctx),
&args.addrs);
grpc_exec_ctx_flush(&exec_ctx);
@@ -166,7 +166,7 @@ static void test_missing_default_port(void) {
args_struct args;
args_init(&exec_ctx, &args);
grpc_resolve_address(
- &exec_ctx, "localhost", NULL, args.pollset_set,
+ &exec_ctx, "localhost", nullptr, args.pollset_set,
GRPC_CLOSURE_CREATE(must_fail, &args, grpc_schedule_on_exec_ctx),
&args.addrs);
grpc_exec_ctx_flush(&exec_ctx);
@@ -180,7 +180,7 @@ static void test_ipv6_with_port(void) {
args_struct args;
args_init(&exec_ctx, &args);
grpc_resolve_address(
- &exec_ctx, "[2001:db8::1]:1", NULL, args.pollset_set,
+ &exec_ctx, "[2001:db8::1]:1", nullptr, args.pollset_set,
GRPC_CLOSURE_CREATE(must_succeed, &args, grpc_schedule_on_exec_ctx),
&args.addrs);
grpc_exec_ctx_flush(&exec_ctx);
@@ -190,8 +190,10 @@ 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++) {
@@ -210,8 +212,9 @@ 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++) {
@@ -219,7 +222,7 @@ static void test_invalid_ip_addresses(void) {
args_struct args;
args_init(&exec_ctx, &args);
grpc_resolve_address(
- &exec_ctx, kCases[i], NULL, args.pollset_set,
+ &exec_ctx, kCases[i], nullptr, args.pollset_set,
GRPC_CLOSURE_CREATE(must_fail, &args, grpc_schedule_on_exec_ctx),
&args.addrs);
grpc_exec_ctx_flush(&exec_ctx);
@@ -230,7 +233,7 @@ 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;
@@ -249,7 +252,7 @@ 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();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
diff --git a/test/core/iomgr/resource_quota_test.c b/test/core/iomgr/resource_quota_test.cc
index b588f3d120..6851702e67 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(grpc_exec_ctx *exec_ctx, void *a, grpc_error *error) {
+static void inc_int_cb(grpc_exec_ctx* exec_ctx, 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,47 +43,49 @@ static void assert_counter_becomes(int *ctr, int value) {
gpr_mu_unlock(&g_mu);
}
-static void set_event_cb(grpc_exec_ctx *exec_ctx, void *a, grpc_error *error) {
- gpr_event_set((gpr_event *)a, (void *)1);
+static void set_event_cb(grpc_exec_ctx* exec_ctx, 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(grpc_exec_ctx *exec_ctx, void *args,
- grpc_error *error) {
+
+static void reclaimer_cb(grpc_exec_ctx* exec_ctx, 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(exec_ctx, a->resource_user, a->size);
grpc_resource_user_finish_reclamation(exec_ctx, a->resource_user);
GRPC_CLOSURE_RUN(exec_ctx, 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(grpc_exec_ctx *exec_ctx, void *arg,
- grpc_error *error) {
+static void unused_reclaimer_cb(grpc_exec_ctx* exec_ctx, void* arg,
+ grpc_error* error) {
GPR_ASSERT(error == GRPC_ERROR_CANCELLED);
- GRPC_CLOSURE_RUN(exec_ctx, arg, GRPC_ERROR_NONE);
+ GRPC_CLOSURE_RUN(exec_ctx, 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) {
+static void destroy_user(grpc_resource_user* usr) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_resource_user_unref(&exec_ctx, usr);
grpc_exec_ctx_finish(&exec_ctx);
@@ -96,7 +98,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);
@@ -104,22 +106,22 @@ 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");
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_resource_user_alloc(&exec_ctx, usr, 1024, NULL);
+ grpc_resource_user_alloc(&exec_ctx, usr, 1024, nullptr);
grpc_exec_ctx_finish(&exec_ctx);
}
{
@@ -133,13 +135,13 @@ 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");
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_resource_user_alloc(&exec_ctx, usr, 1024, NULL);
+ grpc_resource_user_alloc(&exec_ctx, usr, 1024, nullptr);
grpc_resource_user_free(&exec_ctx, usr, 1024);
grpc_exec_ctx_finish(&exec_ctx);
}
@@ -149,10 +151,10 @@ 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);
@@ -160,7 +162,7 @@ static void test_simple_async_alloc(void) {
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
}
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -173,10 +175,10 @@ 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);
{
@@ -184,10 +186,11 @@ static void test_async_alloc_blocked_by_size(void) {
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(
- &ev, grpc_timeout_milliseconds_to_deadline(100)) == NULL);
+ &ev, grpc_timeout_milliseconds_to_deadline(100)) == nullptr);
}
grpc_resource_quota_resize(q, 1024);
- GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) != NULL);
+ GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
+ nullptr);
;
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -200,10 +203,10 @@ 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);
@@ -211,7 +214,7 @@ static void test_scavenge(void) {
grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
{
@@ -226,7 +229,7 @@ static void test_scavenge(void) {
grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
{
@@ -241,10 +244,10 @@ 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);
@@ -252,7 +255,7 @@ static void test_scavenge_blocked(void) {
grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
{
@@ -261,14 +264,14 @@ static void test_scavenge_blocked(void) {
grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(
- &ev, grpc_timeout_milliseconds_to_deadline(100)) == NULL);
+ &ev, grpc_timeout_milliseconds_to_deadline(100)) == nullptr);
}
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_resource_user_free(&exec_ctx, usr1, 1024);
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
{
@@ -283,10 +286,10 @@ 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);
@@ -294,7 +297,7 @@ static void test_blocked_until_scheduled_reclaim(void) {
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
gpr_event reclaim_done;
@@ -313,9 +316,9 @@ static void test_blocked_until_scheduled_reclaim(void) {
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&reclaim_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
{
@@ -329,11 +332,11 @@ 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);
@@ -341,7 +344,7 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
grpc_resource_user_alloc(&exec_ctx, usr1, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
gpr_event reclaim_done;
@@ -360,9 +363,9 @@ static void test_blocked_until_scheduled_reclaim_and_scavenge(void) {
grpc_resource_user_alloc(&exec_ctx, usr2, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&reclaim_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
{
@@ -377,10 +380,10 @@ 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);
@@ -388,7 +391,7 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
gpr_event reclaim_done;
@@ -407,9 +410,9 @@ static void test_blocked_until_scheduled_destructive_reclaim(void) {
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&reclaim_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
{
@@ -423,10 +426,10 @@ 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;
@@ -441,25 +444,25 @@ static void test_unused_reclaim_is_cancelled(void) {
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&benign_done,
grpc_timeout_milliseconds_to_deadline(100)) ==
- NULL);
+ nullptr);
GPR_ASSERT(gpr_event_wait(&destructive_done,
grpc_timeout_milliseconds_to_deadline(100)) ==
- NULL);
+ nullptr);
}
grpc_resource_quota_unref(q);
destroy_user(usr);
GPR_ASSERT(gpr_event_wait(&benign_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
GPR_ASSERT(gpr_event_wait(&destructive_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
}
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;
@@ -471,7 +474,7 @@ static void test_benign_reclaim_is_preferred(void) {
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
{
@@ -485,10 +488,10 @@ static void test_benign_reclaim_is_preferred(void) {
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&benign_done,
grpc_timeout_milliseconds_to_deadline(100)) ==
- NULL);
+ nullptr);
GPR_ASSERT(gpr_event_wait(&destructive_done,
grpc_timeout_milliseconds_to_deadline(100)) ==
- NULL);
+ nullptr);
}
{
gpr_event ev;
@@ -497,12 +500,12 @@ static void test_benign_reclaim_is_preferred(void) {
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&benign_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
GPR_ASSERT(gpr_event_wait(&destructive_done,
grpc_timeout_milliseconds_to_deadline(100)) ==
- NULL);
+ nullptr);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
}
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -512,17 +515,17 @@ static void test_benign_reclaim_is_preferred(void) {
grpc_resource_quota_unref(q);
destroy_user(usr);
GPR_ASSERT(gpr_event_wait(&benign_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
GPR_ASSERT(gpr_event_wait(&destructive_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
}
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;
@@ -534,7 +537,7 @@ static void test_multiple_reclaims_can_be_triggered(void) {
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
{
@@ -548,10 +551,10 @@ static void test_multiple_reclaims_can_be_triggered(void) {
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&benign_done,
grpc_timeout_milliseconds_to_deadline(100)) ==
- NULL);
+ nullptr);
GPR_ASSERT(gpr_event_wait(&destructive_done,
grpc_timeout_milliseconds_to_deadline(100)) ==
- NULL);
+ nullptr);
}
{
gpr_event ev;
@@ -560,11 +563,11 @@ static void test_multiple_reclaims_can_be_triggered(void) {
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&ev));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&benign_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
GPR_ASSERT(gpr_event_wait(&destructive_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
GPR_ASSERT(gpr_event_wait(&ev, grpc_timeout_seconds_to_deadline(5)) !=
- NULL);
+ nullptr);
;
}
{
@@ -575,21 +578,21 @@ static void test_multiple_reclaims_can_be_triggered(void) {
grpc_resource_quota_unref(q);
destroy_user(usr);
GPR_ASSERT(gpr_event_wait(&benign_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
GPR_ASSERT(gpr_event_wait(&destructive_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
}
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");
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_resource_user_alloc(&exec_ctx, usr, 1024, NULL);
+ grpc_resource_user_alloc(&exec_ctx, usr, 1024, nullptr);
grpc_exec_ctx_finish(&exec_ctx);
}
{
@@ -612,12 +615,12 @@ 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);
{
@@ -628,7 +631,7 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
grpc_timeout_milliseconds_to_deadline(100)) ==
- NULL);
+ nullptr);
}
{
gpr_event allocated;
@@ -636,11 +639,11 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&allocated));
grpc_exec_ctx_finish(&exec_ctx);
- GPR_ASSERT(gpr_event_wait(&allocated,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ GPR_ASSERT(gpr_event_wait(&allocated, grpc_timeout_seconds_to_deadline(
+ 5)) != nullptr);
GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
grpc_timeout_milliseconds_to_deadline(100)) ==
- NULL);
+ nullptr);
}
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -648,14 +651,15 @@ test_resource_user_stays_allocated_and_reclaimers_unrun_until_memory_released(
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
grpc_timeout_milliseconds_to_deadline(100)) ==
- NULL);
+ nullptr);
}
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_resource_user_free(&exec_ctx, usr, 1024);
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&reclaimer_cancelled,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) !=
+ nullptr);
}
}
grpc_resource_quota_unref(q);
@@ -663,10 +667,10 @@ 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);
@@ -674,7 +678,7 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&allocated));
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&allocated,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
}
for (int i = 0; i < 10; i++) {
gpr_event reclaimer_done;
@@ -687,7 +691,7 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&reclaimer_done,
grpc_timeout_milliseconds_to_deadline(100)) ==
- NULL);
+ nullptr);
}
{
gpr_event allocated;
@@ -695,10 +699,11 @@ static void test_reclaimers_can_be_posted_repeatedly(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_resource_user_alloc(&exec_ctx, usr, 1024, set_event(&allocated));
grpc_exec_ctx_finish(&exec_ctx);
- GPR_ASSERT(gpr_event_wait(&allocated,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ GPR_ASSERT(gpr_event_wait(&allocated, grpc_timeout_seconds_to_deadline(
+ 5)) != nullptr);
GPR_ASSERT(gpr_event_wait(&reclaimer_done,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) !=
+ nullptr);
}
}
{
@@ -713,10 +718,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;
@@ -745,11 +750,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;
@@ -782,18 +787,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;
@@ -830,7 +835,7 @@ static void test_negative_rq_free_pool(void) {
}
}
-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..a445714851 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;
}
@@ -81,21 +81,21 @@ static void test_sockaddr_is_v4mapped(void) {
/* v4mapped input should succeed. */
input6 = make_addr6(kMapped, sizeof(kMapped));
- GPR_ASSERT(grpc_sockaddr_is_v4mapped(&input6, NULL));
+ GPR_ASSERT(grpc_sockaddr_is_v4mapped(&input6, nullptr));
GPR_ASSERT(grpc_sockaddr_is_v4mapped(&input6, &output4));
expect4 = make_addr4(kIPv4, sizeof(kIPv4));
GPR_ASSERT(memcmp(&expect4, &output4, sizeof(expect4)) == 0);
/* Non-v4mapped input should fail. */
input6 = make_addr6(kNotQuiteMapped, sizeof(kNotQuiteMapped));
- GPR_ASSERT(!grpc_sockaddr_is_v4mapped(&input6, NULL));
+ GPR_ASSERT(!grpc_sockaddr_is_v4mapped(&input6, nullptr));
GPR_ASSERT(!grpc_sockaddr_is_v4mapped(&input6, &output4));
/* Output is unchanged. */
GPR_ASSERT(memcmp(&expect4, &output4, sizeof(expect4)) == 0);
/* Plain IPv4 input should also fail. */
input4 = make_addr4(kIPv4, sizeof(kIPv4));
- GPR_ASSERT(!grpc_sockaddr_is_v4mapped(&input4, NULL));
+ GPR_ASSERT(!grpc_sockaddr_is_v4mapped(&input4, nullptr));
}
static void test_sockaddr_to_v4mapped(void) {
@@ -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,25 +170,25 @@ 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);
+ GPR_ASSERT(str != nullptr);
GPR_ASSERT(result >= 0);
GPR_ASSERT((size_t)result == strlen(str));
GPR_ASSERT(strcmp(expected, str) == 0);
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);
+ GPR_ASSERT(str != nullptr);
GPR_ASSERT(strcmp(expected, str) == 0);
gpr_free(str);
}
@@ -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,18 +234,18 @@ 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);
- GPR_ASSERT(grpc_sockaddr_to_uri(&dummy) == NULL);
+ GPR_ASSERT(grpc_sockaddr_to_uri(&dummy) == nullptr);
}
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 b8b76d1c42..9fb1a2d770 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 = nullptr;
static grpc_millis test_deadline(void) {
return grpc_timespec_to_millis_round_up(grpc_timeout_seconds_to_deadline(10));
@@ -54,33 +54,33 @@ static void finish_connection() {
gpr_mu_lock(g_mu);
g_connections_complete++;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(&exec_ctx, g_pollset, NULL)));
+ GPR_ASSERT(GRPC_LOG_IF_ERROR(
+ "pollset_kick", grpc_pollset_kick(&exec_ctx, g_pollset, nullptr)));
grpc_exec_ctx_finish(&exec_ctx);
gpr_mu_unlock(g_mu);
}
-static void must_succeed(grpc_exec_ctx *exec_ctx, void *arg,
- grpc_error *error) {
- GPR_ASSERT(g_connecting != NULL);
+static void must_succeed(grpc_exec_ctx* exec_ctx, void* arg,
+ grpc_error* error) {
+ GPR_ASSERT(g_connecting != nullptr);
GPR_ASSERT(error == GRPC_ERROR_NONE);
grpc_endpoint_shutdown(
exec_ctx, g_connecting,
GRPC_ERROR_CREATE_FROM_STATIC_STRING("must_succeed called"));
grpc_endpoint_destroy(exec_ctx, g_connecting);
- g_connecting = NULL;
+ g_connecting = nullptr;
finish_connection();
}
-static void must_fail(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
- GPR_ASSERT(g_connecting == NULL);
+static void must_fail(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+ GPR_ASSERT(g_connecting == nullptr);
GPR_ASSERT(error != GRPC_ERROR_NONE);
finish_connection();
}
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;
@@ -97,7 +97,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);
@@ -105,17 +105,16 @@ 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);
- GRPC_CLOSURE_INIT(&done, must_succeed, NULL, grpc_schedule_on_exec_ctx);
- grpc_tcp_client_connect(&exec_ctx, &done, &g_connecting, g_pollset_set, NULL,
- &resolved_addr, GRPC_MILLIS_INF_FUTURE);
+ GPR_ASSERT(getsockname(svr_fd, (struct sockaddr*)addr,
+ (socklen_t*)&resolved_addr.len) == 0);
+ GRPC_CLOSURE_INIT(&done, must_succeed, nullptr, grpc_schedule_on_exec_ctx);
+ grpc_tcp_client_connect(&exec_ctx, &done, &g_connecting, g_pollset_set,
+ nullptr, &resolved_addr, GRPC_MILLIS_INF_FUTURE);
/* 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);
@@ -123,7 +122,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 = nullptr;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(&exec_ctx, g_pollset, &worker,
@@ -141,7 +140,7 @@ 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;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -157,15 +156,15 @@ void test_fails(void) {
gpr_mu_unlock(g_mu);
/* connect to a broken address */
- GRPC_CLOSURE_INIT(&done, must_fail, NULL, grpc_schedule_on_exec_ctx);
- grpc_tcp_client_connect(&exec_ctx, &done, &g_connecting, g_pollset_set, NULL,
- &resolved_addr, GRPC_MILLIS_INF_FUTURE);
+ GRPC_CLOSURE_INIT(&done, must_fail, nullptr, grpc_schedule_on_exec_ctx);
+ grpc_tcp_client_connect(&exec_ctx, &done, &g_connecting, g_pollset_set,
+ nullptr, &resolved_addr, GRPC_MILLIS_INF_FUTURE);
gpr_mu_lock(g_mu);
/* wait for the connection callback to finish */
while (g_connections_complete == connections_complete_before) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = nullptr;
grpc_millis polling_deadline = test_deadline();
switch (grpc_timer_check(&exec_ctx, &polling_deadline)) {
case GRPC_TIMERS_FIRED:
@@ -188,18 +187,18 @@ void test_fails(void) {
grpc_exec_ctx_finish(&exec_ctx);
}
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
- grpc_error *error) {
- grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+ grpc_error* error) {
+ grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(&exec_ctx, g_pollset_set, g_pollset);
grpc_exec_ctx_finish(&exec_ctx);
@@ -218,6 +217,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 edfccbe867..101d7bf6b5 100644
--- a/test/core/iomgr/tcp_client_uv_test.c
+++ b/test/core/iomgr/tcp_client_uv_test.cc
@@ -37,16 +37,16 @@
#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));
}
-static void finish_connection(grpc_exec_ctx *exec_ctx) {
+static void finish_connection(grpc_exec_ctx* exec_ctx) {
gpr_mu_lock(g_mu);
g_connections_complete++;
GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
@@ -54,8 +54,8 @@ static void finish_connection(grpc_exec_ctx *exec_ctx) {
gpr_mu_unlock(g_mu);
}
-static void must_succeed(grpc_exec_ctx *exec_ctx, void *arg,
- grpc_error *error) {
+static void must_succeed(grpc_exec_ctx* exec_ctx, void* arg,
+ grpc_error* error) {
GPR_ASSERT(g_connecting != NULL);
GPR_ASSERT(error == GRPC_ERROR_NONE);
grpc_endpoint_shutdown(
@@ -66,26 +66,27 @@ static void must_succeed(grpc_exec_ctx *exec_ctx, void *arg,
finish_connection(exec_ctx);
}
-static void must_fail(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
+static void must_fail(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
GPR_ASSERT(g_connecting == NULL);
GPR_ASSERT(error != GRPC_ERROR_NONE);
finish_connection(exec_ctx);
}
-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;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -98,16 +99,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(&exec_ctx, &done, &g_connecting, NULL, NULL,
&resolved_addr, GRPC_MILLIS_INF_FUTURE);
@@ -115,7 +116,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(&exec_ctx, g_pollset, &worker,
@@ -127,7 +128,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);
@@ -136,7 +137,7 @@ 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;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -160,7 +161,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(&exec_ctx, &polling_deadline)) {
@@ -184,17 +185,17 @@ void test_fails(void) {
grpc_exec_ctx_finish(&exec_ctx);
}
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
- grpc_error *error) {
- grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+ grpc_error* error) {
+ grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(&exec_ctx);
test_succeeds();
@@ -211,6 +212,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 6501160c6f..7986dc2b19 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,9 +131,9 @@ static size_t count_slices(grpc_slice *slices, size_t nslices,
return num_bytes;
}
-static void read_cb(grpc_exec_ctx *exec_ctx, void *user_data,
- grpc_error *error) {
- struct read_socket_state *state = (struct read_socket_state *)user_data;
+static void read_cb(grpc_exec_ctx* exec_ctx, void* user_data,
+ grpc_error* error) {
+ struct read_socket_state* state = (struct read_socket_state*)user_data;
size_t read_bytes;
int current_data;
@@ -147,8 +147,8 @@ static void read_cb(grpc_exec_ctx *exec_ctx, void *user_data,
gpr_log(GPR_INFO, "Read %" PRIuPTR " bytes of %" PRIuPTR, read_bytes,
state->target_read_bytes);
if (state->read_bytes >= state->target_read_bytes) {
- GPR_ASSERT(GRPC_LOG_IF_ERROR("kick",
- grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+ GPR_ASSERT(GRPC_LOG_IF_ERROR(
+ "kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
gpr_mu_unlock(g_mu);
} else {
grpc_endpoint_read(exec_ctx, state->ep, &state->incoming, &state->read_cb);
@@ -159,7 +159,7 @@ static void read_cb(grpc_exec_ctx *exec_ctx, void *user_data,
/* 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 =
@@ -171,10 +171,10 @@ static void read_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(&exec_ctx, grpc_fd_create(sv[1], "read_test"), &args,
"test");
grpc_endpoint_add_to_pollset(&exec_ctx, ep, g_pollset);
@@ -192,7 +192,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 = nullptr;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(&exec_ctx, g_pollset, &worker, deadline)));
@@ -212,7 +212,7 @@ 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 =
@@ -223,10 +223,11 @@ static void large_read_test(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(&exec_ctx, grpc_fd_create(sv[1], "large_read_test"),
&args, "test");
grpc_endpoint_add_to_pollset(&exec_ctx, ep, g_pollset);
@@ -244,7 +245,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 = nullptr;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(&exec_ctx, g_pollset, &worker, deadline)));
@@ -261,17 +262,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) {
@@ -288,21 +289,21 @@ static grpc_slice *allocate_blocks(size_t num_bytes, size_t slice_size,
return slices;
}
-static void write_done(grpc_exec_ctx *exec_ctx,
- void *user_data /* write_socket_state */,
- grpc_error *error) {
- struct write_socket_state *state = (struct write_socket_state *)user_data;
+static void write_done(grpc_exec_ctx* exec_ctx,
+ 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");
state->write_done = 1;
- GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+ GPR_ASSERT(GRPC_LOG_IF_ERROR(
+ "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
gpr_mu_unlock(g_mu);
}
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;
@@ -314,7 +315,7 @@ void drain_socket_blocking(int fd, size_t num_bytes, size_t read_size) {
GPR_ASSERT(fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) == 0);
for (;;) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = nullptr;
gpr_mu_lock(g_mu);
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
@@ -346,10 +347,10 @@ 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;
@@ -363,10 +364,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(&exec_ctx, grpc_fd_create(sv[1], "write_test"), &args,
"test");
grpc_endpoint_add_to_pollset(&exec_ctx, ep, g_pollset);
@@ -385,7 +386,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 = nullptr;
if (state.write_done) {
break;
}
@@ -404,18 +405,18 @@ static void write_test(size_t num_bytes, size_t slice_size) {
grpc_exec_ctx_finish(&exec_ctx);
}
-void on_fd_released(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *errors) {
- int *done = (int *)arg;
+void on_fd_released(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* errors) {
+ int* done = (int*)arg;
*done = 1;
- GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+ GPR_ASSERT(GRPC_LOG_IF_ERROR(
+ "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
}
/* Do a read_test, then release fd and try to read/write again. Verify that
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;
@@ -433,10 +434,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(&exec_ctx, grpc_fd_create(sv[1], "read_test"), &args,
"test");
GPR_ASSERT(grpc_tcp_fd(ep) == sv[1] && sv[1] >= 0);
@@ -455,7 +457,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 = nullptr;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(&exec_ctx, g_pollset, &worker, deadline)));
@@ -473,7 +475,7 @@ static void release_fd_test(size_t num_bytes, size_t slice_size) {
grpc_exec_ctx_flush(&exec_ctx);
gpr_mu_lock(g_mu);
while (!fd_released_done) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = nullptr;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(&exec_ctx, g_pollset, &worker, deadline)));
@@ -523,12 +525,13 @@ static grpc_endpoint_test_fixture create_fixture_tcp_socketpair(
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(
&exec_ctx, grpc_fd_create(sv[0], "fixture:client"), &args, "test");
f.server_ep = grpc_tcp_create(
@@ -546,17 +549,17 @@ static grpc_endpoint_test_config configs[] = {
{"tcp/tcp_socketpair", create_fixture_tcp_socketpair, clean_up},
};
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
- grpc_error *error) {
- grpc_pollset_destroy(exec_ctx, (grpc_pollset *)p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+ grpc_error* error) {
+ grpc_pollset_destroy(exec_ctx, (grpc_pollset*)p);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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();
@@ -572,6 +575,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 782dfb413a..48d8d425a5 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;
@@ -78,10 +78,10 @@ typedef struct {
test_addr addrs[MAX_ADDRS];
} test_addrs;
-static on_connect_result g_result = {NULL, 0, 0, -1};
+static on_connect_result g_result = {nullptr, 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) {
- result->server = NULL;
+static void on_connect_result_init(on_connect_result* result) {
+ result->server = nullptr;
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,14 +110,14 @@ static void on_connect_result_set(on_connect_result *result,
result->server, acceptor->port_index, acceptor->fd_index);
}
-static void server_weak_ref_shutdown(grpc_exec_ctx *exec_ctx, void *arg,
- grpc_error *error) {
- server_weak_ref *weak_ref = arg;
- weak_ref->server = NULL;
+static void server_weak_ref_shutdown(grpc_exec_ctx* exec_ctx, void* arg,
+ grpc_error* error) {
+ server_weak_ref* weak_ref = static_cast<server_weak_ref*>(arg);
+ weak_ref->server = nullptr;
}
-static void server_weak_ref_init(server_weak_ref *weak_ref) {
- weak_ref->server = NULL;
+static void server_weak_ref_init(server_weak_ref* weak_ref) {
+ weak_ref->server = nullptr;
GRPC_CLOSURE_INIT(&weak_ref->server_shutdown, server_weak_ref_shutdown,
weak_ref, grpc_schedule_on_exec_ctx);
}
@@ -127,14 +127,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 = nullptr;
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)));
@@ -145,9 +145,9 @@ static void test_addr_init_str(test_addr *addr) {
}
}
-static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp,
- grpc_pollset *pollset,
- grpc_tcp_server_acceptor *acceptor) {
+static void on_connect(grpc_exec_ctx* exec_ctx, void* arg, grpc_endpoint* tcp,
+ grpc_pollset* pollset,
+ grpc_tcp_server_acceptor* acceptor) {
grpc_endpoint_shutdown(exec_ctx, tcp,
GRPC_ERROR_CREATE_FROM_STATIC_STRING("Connected"));
grpc_endpoint_destroy(exec_ctx, tcp);
@@ -159,27 +159,27 @@ static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp,
gpr_mu_lock(g_mu);
g_result = temp_result;
g_nconnects++;
- GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+ GPR_ASSERT(GRPC_LOG_IF_ERROR(
+ "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
gpr_mu_unlock(g_mu);
}
static void test_no_op(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_tcp_server *s;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE ==
- grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
+ grpc_tcp_server_create(&exec_ctx, nullptr, nullptr, &s));
grpc_tcp_server_unref(&exec_ctx, s);
grpc_exec_ctx_finish(&exec_ctx);
}
static void test_no_op_with_start(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_tcp_server *s;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE ==
- grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
+ grpc_tcp_server_create(&exec_ctx, nullptr, nullptr, &s));
LOG_TEST("test_no_op_with_start");
- grpc_tcp_server_start(&exec_ctx, s, NULL, 0, on_connect, NULL);
+ grpc_tcp_server_start(&exec_ctx, s, nullptr, 0, on_connect, nullptr);
grpc_tcp_server_unref(&exec_ctx, s);
grpc_exec_ctx_finish(&exec_ctx);
}
@@ -187,10 +187,10 @@ static void test_no_op_with_start(void) {
static void test_no_op_with_port(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(&exec_ctx, NULL, NULL, &s));
+ grpc_tcp_server_create(&exec_ctx, nullptr, nullptr, &s));
LOG_TEST("test_no_op_with_port");
memset(&resolved_addr, 0, sizeof(resolved_addr));
@@ -208,10 +208,10 @@ static void test_no_op_with_port(void) {
static void test_no_op_with_port_and_start(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(&exec_ctx, NULL, NULL, &s));
+ grpc_tcp_server_create(&exec_ctx, nullptr, nullptr, &s));
LOG_TEST("test_no_op_with_port_and_start");
int port = -1;
@@ -222,20 +222,20 @@ static void test_no_op_with_port_and_start(void) {
GRPC_ERROR_NONE &&
port > 0);
- grpc_tcp_server_start(&exec_ctx, s, NULL, 0, on_connect, NULL);
+ grpc_tcp_server_start(&exec_ctx, s, nullptr, 0, on_connect, nullptr);
grpc_tcp_server_unref(&exec_ctx, s);
grpc_exec_ctx_finish(&exec_ctx);
}
-static grpc_error *tcp_connect(grpc_exec_ctx *exec_ctx, const test_addr *remote,
- on_connect_result *result) {
+static grpc_error* tcp_connect(grpc_exec_ctx* exec_ctx, 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);
@@ -255,8 +255,8 @@ static grpc_error *tcp_connect(grpc_exec_ctx *exec_ctx, const test_addr *remote,
gpr_log(GPR_DEBUG, "wait");
while (g_nconnects == nconnects_before &&
deadline > grpc_exec_ctx_now(exec_ctx)) {
- grpc_pollset_worker *worker = NULL;
- grpc_error *err;
+ grpc_pollset_worker* worker = nullptr;
+ grpc_error* err;
if ((err = grpc_pollset_work(exec_ctx, g_pollset, &worker, deadline)) !=
GRPC_ERROR_NONE) {
gpr_mu_unlock(g_mu);
@@ -290,24 +290,24 @@ static grpc_error *tcp_connect(grpc_exec_ctx *exec_ctx, 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) {
+ const grpc_channel_args* channel_args,
+ test_addrs* dst_addrs, bool test_dst_addrs) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(&exec_ctx, NULL, channel_args, &s));
+ grpc_tcp_server_create(&exec_ctx, nullptr, channel_args, &s));
unsigned port_num;
server_weak_ref weak_ref;
server_weak_ref_init(&weak_ref);
@@ -316,8 +316,8 @@ static void test_connect(size_t num_connects,
gpr_log(GPR_INFO,
"clients=%lu, num chan args=%lu, remote IP=%s, test_dst_addrs=%d",
(unsigned long)num_connects,
- (unsigned long)(channel_args != NULL ? channel_args->num_args : 0),
- dst_addrs != NULL ? "<specific>" : "::", test_dst_addrs);
+ (unsigned long)(channel_args != nullptr ? channel_args->num_args : 0),
+ dst_addrs != nullptr ? "<specific>" : "::", test_dst_addrs);
memset(&resolved_addr, 0, sizeof(resolved_addr));
memset(&resolved_addr1, 0, sizeof(resolved_addr1));
resolved_addr.len = sizeof(struct sockaddr_storage);
@@ -352,9 +352,9 @@ static void test_connect(size_t num_connects,
svr1_fd_count = grpc_tcp_server_port_fd_count(s, 1);
GPR_ASSERT(svr1_fd_count >= 1);
- grpc_tcp_server_start(&exec_ctx, s, &g_pollset, 1, on_connect, NULL);
+ grpc_tcp_server_start(&exec_ctx, s, &g_pollset, 1, on_connect, nullptr);
- if (dst_addrs != NULL) {
+ if (dst_addrs != nullptr) {
int ports[] = {svr_port, svr1_port};
for (port_num = 0; port_num < num_ports; ++port_num) {
size_t dst_idx;
@@ -362,7 +362,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);
@@ -394,8 +394,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,
@@ -417,34 +417,37 @@ static void test_connect(size_t num_connects,
}
}
/* Weak ref to server valid until final unref. */
- GPR_ASSERT(weak_ref.server != NULL);
+ GPR_ASSERT(weak_ref.server != nullptr);
GPR_ASSERT(grpc_tcp_server_port_fd(s, 0, 0) >= 0);
grpc_tcp_server_unref(&exec_ctx, s);
grpc_exec_ctx_finish(&exec_ctx);
/* Weak ref lost. */
- GPR_ASSERT(weak_ref.server == NULL);
+ GPR_ASSERT(weak_ref.server == nullptr);
}
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
- grpc_error *error) {
- grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+ grpc_error* error) {
+ grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_arg chan_args[] = {
- {GRPC_ARG_INTEGER, GRPC_ARG_EXPAND_WILDCARD_ADDRS, {.integer = 1}}};
+ 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 = nullptr;
+ 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();
@@ -452,14 +455,14 @@ int main(int argc, char **argv) {
test_no_op_with_port();
test_no_op_with_port_and_start();
- if (getifaddrs(&ifa) != 0 || ifa == NULL) {
+ if (getifaddrs(&ifa) != 0 || ifa == nullptr) {
gpr_log(GPR_ERROR, "getifaddrs: %s", strerror(errno));
return EXIT_FAILURE;
}
dst_addrs->naddrs = 0;
- for (ifa_it = ifa; ifa_it != NULL && dst_addrs->naddrs < MAX_ADDRS;
+ for (ifa_it = ifa; ifa_it != nullptr && dst_addrs->naddrs < MAX_ADDRS;
ifa_it = ifa_it->ifa_next) {
- if (ifa_it->ifa_addr == NULL) {
+ if (ifa_it->ifa_addr == nullptr) {
continue;
} else if (ifa_it->ifa_addr->sa_family == AF_INET) {
dst_addrs->addrs[dst_addrs->naddrs].addr.len = sizeof(struct sockaddr_in);
@@ -477,15 +480,15 @@ int main(int argc, char **argv) {
++dst_addrs->naddrs;
}
freeifaddrs(ifa);
- ifa = NULL;
+ ifa = nullptr;
/* Connect to same addresses as listeners. */
- test_connect(1, NULL, NULL, false);
- test_connect(10, NULL, NULL, false);
+ test_connect(1, nullptr, nullptr, false);
+ test_connect(10, nullptr, nullptr, false);
/* Set dst_addrs->addrs[i].len=0 for dst_addrs that are unreachable with a
"::" listener. */
- test_connect(1, NULL, dst_addrs, true);
+ test_connect(1, nullptr, dst_addrs, true);
/* Test connect(2) with dst_addrs. */
test_connect(1, &channel_args, dst_addrs, false);
@@ -504,6 +507,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 9fafd3177a..dd047a0498 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,26 +61,26 @@ 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(grpc_exec_ctx *exec_ctx, void *arg,
- grpc_error *error) {
- server_weak_ref *weak_ref = arg;
+static void server_weak_ref_shutdown(grpc_exec_ctx* exec_ctx, 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);
@@ -91,15 +91,15 @@ 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(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp,
- grpc_pollset *pollset,
- grpc_tcp_server_acceptor *acceptor) {
+static void on_connect(grpc_exec_ctx* exec_ctx, void* arg, grpc_endpoint* tcp,
+ grpc_pollset* pollset,
+ grpc_tcp_server_acceptor* acceptor) {
grpc_endpoint_shutdown(exec_ctx, tcp,
GRPC_ERROR_CREATE_FROM_STATIC_STRING("Connected"));
grpc_endpoint_destroy(exec_ctx, tcp);
@@ -118,7 +118,7 @@ static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp,
static void test_no_op(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_tcp_server *s;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE ==
grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
grpc_tcp_server_unref(&exec_ctx, s);
@@ -127,7 +127,7 @@ static void test_no_op(void) {
static void test_no_op_with_start(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_tcp_server *s;
+ grpc_tcp_server* s;
GPR_ASSERT(GRPC_ERROR_NONE ==
grpc_tcp_server_create(&exec_ctx, NULL, NULL, &s));
LOG_TEST("test_no_op_with_start");
@@ -139,8 +139,8 @@ static void test_no_op_with_start(void) {
static void test_no_op_with_port(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(&exec_ctx, NULL, NULL, &s));
LOG_TEST("test_no_op_with_port");
@@ -160,8 +160,8 @@ static void test_no_op_with_port(void) {
static void test_no_op_with_port_and_start(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(&exec_ctx, NULL, NULL, &s));
LOG_TEST("test_no_op_with_port_and_start");
@@ -180,18 +180,20 @@ static void test_no_op_with_port_and_start(void) {
grpc_exec_ctx_finish(&exec_ctx);
}
-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(grpc_exec_ctx *exec_ctx, const struct sockaddr *remote,
- socklen_t remote_len, on_connect_result *result) {
+static void tcp_connect(grpc_exec_ctx* exec_ctx, 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);
@@ -203,7 +205,7 @@ static void tcp_connect(grpc_exec_ctx *exec_ctx, const struct sockaddr *remote,
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(exec_ctx, g_pollset, &worker,
@@ -214,7 +216,7 @@ static void tcp_connect(grpc_exec_ctx *exec_ctx, const struct sockaddr *remote,
}
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);
@@ -225,12 +227,12 @@ static void test_connect(unsigned n) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(&exec_ctx, NULL, NULL, &s));
unsigned i;
@@ -246,7 +248,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();
@@ -257,13 +259,13 @@ static void test_connect(unsigned n) {
grpc_tcp_server_start(&exec_ctx, 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(&exec_ctx, (struct sockaddr *)addr,
- (socklen_t)resolved_addr.len, &result);
+ tcp_connect(&exec_ctx, (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) {
@@ -272,7 +274,7 @@ static void test_connect(unsigned n) {
grpc_tcp_server_unref(&exec_ctx, result.server);
on_connect_result_init(&result);
- tcp_connect(&exec_ctx, (struct sockaddr *)addr1,
+ tcp_connect(&exec_ctx, (struct sockaddr*)addr1,
(socklen_t)resolved_addr1.len, &result);
GPR_ASSERT(result.port_index == 1);
GPR_ASSERT(result.server == s);
@@ -289,17 +291,17 @@ static void test_connect(unsigned n) {
GPR_ASSERT(weak_ref.server == NULL);
}
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
- grpc_error *error) {
- grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+ grpc_error* error) {
+ grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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();
@@ -320,6 +322,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..f0ab4343cb 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,8 +146,8 @@ 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;
- for (size_t i = 0; out == NULL && i < count; i++) {
+ elem_struct* out = nullptr;
+ for (size_t i = 0; out == nullptr && 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,8 +173,8 @@ 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);
- if (el != NULL) {
+ elem_struct* el = search_elems(elems, GPR_ARRAY_SIZE(elems), false);
+ if (el != nullptr) {
el->elem.deadline = random_deadline();
grpc_timer_heap_add(&pq, &el->elem);
el->inserted = true;
@@ -180,8 +183,8 @@ 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);
- if (el != NULL) {
+ elem_struct* el = search_elems(elems, GPR_ARRAY_SIZE(elems), true);
+ if (el != nullptr) {
grpc_timer_heap_remove(&pq, &el->elem);
el->inserted = false;
num_inserted--;
@@ -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,10 +207,10 @@ static void test2(void) {
}
if (num_inserted) {
- gpr_atm *min_deadline = NULL;
+ gpr_atm* min_deadline = nullptr;
for (size_t i = 0; i < elems_size; i++) {
if (elems[i].inserted) {
- if (min_deadline == NULL) {
+ if (min_deadline == nullptr) {
min_deadline = &elems[i].elem.deadline;
} else {
if (elems[i].elem.deadline < *min_deadline) {
@@ -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 c3d9f9d88d..d74ea4fc96 100644
--- a/test/core/iomgr/timer_list_test.c
+++ b/test/core/iomgr/timer_list_test.cc
@@ -28,15 +28,16 @@
#include <grpc/support/log.h>
#include "src/core/lib/debug/trace.h"
#include "test/core/util/test_config.h"
+#include "test/core/util/tracer_util.h"
#define MAX_CB 30
-extern grpc_tracer_flag grpc_timer_trace;
-extern grpc_tracer_flag grpc_timer_check_trace;
+extern grpc_core::TraceFlag grpc_timer_trace;
+extern grpc_core::TraceFlag grpc_timer_check_trace;
static int cb_called[MAX_CB][2];
-static void cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
+static void cb(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
cb_called[(intptr_t)arg][error == GRPC_ERROR_NONE]++;
}
@@ -48,29 +49,29 @@ static void add_test(void) {
gpr_log(GPR_INFO, "add_test");
grpc_timer_list_init(&exec_ctx);
- grpc_timer_trace.value = 1;
- grpc_timer_check_trace.value = 1;
+ grpc_core::testing::grpc_tracer_enable_flag(&grpc_timer_trace);
+ grpc_core::testing::grpc_tracer_enable_flag(&grpc_timer_check_trace);
memset(cb_called, 0, sizeof(cb_called));
grpc_millis start = grpc_exec_ctx_now(&exec_ctx);
/* 10 ms timers. will expire in the current epoch */
for (i = 0; i < 10; i++) {
- grpc_timer_init(&exec_ctx, &timers[i], start + 10,
- GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)i,
- grpc_schedule_on_exec_ctx));
+ grpc_timer_init(
+ &exec_ctx, &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(&exec_ctx, &timers[i], start + 1010,
- GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)i,
- grpc_schedule_on_exec_ctx));
+ grpc_timer_init(
+ &exec_ctx, &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;
- GPR_ASSERT(grpc_timer_check(&exec_ctx, NULL) == GRPC_TIMERS_FIRED);
+ GPR_ASSERT(grpc_timer_check(&exec_ctx, nullptr) == GRPC_TIMERS_FIRED);
grpc_exec_ctx_finish(&exec_ctx);
for (i = 0; i < 20; i++) {
GPR_ASSERT(cb_called[i][1] == (i < 10));
@@ -78,7 +79,7 @@ static void add_test(void) {
}
exec_ctx.now = start + 600;
- GPR_ASSERT(grpc_timer_check(&exec_ctx, NULL) ==
+ GPR_ASSERT(grpc_timer_check(&exec_ctx, nullptr) ==
GRPC_TIMERS_CHECKED_AND_EMPTY);
grpc_exec_ctx_finish(&exec_ctx);
for (i = 0; i < 30; i++) {
@@ -88,7 +89,7 @@ static void add_test(void) {
/* collect the rest of the timers */
exec_ctx.now = start + 1500;
- GPR_ASSERT(grpc_timer_check(&exec_ctx, NULL) == GRPC_TIMERS_FIRED);
+ GPR_ASSERT(grpc_timer_check(&exec_ctx, nullptr) == GRPC_TIMERS_FIRED);
grpc_exec_ctx_finish(&exec_ctx);
for (i = 0; i < 30; i++) {
GPR_ASSERT(cb_called[i][1] == (i < 20));
@@ -96,7 +97,7 @@ static void add_test(void) {
}
exec_ctx.now = start + 1600;
- GPR_ASSERT(grpc_timer_check(&exec_ctx, NULL) ==
+ GPR_ASSERT(grpc_timer_check(&exec_ctx, nullptr) ==
GRPC_TIMERS_CHECKED_AND_EMPTY);
for (i = 0; i < 30; i++) {
GPR_ASSERT(cb_called[i][1] == (i < 20));
@@ -117,27 +118,27 @@ void destruction_test(void) {
exec_ctx.now_is_valid = true;
exec_ctx.now = 0;
grpc_timer_list_init(&exec_ctx);
- grpc_timer_trace.value = 1;
- grpc_timer_check_trace.value = 1;
+ grpc_core::testing::grpc_tracer_enable_flag(&grpc_timer_trace);
+ grpc_core::testing::grpc_tracer_enable_flag(&grpc_timer_check_trace);
memset(cb_called, 0, sizeof(cb_called));
grpc_timer_init(
&exec_ctx, &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(
&exec_ctx, &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(
&exec_ctx, &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(
&exec_ctx, &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(
&exec_ctx, &timers[4], 1,
- GRPC_CLOSURE_CREATE(cb, (void *)(intptr_t)4, grpc_schedule_on_exec_ctx));
+ GRPC_CLOSURE_CREATE(cb, (void*)(intptr_t)4, grpc_schedule_on_exec_ctx));
exec_ctx.now = 2;
- GPR_ASSERT(grpc_timer_check(&exec_ctx, NULL) == GRPC_TIMERS_FIRED);
+ GPR_ASSERT(grpc_timer_check(&exec_ctx, nullptr) == GRPC_TIMERS_FIRED);
grpc_exec_ctx_finish(&exec_ctx);
GPR_ASSERT(1 == cb_called[4][1]);
grpc_timer_cancel(&exec_ctx, &timers[0]);
@@ -152,7 +153,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();
@@ -162,6 +163,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 2e44d0abc8..803f017106 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_exec_ctx *exec_ctx, grpc_fd *emfd, void *user_data) {
+static void on_read(grpc_exec_ctx* exec_ctx, grpc_fd* emfd, void* user_data) {
char read_buffer[512];
ssize_t byte_count;
@@ -61,22 +61,22 @@ static void on_read(grpc_exec_ctx *exec_ctx, grpc_fd *emfd, void *user_data) {
g_number_of_reads++;
g_number_of_bytes_read += (int)byte_count;
- GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+ GPR_ASSERT(GRPC_LOG_IF_ERROR(
+ "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
gpr_mu_unlock(g_mu);
}
-static void on_write(grpc_exec_ctx *exec_ctx, grpc_fd *emfd, void *user_data) {
+static void on_write(grpc_exec_ctx* exec_ctx, grpc_fd* emfd, void* user_data) {
gpr_mu_lock(g_mu);
g_number_of_writes++;
- GPR_ASSERT(GRPC_LOG_IF_ERROR("pollset_kick",
- grpc_pollset_kick(exec_ctx, g_pollset, NULL)));
+ GPR_ASSERT(GRPC_LOG_IF_ERROR(
+ "pollset_kick", grpc_pollset_kick(exec_ctx, g_pollset, nullptr)));
gpr_mu_unlock(g_mu);
}
-static void on_fd_orphaned(grpc_exec_ctx *exec_ctx, grpc_fd *emfd,
- grpc_closure *closure, void *user_data) {
+static void on_fd_orphaned(grpc_exec_ctx* exec_ctx, 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;
@@ -127,17 +128,17 @@ static test_socket_factory *test_socket_factory_create(void) {
static void test_no_op(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_udp_server *s = grpc_udp_server_create(NULL);
- grpc_udp_server_destroy(&exec_ctx, s, NULL);
+ grpc_udp_server* s = grpc_udp_server_create(nullptr);
+ grpc_udp_server_destroy(&exec_ctx, s, nullptr);
grpc_exec_ctx_finish(&exec_ctx);
}
static void test_no_op_with_start(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_udp_server *s = grpc_udp_server_create(NULL);
+ grpc_udp_server* s = grpc_udp_server_create(nullptr);
LOG_TEST("test_no_op_with_start");
- grpc_udp_server_start(&exec_ctx, s, NULL, 0, NULL);
- grpc_udp_server_destroy(&exec_ctx, s, NULL);
+ grpc_udp_server_start(&exec_ctx, s, nullptr, 0, nullptr);
+ grpc_udp_server_destroy(&exec_ctx, s, nullptr);
grpc_exec_ctx_finish(&exec_ctx);
}
@@ -145,8 +146,8 @@ static void test_no_op_with_port(void) {
g_number_of_orphan_calls = 0;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(nullptr);
LOG_TEST("test_no_op_with_port");
memset(&resolved_addr, 0, sizeof(resolved_addr));
@@ -155,7 +156,7 @@ static void test_no_op_with_port(void) {
GPR_ASSERT(grpc_udp_server_add_port(s, &resolved_addr, on_read, on_write,
on_fd_orphaned));
- grpc_udp_server_destroy(&exec_ctx, s, NULL);
+ grpc_udp_server_destroy(&exec_ctx, s, nullptr);
grpc_exec_ctx_finish(&exec_ctx);
/* The server had a single FD, which should have been orphaned. */
@@ -166,14 +167,14 @@ static void test_no_op_with_port_and_socket_factory(void) {
g_number_of_orphan_calls = 0;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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_copy_and_add(NULL, &socket_factory_arg, 1);
- grpc_udp_server *s = grpc_udp_server_create(channel_args);
+ grpc_channel_args* channel_args =
+ grpc_channel_args_copy_and_add(nullptr, &socket_factory_arg, 1);
+ grpc_udp_server* s = grpc_udp_server_create(channel_args);
grpc_channel_args_destroy(&exec_ctx, channel_args);
LOG_TEST("test_no_op_with_port_and_socket_factory");
@@ -186,7 +187,7 @@ static void test_no_op_with_port_and_socket_factory(void) {
GPR_ASSERT(socket_factory->number_of_socket_calls == 1);
GPR_ASSERT(socket_factory->number_of_bind_calls == 1);
- grpc_udp_server_destroy(&exec_ctx, s, NULL);
+ grpc_udp_server_destroy(&exec_ctx, s, nullptr);
grpc_exec_ctx_finish(&exec_ctx);
grpc_socket_factory_unref(&socket_factory->base);
@@ -198,8 +199,8 @@ static void test_no_op_with_port_and_start(void) {
g_number_of_orphan_calls = 0;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(nullptr);
LOG_TEST("test_no_op_with_port_and_start");
memset(&resolved_addr, 0, sizeof(resolved_addr));
@@ -208,9 +209,9 @@ static void test_no_op_with_port_and_start(void) {
GPR_ASSERT(grpc_udp_server_add_port(s, &resolved_addr, on_read, on_write,
on_fd_orphaned));
- grpc_udp_server_start(&exec_ctx, s, NULL, 0, NULL);
+ grpc_udp_server_start(&exec_ctx, s, nullptr, 0, nullptr);
- grpc_udp_server_destroy(&exec_ctx, s, NULL);
+ grpc_udp_server_destroy(&exec_ctx, s, nullptr);
grpc_exec_ctx_finish(&exec_ctx);
/* The server had a single FD, which is orphaned exactly once in *
@@ -221,13 +222,13 @@ static void test_no_op_with_port_and_start(void) {
static void test_receive(int number_of_clients) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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(nullptr);
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,12 +243,12 @@ 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;
- grpc_udp_server_start(&exec_ctx, s, pollsets, 1, NULL);
+ grpc_udp_server_start(&exec_ctx, s, pollsets, 1, nullptr);
gpr_mu_lock(g_mu);
@@ -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(&exec_ctx)) {
- grpc_pollset_worker *worker = NULL;
+ grpc_pollset_worker* worker = nullptr;
GPR_ASSERT(GRPC_LOG_IF_ERROR(
"pollset_work",
grpc_pollset_work(&exec_ctx, g_pollset, &worker, deadline)));
@@ -279,7 +280,7 @@ static void test_receive(int number_of_clients) {
gpr_mu_unlock(g_mu);
- grpc_udp_server_destroy(&exec_ctx, s, NULL);
+ grpc_udp_server_destroy(&exec_ctx, s, nullptr);
grpc_exec_ctx_finish(&exec_ctx);
/* The server had a single FD, which is orphaned exactly once in *
@@ -290,17 +291,17 @@ static void test_receive(int number_of_clients) {
GPR_ASSERT(g_number_of_writes > 0);
}
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p,
- grpc_error *error) {
- grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p,
+ grpc_error* error) {
+ grpc_pollset_destroy(exec_ctx, static_cast<grpc_pollset*>(p));
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_closure destroyed;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
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();
@@ -322,6 +323,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-08-07 20:53:01 +0000