aboutsummaryrefslogtreecommitdiffhomepage
path: root/test/core/client_channel
diff options
context:
space:
mode:
Diffstat (limited to 'test/core/client_channel')
-rw-r--r--test/core/client_channel/BUILD8
-rw-r--r--test/core/client_channel/lb_policies_test.cc (renamed from test/core/client_channel/lb_policies_test.c)384
-rw-r--r--test/core/client_channel/parse_address_test.cc (renamed from test/core/client_channel/parse_address_test.c)30
-rw-r--r--test/core/client_channel/resolvers/BUILD16
-rw-r--r--test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc (renamed from test/core/client_channel/resolvers/dns_resolver_connectivity_test.c)99
-rw-r--r--test/core/client_channel/resolvers/dns_resolver_test.cc (renamed from test/core/client_channel/resolvers/dns_resolver_test.c)22
-rw-r--r--test/core/client_channel/resolvers/fake_resolver_test.cc (renamed from test/core/client_channel/resolvers/fake_resolver_test.c)66
-rw-r--r--test/core/client_channel/resolvers/sockaddr_resolver_test.cc (renamed from test/core/client_channel/resolvers/sockaddr_resolver_test.c)30
-rw-r--r--test/core/client_channel/uri_fuzzer_test.cc (renamed from test/core/client_channel/uri_fuzzer_test.c)6
-rw-r--r--test/core/client_channel/uri_parser_test.cc (renamed from test/core/client_channel/uri_parser_test.c)38
10 files changed, 362 insertions, 337 deletions
diff --git a/test/core/client_channel/BUILD b/test/core/client_channel/BUILD
index c4a93238f2..ec72e0ea72 100644
--- a/test/core/client_channel/BUILD
+++ b/test/core/client_channel/BUILD
@@ -22,8 +22,8 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer")
grpc_fuzzer(
name = "uri_fuzzer_test",
- srcs = ["uri_fuzzer_test.c"],
- language = "C",
+ srcs = ["uri_fuzzer_test.cc"],
+ language = "C++",
corpus = "uri_corpus",
deps = [
"//:gpr",
@@ -34,8 +34,8 @@ grpc_fuzzer(
grpc_cc_test(
name = "lb_policies_test",
- srcs = ["lb_policies_test.c"],
- language = "C",
+ srcs = ["lb_policies_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
diff --git a/test/core/client_channel/lb_policies_test.c b/test/core/client_channel/lb_policies_test.cc
index ba37cd673f..5f8d3b84cc 100644
--- a/test/core/client_channel/lb_policies_test.c
+++ b/test/core/client_channel/lb_policies_test.cc
@@ -41,39 +41,39 @@
typedef struct servers_fixture {
size_t num_servers;
- grpc_server **servers;
- grpc_call **server_calls;
- grpc_completion_queue *cq;
- grpc_completion_queue *shutdown_cq;
- char **servers_hostports;
- grpc_metadata_array *request_metadata_recv;
+ grpc_server** servers;
+ grpc_call** server_calls;
+ grpc_completion_queue* cq;
+ grpc_completion_queue* shutdown_cq;
+ char** servers_hostports;
+ grpc_metadata_array* request_metadata_recv;
} servers_fixture;
typedef struct request_sequences {
size_t n; /* number of iterations */
- int *connections; /* indexed by the interation number, value is the index of
+ int* connections; /* indexed by the interation number, value is the index of
the server it connected to or -1 if none */
- int *connectivity_states; /* indexed by the interation number, value is the
- client connectivity state */
+ /* indexed by the interation number, value is the client connectivity state */
+ grpc_connectivity_state* connectivity_states;
} request_sequences;
-typedef void (*verifier_fn)(const servers_fixture *, grpc_channel *,
- const request_sequences *, const size_t);
+typedef void (*verifier_fn)(const servers_fixture*, grpc_channel*,
+ const request_sequences*, const size_t);
typedef struct test_spec {
size_t num_iters;
size_t num_servers;
- int **kill_at;
- int **revive_at;
+ int** kill_at;
+ int** revive_at;
- const char *description;
+ const char* description;
verifier_fn verifier;
} test_spec;
-static void test_spec_reset(test_spec *spec) {
+static void test_spec_reset(test_spec* spec) {
size_t i, j;
for (i = 0; i < spec->num_iters; i++) {
@@ -84,25 +84,26 @@ static void test_spec_reset(test_spec *spec) {
}
}
-static test_spec *test_spec_create(size_t num_iters, size_t num_servers) {
- test_spec *spec;
+static test_spec* test_spec_create(size_t num_iters, size_t num_servers) {
+ test_spec* spec;
size_t i;
- spec = gpr_malloc(sizeof(test_spec));
+ spec = static_cast<test_spec*>(gpr_malloc(sizeof(test_spec)));
spec->num_iters = num_iters;
spec->num_servers = num_servers;
- spec->kill_at = gpr_malloc(sizeof(int *) * num_iters);
- spec->revive_at = gpr_malloc(sizeof(int *) * num_iters);
+ spec->kill_at = static_cast<int**>(gpr_malloc(sizeof(int*) * num_iters));
+ spec->revive_at = static_cast<int**>(gpr_malloc(sizeof(int*) * num_iters));
for (i = 0; i < num_iters; i++) {
- spec->kill_at[i] = gpr_malloc(sizeof(int) * num_servers);
- spec->revive_at[i] = gpr_malloc(sizeof(int) * num_servers);
+ spec->kill_at[i] = static_cast<int*>(gpr_malloc(sizeof(int) * num_servers));
+ spec->revive_at[i] =
+ static_cast<int*>(gpr_malloc(sizeof(int) * num_servers));
}
test_spec_reset(spec);
return spec;
}
-static void test_spec_destroy(test_spec *spec) {
+static void test_spec_destroy(test_spec* spec) {
size_t i;
for (i = 0; i < spec->num_iters; i++) {
gpr_free(spec->kill_at[i]);
@@ -115,29 +116,29 @@ static void test_spec_destroy(test_spec *spec) {
gpr_free(spec);
}
-static void *tag(intptr_t t) { return (void *)t; }
+static void* tag(intptr_t t) { return (void*)t; }
static gpr_timespec n_millis_time(int n) {
return gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
gpr_time_from_millis(n, GPR_TIMESPAN));
}
-static void drain_cq(grpc_completion_queue *cq) {
+static void drain_cq(grpc_completion_queue* cq) {
grpc_event ev;
do {
- ev = grpc_completion_queue_next(cq, n_millis_time(5000), NULL);
+ ev = grpc_completion_queue_next(cq, n_millis_time(5000), nullptr);
} while (ev.type != GRPC_QUEUE_SHUTDOWN);
}
-static void kill_server(const servers_fixture *f, size_t i) {
+static void kill_server(const servers_fixture* f, size_t i) {
gpr_log(GPR_INFO, "KILLING SERVER %" PRIuPTR, i);
- GPR_ASSERT(f->servers[i] != NULL);
+ GPR_ASSERT(f->servers[i] != nullptr);
grpc_server_shutdown_and_notify(f->servers[i], f->shutdown_cq, tag(10000));
GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(10000),
- n_millis_time(5000), NULL)
+ n_millis_time(5000), nullptr)
.type == GRPC_OP_COMPLETE);
grpc_server_destroy(f->servers[i]);
- f->servers[i] = NULL;
+ f->servers[i] = nullptr;
}
typedef struct request_data {
@@ -145,19 +146,19 @@ typedef struct request_data {
grpc_metadata_array trailing_metadata_recv;
grpc_slice details;
grpc_status_code status;
- grpc_call_details *call_details;
+ grpc_call_details* call_details;
} request_data;
-static void revive_server(const servers_fixture *f, request_data *rdata,
+static void revive_server(const servers_fixture* f, request_data* rdata,
size_t i) {
int got_port;
gpr_log(GPR_INFO, "RAISE AGAIN SERVER %" PRIuPTR, i);
- GPR_ASSERT(f->servers[i] == NULL);
+ GPR_ASSERT(f->servers[i] == nullptr);
gpr_log(GPR_DEBUG, "revive: %s", f->servers_hostports[i]);
- f->servers[i] = grpc_server_create(NULL, NULL);
- grpc_server_register_completion_queue(f->servers[i], f->cq, NULL);
+ f->servers[i] = grpc_server_create(nullptr, nullptr);
+ grpc_server_register_completion_queue(f->servers[i], f->cq, nullptr);
GPR_ASSERT((got_port = grpc_server_add_insecure_http2_port(
f->servers[i], f->servers_hostports[i])) > 0);
grpc_server_start(f->servers[i]);
@@ -169,39 +170,43 @@ static void revive_server(const servers_fixture *f, request_data *rdata,
f->cq, tag(1000 + (int)i)));
}
-static servers_fixture *setup_servers(const char *server_host,
- request_data *rdata,
+static servers_fixture* setup_servers(const char* server_host,
+ request_data* rdata,
const size_t num_servers) {
- servers_fixture *f = gpr_malloc(sizeof(servers_fixture));
+ servers_fixture* f =
+ static_cast<servers_fixture*>(gpr_malloc(sizeof(servers_fixture)));
size_t i;
f->num_servers = num_servers;
- f->server_calls = gpr_malloc(sizeof(grpc_call *) * num_servers);
- f->request_metadata_recv =
- gpr_malloc(sizeof(grpc_metadata_array) * num_servers);
+ f->server_calls =
+ static_cast<grpc_call**>(gpr_malloc(sizeof(grpc_call*) * num_servers));
+ f->request_metadata_recv = static_cast<grpc_metadata_array*>(
+ gpr_malloc(sizeof(grpc_metadata_array) * num_servers));
/* Create servers. */
- f->servers = gpr_malloc(sizeof(grpc_server *) * num_servers);
- f->servers_hostports = gpr_malloc(sizeof(char *) * num_servers);
- f->cq = grpc_completion_queue_create_for_next(NULL);
- f->shutdown_cq = grpc_completion_queue_create_for_pluck(NULL);
+ f->servers = static_cast<grpc_server**>(
+ gpr_malloc(sizeof(grpc_server*) * num_servers));
+ f->servers_hostports =
+ static_cast<char**>(gpr_malloc(sizeof(char*) * num_servers));
+ f->cq = grpc_completion_queue_create_for_next(nullptr);
+ f->shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
for (i = 0; i < num_servers; i++) {
grpc_metadata_array_init(&f->request_metadata_recv[i]);
gpr_join_host_port(&f->servers_hostports[i], server_host,
grpc_pick_unused_port_or_die());
- f->servers[i] = 0;
+ f->servers[i] = nullptr;
revive_server(f, rdata, i);
}
return f;
}
-static void teardown_servers(servers_fixture *f) {
+static void teardown_servers(servers_fixture* f) {
size_t i;
/* Destroy server. */
for (i = 0; i < f->num_servers; i++) {
- if (f->servers[i] == NULL) continue;
+ if (f->servers[i] == nullptr) continue;
grpc_server_shutdown_and_notify(f->servers[i], f->shutdown_cq, tag(10000));
GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(10000),
- n_millis_time(5000), NULL)
+ n_millis_time(5000), nullptr)
.type == GRPC_OP_COMPLETE);
grpc_server_destroy(f->servers[i]);
}
@@ -226,28 +231,29 @@ static void teardown_servers(servers_fixture *f) {
static request_sequences request_sequences_create(size_t n) {
request_sequences res;
res.n = n;
- res.connections = gpr_malloc(sizeof(*res.connections) * n);
- res.connectivity_states = gpr_malloc(sizeof(*res.connectivity_states) * n);
+ res.connections = static_cast<int*>(gpr_malloc(sizeof(*res.connections) * n));
+ res.connectivity_states = static_cast<grpc_connectivity_state*>(
+ gpr_malloc(sizeof(*res.connectivity_states) * n));
memset(res.connections, 0, sizeof(*res.connections) * n);
memset(res.connectivity_states, 0, sizeof(*res.connectivity_states) * n);
return res;
}
-static void request_sequences_destroy(const request_sequences *rseqs) {
+static void request_sequences_destroy(const request_sequences* rseqs) {
gpr_free(rseqs->connections);
gpr_free(rseqs->connectivity_states);
}
/** Returns connection sequence (server indices), which must be freed */
-static request_sequences perform_request(servers_fixture *f,
- grpc_channel *client,
- request_data *rdata,
- const test_spec *spec) {
- grpc_call *c;
+static request_sequences perform_request(servers_fixture* f,
+ grpc_channel* client,
+ request_data* rdata,
+ const test_spec* spec) {
+ grpc_call* c;
int s_idx;
- int *s_valid;
+ int* s_valid;
grpc_op ops[6];
- grpc_op *op;
+ grpc_op* op;
int was_cancelled;
size_t i, iter_num;
grpc_event ev;
@@ -255,10 +261,10 @@ static request_sequences perform_request(servers_fixture *f,
int completed_client;
const request_sequences sequences = request_sequences_create(spec->num_iters);
- s_valid = gpr_malloc(sizeof(int) * f->num_servers);
+ s_valid = static_cast<int*>(gpr_malloc(sizeof(int) * f->num_servers));
for (iter_num = 0; iter_num < spec->num_iters; iter_num++) {
- cq_verifier *cqv = cq_verifier_create(f->cq);
+ cq_verifier* cqv = cq_verifier_create(f->cq);
was_cancelled = 2;
for (i = 0; i < f->num_servers; i++) {
@@ -280,9 +286,10 @@ static request_sequences perform_request(servers_fixture *f,
memset(s_valid, 0, f->num_servers * sizeof(int));
grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr");
- c = grpc_channel_create_call(client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq,
- grpc_slice_from_static_string("/foo"), &host,
- gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+ c = grpc_channel_create_call(client, nullptr, GRPC_PROPAGATE_DEFAULTS,
+ f->cq, grpc_slice_from_static_string("/foo"),
+ &host, gpr_inf_future(GPR_CLOCK_REALTIME),
+ nullptr);
GPR_ASSERT(c);
completed_client = 0;
@@ -291,17 +298,17 @@ static request_sequences perform_request(servers_fixture *f,
op->op = GRPC_OP_SEND_INITIAL_METADATA;
op->data.send_initial_metadata.count = 0;
op->flags = 0;
- op->reserved = NULL;
+ op->reserved = nullptr;
op++;
op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
op->flags = 0;
- op->reserved = NULL;
+ op->reserved = nullptr;
op++;
op->op = GRPC_OP_RECV_INITIAL_METADATA;
op->data.recv_initial_metadata.recv_initial_metadata =
&rdata->initial_metadata_recv;
op->flags = 0;
- op->reserved = NULL;
+ op->reserved = nullptr;
op++;
op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
op->data.recv_status_on_client.trailing_metadata =
@@ -309,16 +316,16 @@ static request_sequences perform_request(servers_fixture *f,
op->data.recv_status_on_client.status = &rdata->status;
op->data.recv_status_on_client.status_details = &rdata->details;
op->flags = 0;
- op->reserved = NULL;
+ op->reserved = nullptr;
op++;
- GPR_ASSERT(GRPC_CALL_OK ==
- grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL));
+ GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(c, ops, (size_t)(op - ops),
+ tag(1), nullptr));
s_idx = -1;
- while (
- (ev = grpc_completion_queue_next(
- f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT), NULL))
- .type != GRPC_QUEUE_TIMEOUT) {
+ while ((ev = grpc_completion_queue_next(
+ f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT),
+ nullptr))
+ .type != GRPC_QUEUE_TIMEOUT) {
GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
read_tag = ((int)(intptr_t)ev.tag);
const grpc_connectivity_state conn_state =
@@ -346,7 +353,7 @@ static request_sequences perform_request(servers_fixture *f,
op->op = GRPC_OP_SEND_INITIAL_METADATA;
op->data.send_initial_metadata.count = 0;
op->flags = 0;
- op->reserved = NULL;
+ op->reserved = nullptr;
op++;
op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
op->data.send_status_from_server.trailing_metadata_count = 0;
@@ -354,16 +361,16 @@ static request_sequences perform_request(servers_fixture *f,
grpc_slice status_details = grpc_slice_from_static_string("xyz");
op->data.send_status_from_server.status_details = &status_details;
op->flags = 0;
- op->reserved = NULL;
+ op->reserved = nullptr;
op++;
op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
op->data.recv_close_on_server.cancelled = &was_cancelled;
op->flags = 0;
- op->reserved = NULL;
+ op->reserved = nullptr;
op++;
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(f->server_calls[s_idx],
ops, (size_t)(op - ops),
- tag(102), NULL));
+ tag(102), nullptr));
CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
if (!completed_client) {
@@ -388,17 +395,17 @@ static request_sequences perform_request(servers_fixture *f,
&f->request_metadata_recv[s_idx], f->cq,
f->cq, tag(1000 + (int)s_idx)));
} else { /* no response from server */
- grpc_call_cancel(c, NULL);
+ grpc_call_cancel(c, nullptr);
if (!completed_client) {
CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
cq_verify(cqv);
}
}
- GPR_ASSERT(
- grpc_completion_queue_next(
- f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT), NULL)
- .type == GRPC_QUEUE_TIMEOUT);
+ GPR_ASSERT(grpc_completion_queue_next(
+ f->cq, grpc_timeout_milliseconds_to_deadline(RETRY_TIMEOUT),
+ nullptr)
+ .type == GRPC_QUEUE_TIMEOUT);
grpc_metadata_array_destroy(&rdata->initial_metadata_recv);
grpc_metadata_array_destroy(&rdata->trailing_metadata_recv);
@@ -418,15 +425,16 @@ static request_sequences perform_request(servers_fixture *f,
return sequences;
}
-static grpc_call **perform_multirequest(servers_fixture *f,
- grpc_channel *client,
+static grpc_call** perform_multirequest(servers_fixture* f,
+ grpc_channel* client,
size_t concurrent_calls) {
- grpc_call **calls;
+ grpc_call** calls;
grpc_op ops[6];
- grpc_op *op;
+ grpc_op* op;
size_t i;
- calls = gpr_malloc(sizeof(grpc_call *) * concurrent_calls);
+ calls = static_cast<grpc_call**>(
+ gpr_malloc(sizeof(grpc_call*) * concurrent_calls));
for (i = 0; i < f->num_servers; i++) {
kill_server(f, i);
}
@@ -436,54 +444,55 @@ static grpc_call **perform_multirequest(servers_fixture *f,
op->op = GRPC_OP_SEND_INITIAL_METADATA;
op->data.send_initial_metadata.count = 0;
op->flags = 0;
- op->reserved = NULL;
+ op->reserved = nullptr;
op++;
op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
op->flags = 0;
- op->reserved = NULL;
+ op->reserved = nullptr;
grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr");
for (i = 0; i < concurrent_calls; i++) {
- calls[i] =
- grpc_channel_create_call(client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq,
- grpc_slice_from_static_string("/foo"), &host,
- gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+ calls[i] = grpc_channel_create_call(
+ client, nullptr, GRPC_PROPAGATE_DEFAULTS, f->cq,
+ grpc_slice_from_static_string("/foo"), &host,
+ gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
GPR_ASSERT(calls[i]);
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(calls[i], ops,
(size_t)(op - ops), tag(1),
- NULL));
+ nullptr));
}
return calls;
}
-void run_spec(const test_spec *spec) {
- grpc_channel *client;
- char *client_hostport;
- char *servers_hostports_str;
+void run_spec(const test_spec* spec) {
+ grpc_channel* client;
+ char* client_hostport;
+ char* servers_hostports_str;
request_data rdata;
- servers_fixture *f;
+ servers_fixture* f;
grpc_channel_args args;
grpc_arg arg_array[2];
- rdata.call_details =
- gpr_malloc(sizeof(grpc_call_details) * spec->num_servers);
+ rdata.call_details = static_cast<grpc_call_details*>(
+ gpr_malloc(sizeof(grpc_call_details) * spec->num_servers));
f = setup_servers("127.0.0.1", &rdata, spec->num_servers);
/* Create client. */
- servers_hostports_str = gpr_strjoin_sep((const char **)f->servers_hostports,
- f->num_servers, ",", NULL);
+ servers_hostports_str = gpr_strjoin_sep((const char**)f->servers_hostports,
+ f->num_servers, ",", nullptr);
gpr_asprintf(&client_hostport, "ipv4:%s", servers_hostports_str);
arg_array[0].type = GRPC_ARG_INTEGER;
- arg_array[0].key = "grpc.testing.fixed_reconnect_backoff_ms";
+ arg_array[0].key =
+ const_cast<char*>("grpc.testing.fixed_reconnect_backoff_ms");
arg_array[0].value.integer = RETRY_TIMEOUT;
arg_array[1].type = GRPC_ARG_STRING;
- arg_array[1].key = GRPC_ARG_LB_POLICY_NAME;
- arg_array[1].value.string = "round_robin";
+ arg_array[1].key = const_cast<char*>(GRPC_ARG_LB_POLICY_NAME);
+ arg_array[1].value.string = const_cast<char*>("round_robin");
args.num_args = 2;
args.args = arg_array;
- client = grpc_insecure_channel_create(client_hostport, &args, NULL);
+ client = grpc_insecure_channel_create(client_hostport, &args, nullptr);
gpr_log(GPR_INFO, "Testing '%s' with servers=%s client=%s", spec->description,
servers_hostports_str, client_hostport);
@@ -501,30 +510,32 @@ void run_spec(const test_spec *spec) {
teardown_servers(f);
}
-static grpc_channel *create_client(const servers_fixture *f) {
- grpc_channel *client;
- char *client_hostport;
- char *servers_hostports_str;
+static grpc_channel* create_client(const servers_fixture* f) {
+ grpc_channel* client;
+ char* client_hostport;
+ char* servers_hostports_str;
grpc_arg arg_array[3];
grpc_channel_args args;
- servers_hostports_str = gpr_strjoin_sep((const char **)f->servers_hostports,
- f->num_servers, ",", NULL);
+ servers_hostports_str = gpr_strjoin_sep((const char**)f->servers_hostports,
+ f->num_servers, ",", nullptr);
gpr_asprintf(&client_hostport, "ipv4:%s", servers_hostports_str);
arg_array[0].type = GRPC_ARG_INTEGER;
- arg_array[0].key = "grpc.testing.fixed_reconnect_backoff_ms";
+ arg_array[0].key =
+ const_cast<char*>("grpc.testing.fixed_reconnect_backoff_ms");
arg_array[0].value.integer = RETRY_TIMEOUT;
arg_array[1].type = GRPC_ARG_STRING;
- arg_array[1].key = GRPC_ARG_LB_POLICY_NAME;
- arg_array[1].value.string = "ROUND_ROBIN";
+ arg_array[1].key = const_cast<char*>(GRPC_ARG_LB_POLICY_NAME);
+ arg_array[1].value.string = const_cast<char*>("ROUND_ROBIN");
arg_array[2].type = GRPC_ARG_INTEGER;
- arg_array[2].key = GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS;
+ arg_array[2].key =
+ const_cast<char*>(GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS);
arg_array[2].value.integer = 0;
args.num_args = GPR_ARRAY_SIZE(arg_array);
args.args = arg_array;
- client = grpc_insecure_channel_create(client_hostport, &args, NULL);
+ client = grpc_insecure_channel_create(client_hostport, &args, nullptr);
gpr_free(client_hostport);
gpr_free(servers_hostports_str);
@@ -532,21 +543,22 @@ static grpc_channel *create_client(const servers_fixture *f) {
}
static void test_ping() {
- grpc_channel *client;
+ grpc_channel* client;
request_data rdata;
- servers_fixture *f;
- cq_verifier *cqv;
+ servers_fixture* f;
+ cq_verifier* cqv;
grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
const size_t num_servers = 1;
int i;
- rdata.call_details = gpr_malloc(sizeof(grpc_call_details) * num_servers);
+ rdata.call_details = static_cast<grpc_call_details*>(
+ gpr_malloc(sizeof(grpc_call_details) * num_servers));
f = setup_servers("127.0.0.1", &rdata, num_servers);
cqv = cq_verifier_create(f->cq);
client = create_client(f);
- grpc_channel_ping(client, f->cq, tag(0), NULL);
+ grpc_channel_ping(client, f->cq, tag(0), nullptr);
CQ_EXPECT_COMPLETION(cqv, tag(0), 0);
/* check that we're still in idle, and start connecting */
@@ -566,7 +578,7 @@ static void test_ping() {
}
for (i = 1; i <= 5; i++) {
- grpc_channel_ping(client, f->cq, tag(i), NULL);
+ grpc_channel_ping(client, f->cq, tag(i), nullptr);
CQ_EXPECT_COMPLETION(cqv, tag(i), 1);
cq_verify(cqv);
}
@@ -580,20 +592,19 @@ static void test_ping() {
static void test_pending_calls(size_t concurrent_calls) {
size_t i;
- grpc_call **calls;
- grpc_channel *client;
+ grpc_call** calls;
+ grpc_channel* client;
request_data rdata;
- servers_fixture *f;
- test_spec *spec = test_spec_create(0, 4);
- rdata.call_details =
- gpr_malloc(sizeof(grpc_call_details) * spec->num_servers);
+ servers_fixture* f;
+ test_spec* spec = test_spec_create(0, 4);
+ rdata.call_details = static_cast<grpc_call_details*>(
+ gpr_malloc(sizeof(grpc_call_details) * spec->num_servers));
f = setup_servers("127.0.0.1", &rdata, spec->num_servers);
client = create_client(f);
calls = perform_multirequest(f, client, concurrent_calls);
- grpc_call_cancel(
- calls[0],
- NULL); /* exercise the cancel pick path whilst there are pending picks */
+ grpc_call_cancel(calls[0], nullptr); /* exercise the cancel pick path whilst
+ there are pending picks */
gpr_free(rdata.call_details);
@@ -609,8 +620,8 @@ static void test_pending_calls(size_t concurrent_calls) {
}
static void test_get_channel_info() {
- grpc_channel *channel =
- grpc_insecure_channel_create("ipv4:127.0.0.1:1234", NULL, NULL);
+ grpc_channel* channel =
+ grpc_insecure_channel_create("ipv4:127.0.0.1:1234", nullptr, nullptr);
// Ensures that resolver returns.
grpc_channel_check_connectivity_state(channel, true /* try_to_connect */);
// First, request no fields. This is a no-op.
@@ -618,26 +629,27 @@ static void test_get_channel_info() {
memset(&channel_info, 0, sizeof(channel_info));
grpc_channel_get_info(channel, &channel_info);
// Request LB policy name.
- char *lb_policy_name = NULL;
+ char* lb_policy_name = nullptr;
channel_info.lb_policy_name = &lb_policy_name;
grpc_channel_get_info(channel, &channel_info);
- GPR_ASSERT(lb_policy_name != NULL);
+ GPR_ASSERT(lb_policy_name != nullptr);
GPR_ASSERT(strcmp(lb_policy_name, "pick_first") == 0);
gpr_free(lb_policy_name);
// Request service config, which does not exist, so we'll get nothing back.
memset(&channel_info, 0, sizeof(channel_info));
- char *service_config_json = "dummy_string";
+ char* service_config_json = const_cast<char*>("dummy_string");
channel_info.service_config_json = &service_config_json;
grpc_channel_get_info(channel, &channel_info);
- GPR_ASSERT(service_config_json == NULL);
+ GPR_ASSERT(service_config_json == nullptr);
// Recreate the channel such that it has a service config.
grpc_channel_destroy(channel);
grpc_arg arg;
arg.type = GRPC_ARG_STRING;
- arg.key = GRPC_ARG_SERVICE_CONFIG;
- arg.value.string = "{\"loadBalancingPolicy\": \"ROUND_ROBIN\"}";
- grpc_channel_args *args = grpc_channel_args_copy_and_add(NULL, &arg, 1);
- channel = grpc_insecure_channel_create("ipv4:127.0.0.1:1234", args, NULL);
+ arg.key = const_cast<char*>(GRPC_ARG_SERVICE_CONFIG);
+ arg.value.string =
+ const_cast<char*>("{\"loadBalancingPolicy\": \"ROUND_ROBIN\"}");
+ grpc_channel_args* args = grpc_channel_args_copy_and_add(nullptr, &arg, 1);
+ channel = grpc_insecure_channel_create("ipv4:127.0.0.1:1234", args, nullptr);
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
grpc_channel_args_destroy(&exec_ctx, args);
@@ -647,15 +659,15 @@ static void test_get_channel_info() {
grpc_channel_check_connectivity_state(channel, true /* try_to_connect */);
// Now request the service config again.
grpc_channel_get_info(channel, &channel_info);
- GPR_ASSERT(service_config_json != NULL);
+ GPR_ASSERT(service_config_json != nullptr);
GPR_ASSERT(strcmp(service_config_json, arg.value.string) == 0);
gpr_free(service_config_json);
// Clean up.
grpc_channel_destroy(channel);
}
-static void print_failed_expectations(const int *expected_connection_sequence,
- const int *actual_connection_sequence,
+static void print_failed_expectations(const int* expected_connection_sequence,
+ const int* actual_connection_sequence,
const size_t expected_seq_length,
const size_t num_iters) {
size_t i;
@@ -667,16 +679,16 @@ static void print_failed_expectations(const int *expected_connection_sequence,
}
}
-static void verify_vanilla_round_robin(const servers_fixture *f,
- grpc_channel *client,
- const request_sequences *sequences,
+static void verify_vanilla_round_robin(const servers_fixture* f,
+ grpc_channel* client,
+ const request_sequences* sequences,
const size_t num_iters) {
const size_t expected_seq_length = f->num_servers;
/* verify conn. seq. expectation */
/* get the first sequence of "num_servers" elements */
- int *expected_connection_sequence =
- gpr_malloc(sizeof(int) * expected_seq_length);
+ int* expected_connection_sequence =
+ static_cast<int*>(gpr_malloc(sizeof(int) * expected_seq_length));
memcpy(expected_connection_sequence, sequences->connections,
sizeof(int) * expected_seq_length);
@@ -695,7 +707,8 @@ static void verify_vanilla_round_robin(const servers_fixture *f,
/* All servers are available, therefore all client subchannels are READY, even
* when we only need one for the client channel state to be READY */
for (size_t i = 0; i < sequences->n; i++) {
- const grpc_connectivity_state actual = sequences->connectivity_states[i];
+ const grpc_connectivity_state actual =
+ static_cast<grpc_connectivity_state>(sequences->connectivity_states[i]);
const grpc_connectivity_state expected = GRPC_CHANNEL_READY;
if (actual != expected) {
gpr_log(GPR_ERROR,
@@ -713,15 +726,16 @@ static void verify_vanilla_round_robin(const servers_fixture *f,
/* At the start of the second iteration, all but the first and last servers (as
* given in "f") are killed */
static void verify_vanishing_floor_round_robin(
- const servers_fixture *f, grpc_channel *client,
- const request_sequences *sequences, const size_t num_iters) {
- int *expected_connection_sequence;
+ const servers_fixture* f, grpc_channel* client,
+ const request_sequences* sequences, const size_t num_iters) {
+ int* expected_connection_sequence;
const size_t expected_seq_length = 2;
size_t i;
/* verify conn. seq. expectation */
/* copy the first full sequence (without -1s) */
- expected_connection_sequence = gpr_malloc(sizeof(int) * expected_seq_length);
+ expected_connection_sequence =
+ static_cast<int*>(gpr_malloc(sizeof(int) * expected_seq_length));
memcpy(expected_connection_sequence, sequences->connections + 2,
expected_seq_length * sizeof(int));
@@ -750,7 +764,8 @@ static void verify_vanishing_floor_round_robin(
/* There's always at least one subchannel READY (connected), therefore the
* overall state of the client channel is READY at all times. */
for (i = 0; i < sequences->n; i++) {
- const grpc_connectivity_state actual = sequences->connectivity_states[i];
+ const grpc_connectivity_state actual =
+ static_cast<grpc_connectivity_state>(sequences->connectivity_states[i]);
const grpc_connectivity_state expected = GRPC_CHANNEL_READY;
if (actual != expected) {
gpr_log(GPR_ERROR,
@@ -765,9 +780,9 @@ static void verify_vanishing_floor_round_robin(
gpr_free(expected_connection_sequence);
}
-static void verify_total_carnage_round_robin(const servers_fixture *f,
- grpc_channel *client,
- const request_sequences *sequences,
+static void verify_total_carnage_round_robin(const servers_fixture* f,
+ grpc_channel* client,
+ const request_sequences* sequences,
const size_t num_iters) {
for (size_t i = 0; i < num_iters; i++) {
const int actual = sequences->connections[i];
@@ -785,7 +800,8 @@ static void verify_total_carnage_round_robin(const servers_fixture *f,
* Note that all other states (IDLE, CONNECTING, TRANSIENT_FAILURE) are still
* possible, as the policy transitions while attempting to reconnect. */
for (size_t i = 0; i < sequences->n; i++) {
- const grpc_connectivity_state actual = sequences->connectivity_states[i];
+ const grpc_connectivity_state actual =
+ static_cast<grpc_connectivity_state>(sequences->connectivity_states[i]);
if (actual == GRPC_CHANNEL_READY || actual == GRPC_CHANNEL_SHUTDOWN) {
gpr_log(GPR_ERROR,
"CONNECTIVITY STATUS SEQUENCE FAILURE: got unexpected state "
@@ -797,15 +813,16 @@ static void verify_total_carnage_round_robin(const servers_fixture *f,
}
static void verify_partial_carnage_round_robin(
- const servers_fixture *f, grpc_channel *client,
- const request_sequences *sequences, const size_t num_iters) {
- int *expected_connection_sequence;
+ const servers_fixture* f, grpc_channel* client,
+ const request_sequences* sequences, const size_t num_iters) {
+ int* expected_connection_sequence;
size_t i;
const size_t expected_seq_length = f->num_servers;
/* verify conn. seq. expectation */
/* get the first sequence of "num_servers" elements */
- expected_connection_sequence = gpr_malloc(sizeof(int) * expected_seq_length);
+ expected_connection_sequence =
+ static_cast<int*>(gpr_malloc(sizeof(int) * expected_seq_length));
memcpy(expected_connection_sequence, sequences->connections,
sizeof(int) * expected_seq_length);
@@ -827,7 +844,8 @@ static void verify_partial_carnage_round_robin(
/* We can assert that the first client channel state should be READY, when all
* servers were available */
- grpc_connectivity_state actual = sequences->connectivity_states[0];
+ grpc_connectivity_state actual =
+ static_cast<grpc_connectivity_state>(sequences->connectivity_states[0]);
grpc_connectivity_state expected = GRPC_CHANNEL_READY;
if (actual != expected) {
gpr_log(GPR_ERROR,
@@ -841,7 +859,8 @@ static void verify_partial_carnage_round_robin(
/* ... and that the last one shouldn't be READY (or SHUTDOWN): all servers are
* gone. It may be all other states (IDLE, CONNECTING, TRANSIENT_FAILURE), as
* the policy transitions while attempting to reconnect. */
- actual = sequences->connectivity_states[num_iters - 1];
+ actual = static_cast<grpc_connectivity_state>(
+ sequences->connectivity_states[num_iters - 1]);
for (i = 0; i < sequences->n; i++) {
if (actual == GRPC_CHANNEL_READY || actual == GRPC_CHANNEL_SHUTDOWN) {
gpr_log(GPR_ERROR,
@@ -854,9 +873,9 @@ static void verify_partial_carnage_round_robin(
gpr_free(expected_connection_sequence);
}
-static void dump_array(const char *desc, const int *data, const size_t count) {
+static void dump_array(const char* desc, const int* data, const size_t count) {
gpr_strvec s;
- char *tmp;
+ char* tmp;
size_t i;
gpr_strvec_init(&s);
gpr_strvec_add(&s, gpr_strdup(desc));
@@ -865,15 +884,15 @@ static void dump_array(const char *desc, const int *data, const size_t count) {
gpr_asprintf(&tmp, " %d", data[i]);
gpr_strvec_add(&s, tmp);
}
- tmp = gpr_strvec_flatten(&s, NULL);
+ tmp = gpr_strvec_flatten(&s, nullptr);
gpr_strvec_destroy(&s);
gpr_log(GPR_DEBUG, "%s", tmp);
gpr_free(tmp);
}
-static void verify_rebirth_round_robin(const servers_fixture *f,
- grpc_channel *client,
- const request_sequences *sequences,
+static void verify_rebirth_round_robin(const servers_fixture* f,
+ grpc_channel* client,
+ const request_sequences* sequences,
const size_t num_iters) {
dump_array("actual_connection_sequence", sequences->connections, num_iters);
@@ -894,7 +913,8 @@ static void verify_rebirth_round_robin(const servers_fixture *f,
/* We can assert that the first client channel state should be READY, when all
* servers were available; same thing for the last one. In the middle
* somewhere there must exist at least one TRANSIENT_FAILURE */
- grpc_connectivity_state actual = sequences->connectivity_states[0];
+ grpc_connectivity_state actual =
+ static_cast<grpc_connectivity_state>(sequences->connectivity_states[0]);
grpc_connectivity_state expected = GRPC_CHANNEL_READY;
if (actual != expected) {
gpr_log(GPR_ERROR,
@@ -905,7 +925,8 @@ static void verify_rebirth_round_robin(const servers_fixture *f,
abort();
}
- actual = sequences->connectivity_states[num_iters - 1];
+ actual = static_cast<grpc_connectivity_state>(
+ sequences->connectivity_states[num_iters - 1]);
expected = GRPC_CHANNEL_READY;
if (actual != expected) {
gpr_log(GPR_ERROR,
@@ -931,14 +952,15 @@ static void verify_rebirth_round_robin(const servers_fixture *f,
"instead:");
for (size_t i = 0; i < num_iters; i++) {
gpr_log(GPR_ERROR, "[%d]: %s", (int)i,
- grpc_connectivity_state_name(sequences->connectivity_states[i]));
+ grpc_connectivity_state_name(static_cast<grpc_connectivity_state>(
+ sequences->connectivity_states[i])));
}
}
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- test_spec *spec;
+ test_spec* spec;
size_t i;
const size_t NUM_ITERS = 10;
const size_t NUM_SERVERS = 4;
@@ -948,8 +970,8 @@ int main(int argc, char **argv) {
grpc_tracer_set_enabled("round_robin", 1);
GPR_ASSERT(grpc_lb_policy_create(&exec_ctx, "this-lb-policy-does-not-exist",
- NULL) == NULL);
- GPR_ASSERT(grpc_lb_policy_create(&exec_ctx, NULL, NULL) == NULL);
+ nullptr) == nullptr);
+ GPR_ASSERT(grpc_lb_policy_create(&exec_ctx, nullptr, nullptr) == nullptr);
spec = test_spec_create(NUM_ITERS, NUM_SERVERS);
/* everything is fine, all servers stay up the whole time and life's peachy
diff --git a/test/core/client_channel/parse_address_test.c b/test/core/client_channel/parse_address_test.cc
index d011176869..94f76da920 100644
--- a/test/core/client_channel/parse_address_test.c
+++ b/test/core/client_channel/parse_address_test.cc
@@ -32,13 +32,13 @@
#ifdef GRPC_HAVE_UNIX_SOCKET
-static void test_grpc_parse_unix(const char *uri_text, const char *pathname) {
+static void test_grpc_parse_unix(const char* uri_text, const char* pathname) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+ grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
grpc_resolved_address addr;
GPR_ASSERT(1 == grpc_parse_unix(uri, &addr));
- struct sockaddr_un *addr_un = (struct sockaddr_un *)addr.addr;
+ struct sockaddr_un* addr_un = (struct sockaddr_un*)addr.addr;
GPR_ASSERT(AF_UNIX == addr_un->sun_family);
GPR_ASSERT(0 == strcmp(addr_un->sun_path, pathname));
@@ -48,22 +48,22 @@ static void test_grpc_parse_unix(const char *uri_text, const char *pathname) {
#else /* GRPC_HAVE_UNIX_SOCKET */
-static void test_grpc_parse_unix(const char *uri_text, const char *pathname) {}
+static void test_grpc_parse_unix(const char* uri_text, const char* pathname) {}
#endif /* GRPC_HAVE_UNIX_SOCKET */
-static void test_grpc_parse_ipv4(const char *uri_text, const char *host,
+static void test_grpc_parse_ipv4(const char* uri_text, const char* host,
unsigned short port) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+ grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
grpc_resolved_address addr;
char ntop_buf[INET_ADDRSTRLEN];
GPR_ASSERT(1 == grpc_parse_ipv4(uri, &addr));
- struct sockaddr_in *addr_in = (struct sockaddr_in *)addr.addr;
+ struct sockaddr_in* addr_in = (struct sockaddr_in*)addr.addr;
GPR_ASSERT(AF_INET == addr_in->sin_family);
- GPR_ASSERT(NULL != grpc_inet_ntop(AF_INET, &addr_in->sin_addr, ntop_buf,
- sizeof(ntop_buf)));
+ GPR_ASSERT(nullptr != grpc_inet_ntop(AF_INET, &addr_in->sin_addr, ntop_buf,
+ sizeof(ntop_buf)));
GPR_ASSERT(0 == strcmp(ntop_buf, host));
GPR_ASSERT(ntohs(addr_in->sin_port) == port);
@@ -71,18 +71,18 @@ static void test_grpc_parse_ipv4(const char *uri_text, const char *host,
grpc_exec_ctx_finish(&exec_ctx);
}
-static void test_grpc_parse_ipv6(const char *uri_text, const char *host,
+static void test_grpc_parse_ipv6(const char* uri_text, const char* host,
unsigned short port, uint32_t scope_id) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+ grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
grpc_resolved_address addr;
char ntop_buf[INET6_ADDRSTRLEN];
GPR_ASSERT(1 == grpc_parse_ipv6(uri, &addr));
- struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)addr.addr;
+ struct sockaddr_in6* addr_in6 = (struct sockaddr_in6*)addr.addr;
GPR_ASSERT(AF_INET6 == addr_in6->sin6_family);
- GPR_ASSERT(NULL != grpc_inet_ntop(AF_INET6, &addr_in6->sin6_addr, ntop_buf,
- sizeof(ntop_buf)));
+ GPR_ASSERT(nullptr != grpc_inet_ntop(AF_INET6, &addr_in6->sin6_addr, ntop_buf,
+ sizeof(ntop_buf)));
GPR_ASSERT(0 == strcmp(ntop_buf, host));
GPR_ASSERT(ntohs(addr_in6->sin6_port) == port);
GPR_ASSERT(addr_in6->sin6_scope_id == scope_id);
@@ -91,7 +91,7 @@ static void test_grpc_parse_ipv6(const char *uri_text, const char *host,
grpc_exec_ctx_finish(&exec_ctx);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
test_grpc_parse_unix("unix:/path/name", "/path/name");
diff --git a/test/core/client_channel/resolvers/BUILD b/test/core/client_channel/resolvers/BUILD
index 0907e06623..b5269c7ef0 100644
--- a/test/core/client_channel/resolvers/BUILD
+++ b/test/core/client_channel/resolvers/BUILD
@@ -20,8 +20,8 @@ licenses(["notice"]) # Apache v2
grpc_cc_test(
name = "dns_resolver_connectivity_test",
- srcs = ["dns_resolver_connectivity_test.c"],
- language = "C",
+ srcs = ["dns_resolver_connectivity_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -32,8 +32,8 @@ grpc_cc_test(
grpc_cc_test(
name = "dns_resolver_test",
- srcs = ["dns_resolver_test.c"],
- language = "C",
+ srcs = ["dns_resolver_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -44,8 +44,8 @@ grpc_cc_test(
grpc_cc_test(
name = "sockaddr_resolver_test",
- srcs = ["sockaddr_resolver_test.c"],
- language = "C",
+ srcs = ["sockaddr_resolver_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
@@ -56,8 +56,8 @@ grpc_cc_test(
grpc_cc_test(
name = "fake_resolver_test",
- srcs = ["fake_resolver_test.c"],
- language = "C",
+ srcs = ["fake_resolver_test.cc"],
+ language = "C++",
deps = [
"//:gpr",
"//:grpc",
diff --git a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc
index 4597285063..dcf315eba5 100644
--- a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc
@@ -33,114 +33,117 @@
static gpr_mu g_mu;
static bool g_fail_resolution = true;
-static grpc_combiner *g_combiner;
+static grpc_combiner* g_combiner;
-static void my_resolve_address(grpc_exec_ctx *exec_ctx, const char *addr,
- const char *default_port,
- grpc_pollset_set *interested_parties,
- grpc_closure *on_done,
- grpc_resolved_addresses **addrs) {
+static void my_resolve_address(grpc_exec_ctx* exec_ctx, const char* addr,
+ const char* default_port,
+ grpc_pollset_set* interested_parties,
+ grpc_closure* on_done,
+ grpc_resolved_addresses** addrs) {
gpr_mu_lock(&g_mu);
GPR_ASSERT(0 == strcmp("test", addr));
- grpc_error *error = GRPC_ERROR_NONE;
+ grpc_error* error = GRPC_ERROR_NONE;
if (g_fail_resolution) {
g_fail_resolution = false;
gpr_mu_unlock(&g_mu);
error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Forced Failure");
} else {
gpr_mu_unlock(&g_mu);
- *addrs = gpr_malloc(sizeof(**addrs));
+ *addrs = static_cast<grpc_resolved_addresses*>(gpr_malloc(sizeof(**addrs)));
(*addrs)->naddrs = 1;
- (*addrs)->addrs = gpr_malloc(sizeof(*(*addrs)->addrs));
+ (*addrs)->addrs = static_cast<grpc_resolved_address*>(
+ gpr_malloc(sizeof(*(*addrs)->addrs)));
(*addrs)->addrs[0].len = 123;
}
GRPC_CLOSURE_SCHED(exec_ctx, on_done, error);
}
-static grpc_ares_request *my_dns_lookup_ares(
- grpc_exec_ctx *exec_ctx, const char *dns_server, const char *addr,
- const char *default_port, grpc_pollset_set *interested_parties,
- grpc_closure *on_done, grpc_lb_addresses **lb_addrs, bool check_grpclb,
- char **service_config_json) {
+static grpc_ares_request* my_dns_lookup_ares(
+ grpc_exec_ctx* exec_ctx, const char* dns_server, const char* addr,
+ const char* default_port, grpc_pollset_set* interested_parties,
+ grpc_closure* on_done, grpc_lb_addresses** lb_addrs, bool check_grpclb,
+ char** service_config_json) {
gpr_mu_lock(&g_mu);
GPR_ASSERT(0 == strcmp("test", addr));
- grpc_error *error = GRPC_ERROR_NONE;
+ grpc_error* error = GRPC_ERROR_NONE;
if (g_fail_resolution) {
g_fail_resolution = false;
gpr_mu_unlock(&g_mu);
error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Forced Failure");
} else {
gpr_mu_unlock(&g_mu);
- *lb_addrs = grpc_lb_addresses_create(1, NULL);
- grpc_lb_addresses_set_address(*lb_addrs, 0, NULL, 0, false, NULL, NULL);
+ *lb_addrs = grpc_lb_addresses_create(1, nullptr);
+ grpc_lb_addresses_set_address(*lb_addrs, 0, nullptr, 0, false, nullptr,
+ nullptr);
}
GRPC_CLOSURE_SCHED(exec_ctx, on_done, error);
- return NULL;
+ return nullptr;
}
-static grpc_resolver *create_resolver(grpc_exec_ctx *exec_ctx,
- const char *name) {
- grpc_resolver_factory *factory = grpc_resolver_factory_lookup("dns");
- grpc_uri *uri = grpc_uri_parse(exec_ctx, name, 0);
+static grpc_resolver* create_resolver(grpc_exec_ctx* exec_ctx,
+ const char* name) {
+ grpc_resolver_factory* factory = grpc_resolver_factory_lookup("dns");
+ grpc_uri* uri = grpc_uri_parse(exec_ctx, name, 0);
GPR_ASSERT(uri);
grpc_resolver_args args;
memset(&args, 0, sizeof(args));
args.uri = uri;
args.combiner = g_combiner;
- grpc_resolver *resolver =
+ grpc_resolver* resolver =
grpc_resolver_factory_create_resolver(exec_ctx, factory, &args);
grpc_resolver_factory_unref(factory);
grpc_uri_destroy(uri);
return resolver;
}
-static void on_done(grpc_exec_ctx *exec_ctx, void *ev, grpc_error *error) {
- gpr_event_set(ev, (void *)1);
+static void on_done(grpc_exec_ctx* exec_ctx, void* ev, grpc_error* error) {
+ gpr_event_set((gpr_event*)ev, (void*)1);
}
// interleave waiting for an event with a timer check
-static bool wait_loop(int deadline_seconds, gpr_event *ev) {
+static bool wait_loop(int deadline_seconds, gpr_event* ev) {
while (deadline_seconds) {
gpr_log(GPR_DEBUG, "Test: waiting for %d more seconds", deadline_seconds);
if (gpr_event_wait(ev, grpc_timeout_seconds_to_deadline(1))) return true;
deadline_seconds--;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_timer_check(&exec_ctx, NULL);
+ grpc_timer_check(&exec_ctx, nullptr);
grpc_exec_ctx_finish(&exec_ctx);
}
return false;
}
typedef struct next_args {
- grpc_resolver *resolver;
- grpc_channel_args **result;
- grpc_closure *on_complete;
+ grpc_resolver* resolver;
+ grpc_channel_args** result;
+ grpc_closure* on_complete;
} next_args;
-static void call_resolver_next_now_lock_taken(grpc_exec_ctx *exec_ctx,
- void *arg,
- grpc_error *error_unused) {
- next_args *a = arg;
+static void call_resolver_next_now_lock_taken(grpc_exec_ctx* exec_ctx,
+ void* arg,
+ grpc_error* error_unused) {
+ next_args* a = static_cast<next_args*>(arg);
grpc_resolver_next_locked(exec_ctx, a->resolver, a->result, a->on_complete);
gpr_free(a);
}
-static void call_resolver_next_after_locking(grpc_exec_ctx *exec_ctx,
- grpc_resolver *resolver,
- grpc_channel_args **result,
- grpc_closure *on_complete) {
- next_args *a = gpr_malloc(sizeof(*a));
+static void call_resolver_next_after_locking(grpc_exec_ctx* exec_ctx,
+ grpc_resolver* resolver,
+ grpc_channel_args** result,
+ grpc_closure* on_complete) {
+ next_args* a = static_cast<next_args*>(gpr_malloc(sizeof(*a)));
a->resolver = resolver;
a->result = result;
a->on_complete = on_complete;
- GRPC_CLOSURE_SCHED(exec_ctx, GRPC_CLOSURE_CREATE(
- call_resolver_next_now_lock_taken, a,
- grpc_combiner_scheduler(resolver->combiner)),
- GRPC_ERROR_NONE);
+ GRPC_CLOSURE_SCHED(
+ exec_ctx,
+ GRPC_CLOSURE_CREATE(call_resolver_next_now_lock_taken, a,
+ grpc_combiner_scheduler(resolver->combiner)),
+ GRPC_ERROR_NONE);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
grpc_init();
@@ -148,10 +151,10 @@ int main(int argc, char **argv) {
g_combiner = grpc_combiner_create();
grpc_resolve_address = my_resolve_address;
grpc_dns_lookup_ares = my_dns_lookup_ares;
- grpc_channel_args *result = (grpc_channel_args *)1;
+ grpc_channel_args* result = (grpc_channel_args*)1;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_resolver *resolver = create_resolver(&exec_ctx, "dns:test");
+ grpc_resolver* resolver = create_resolver(&exec_ctx, "dns:test");
gpr_event ev1;
gpr_event_init(&ev1);
call_resolver_next_after_locking(
@@ -159,7 +162,7 @@ int main(int argc, char **argv) {
GRPC_CLOSURE_CREATE(on_done, &ev1, grpc_schedule_on_exec_ctx));
grpc_exec_ctx_flush(&exec_ctx);
GPR_ASSERT(wait_loop(5, &ev1));
- GPR_ASSERT(result == NULL);
+ GPR_ASSERT(result == nullptr);
gpr_event ev2;
gpr_event_init(&ev2);
@@ -168,7 +171,7 @@ int main(int argc, char **argv) {
GRPC_CLOSURE_CREATE(on_done, &ev2, grpc_schedule_on_exec_ctx));
grpc_exec_ctx_flush(&exec_ctx);
GPR_ASSERT(wait_loop(30, &ev2));
- GPR_ASSERT(result != NULL);
+ GPR_ASSERT(result != nullptr);
grpc_channel_args_destroy(&exec_ctx, result);
GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "test");
diff --git a/test/core/client_channel/resolvers/dns_resolver_test.c b/test/core/client_channel/resolvers/dns_resolver_test.cc
index a14926f173..4c040caeb9 100644
--- a/test/core/client_channel/resolvers/dns_resolver_test.c
+++ b/test/core/client_channel/resolvers/dns_resolver_test.cc
@@ -25,13 +25,13 @@
#include "src/core/lib/iomgr/combiner.h"
#include "test/core/util/test_config.h"
-static grpc_combiner *g_combiner;
+static grpc_combiner* g_combiner;
-static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
+static void test_succeeds(grpc_resolver_factory* factory, const char* string) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_uri *uri = grpc_uri_parse(&exec_ctx, string, 0);
+ grpc_uri* uri = grpc_uri_parse(&exec_ctx, string, 0);
grpc_resolver_args args;
- grpc_resolver *resolver;
+ grpc_resolver* resolver;
gpr_log(GPR_DEBUG, "test: '%s' should be valid for '%s'", string,
factory->vtable->scheme);
GPR_ASSERT(uri);
@@ -39,17 +39,17 @@ static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
args.uri = uri;
args.combiner = g_combiner;
resolver = grpc_resolver_factory_create_resolver(&exec_ctx, factory, &args);
- GPR_ASSERT(resolver != NULL);
+ GPR_ASSERT(resolver != nullptr);
GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "test_succeeds");
grpc_uri_destroy(uri);
grpc_exec_ctx_finish(&exec_ctx);
}
-static void test_fails(grpc_resolver_factory *factory, const char *string) {
+static void test_fails(grpc_resolver_factory* factory, const char* string) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_uri *uri = grpc_uri_parse(&exec_ctx, string, 0);
+ grpc_uri* uri = grpc_uri_parse(&exec_ctx, string, 0);
grpc_resolver_args args;
- grpc_resolver *resolver;
+ grpc_resolver* resolver;
gpr_log(GPR_DEBUG, "test: '%s' should be invalid for '%s'", string,
factory->vtable->scheme);
GPR_ASSERT(uri);
@@ -57,13 +57,13 @@ static void test_fails(grpc_resolver_factory *factory, const char *string) {
args.uri = uri;
args.combiner = g_combiner;
resolver = grpc_resolver_factory_create_resolver(&exec_ctx, factory, &args);
- GPR_ASSERT(resolver == NULL);
+ GPR_ASSERT(resolver == nullptr);
grpc_uri_destroy(uri);
grpc_exec_ctx_finish(&exec_ctx);
}
-int main(int argc, char **argv) {
- grpc_resolver_factory *dns;
+int main(int argc, char** argv) {
+ grpc_resolver_factory* dns;
grpc_test_init(argc, argv);
grpc_init();
diff --git a/test/core/client_channel/resolvers/fake_resolver_test.c b/test/core/client_channel/resolvers/fake_resolver_test.cc
index 9b0854d6d8..d5538e9621 100644
--- a/test/core/client_channel/resolvers/fake_resolver_test.c
+++ b/test/core/client_channel/resolvers/fake_resolver_test.cc
@@ -32,10 +32,10 @@
#include "test/core/util/test_config.h"
-static grpc_resolver *build_fake_resolver(
- grpc_exec_ctx *exec_ctx, grpc_combiner *combiner,
- grpc_fake_resolver_response_generator *response_generator) {
- grpc_resolver_factory *factory = grpc_resolver_factory_lookup("fake");
+static grpc_resolver* build_fake_resolver(
+ grpc_exec_ctx* exec_ctx, grpc_combiner* combiner,
+ grpc_fake_resolver_response_generator* response_generator) {
+ grpc_resolver_factory* factory = grpc_resolver_factory_lookup("fake");
grpc_arg generator_arg =
grpc_fake_resolver_response_generator_arg(response_generator);
grpc_resolver_args args;
@@ -43,65 +43,65 @@ static grpc_resolver *build_fake_resolver(
grpc_channel_args channel_args = {1, &generator_arg};
args.args = &channel_args;
args.combiner = combiner;
- grpc_resolver *resolver =
+ grpc_resolver* resolver =
grpc_resolver_factory_create_resolver(exec_ctx, factory, &args);
grpc_resolver_factory_unref(factory);
return resolver;
}
typedef struct on_resolution_arg {
- grpc_channel_args *resolver_result;
- grpc_channel_args *expected_resolver_result;
+ grpc_channel_args* resolver_result;
+ grpc_channel_args* expected_resolver_result;
gpr_event ev;
} on_resolution_arg;
-void on_resolution_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
- on_resolution_arg *res = arg;
+void on_resolution_cb(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+ on_resolution_arg* res = static_cast<on_resolution_arg*>(arg);
// We only check the addresses channel arg because that's the only one
// explicitly set by the test via
// grpc_fake_resolver_response_generator_set_response.
- const grpc_lb_addresses *actual_lb_addresses =
+ const grpc_lb_addresses* actual_lb_addresses =
grpc_lb_addresses_find_channel_arg(res->resolver_result);
- const grpc_lb_addresses *expected_lb_addresses =
+ const grpc_lb_addresses* expected_lb_addresses =
grpc_lb_addresses_find_channel_arg(res->expected_resolver_result);
GPR_ASSERT(
grpc_lb_addresses_cmp(actual_lb_addresses, expected_lb_addresses) == 0);
grpc_channel_args_destroy(exec_ctx, res->resolver_result);
grpc_channel_args_destroy(exec_ctx, res->expected_resolver_result);
- gpr_event_set(&res->ev, (void *)1);
+ gpr_event_set(&res->ev, (void*)1);
}
static void test_fake_resolver() {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_combiner *combiner = grpc_combiner_create();
+ grpc_combiner* combiner = grpc_combiner_create();
// Create resolver.
- grpc_fake_resolver_response_generator *response_generator =
+ grpc_fake_resolver_response_generator* response_generator =
grpc_fake_resolver_response_generator_create();
- grpc_resolver *resolver =
+ grpc_resolver* resolver =
build_fake_resolver(&exec_ctx, combiner, response_generator);
- GPR_ASSERT(resolver != NULL);
+ GPR_ASSERT(resolver != nullptr);
// Setup expectations.
- grpc_uri *uris[] = {grpc_uri_parse(&exec_ctx, "ipv4:10.2.1.1:1234", true),
+ grpc_uri* uris[] = {grpc_uri_parse(&exec_ctx, "ipv4:10.2.1.1:1234", true),
grpc_uri_parse(&exec_ctx, "ipv4:127.0.0.1:4321", true)};
- char *balancer_names[] = {"name1", "name2"};
+ const char* balancer_names[] = {"name1", "name2"};
const bool is_balancer[] = {true, false};
- grpc_lb_addresses *addresses = grpc_lb_addresses_create(3, NULL);
+ grpc_lb_addresses* addresses = grpc_lb_addresses_create(3, nullptr);
for (size_t i = 0; i < GPR_ARRAY_SIZE(uris); ++i) {
grpc_lb_addresses_set_address_from_uri(
- addresses, i, uris[i], is_balancer[i], balancer_names[i], NULL);
+ addresses, i, uris[i], is_balancer[i], balancer_names[i], nullptr);
grpc_uri_destroy(uris[i]);
}
const grpc_arg addresses_arg =
grpc_lb_addresses_create_channel_arg(addresses);
- grpc_channel_args *results =
- grpc_channel_args_copy_and_add(NULL, &addresses_arg, 1);
+ grpc_channel_args* results =
+ grpc_channel_args_copy_and_add(nullptr, &addresses_arg, 1);
grpc_lb_addresses_destroy(&exec_ctx, addresses);
on_resolution_arg on_res_arg;
memset(&on_res_arg, 0, sizeof(on_res_arg));
on_res_arg.expected_resolver_result = results;
gpr_event_init(&on_res_arg.ev);
- grpc_closure *on_resolution = GRPC_CLOSURE_CREATE(
+ grpc_closure* on_resolution = GRPC_CLOSURE_CREATE(
on_resolution_cb, &on_res_arg, grpc_combiner_scheduler(combiner));
// Set resolver results and trigger first resolution. on_resolution_cb
@@ -112,25 +112,25 @@ static void test_fake_resolver() {
on_resolution);
grpc_exec_ctx_flush(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&on_res_arg.ev,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
// Setup update.
- grpc_uri *uris_update[] = {
+ grpc_uri* uris_update[] = {
grpc_uri_parse(&exec_ctx, "ipv4:192.168.1.0:31416", true)};
- char *balancer_names_update[] = {"name3"};
+ const char* balancer_names_update[] = {"name3"};
const bool is_balancer_update[] = {false};
- grpc_lb_addresses *addresses_update = grpc_lb_addresses_create(1, NULL);
+ grpc_lb_addresses* addresses_update = grpc_lb_addresses_create(1, nullptr);
for (size_t i = 0; i < GPR_ARRAY_SIZE(uris_update); ++i) {
grpc_lb_addresses_set_address_from_uri(addresses_update, i, uris_update[i],
is_balancer_update[i],
- balancer_names_update[i], NULL);
+ balancer_names_update[i], nullptr);
grpc_uri_destroy(uris_update[i]);
}
grpc_arg addresses_update_arg =
grpc_lb_addresses_create_channel_arg(addresses_update);
- grpc_channel_args *results_update =
- grpc_channel_args_copy_and_add(NULL, &addresses_update_arg, 1);
+ grpc_channel_args* results_update =
+ grpc_channel_args_copy_and_add(nullptr, &addresses_update_arg, 1);
grpc_lb_addresses_destroy(&exec_ctx, addresses_update);
// Setup expectations for the update.
@@ -148,7 +148,7 @@ static void test_fake_resolver() {
&on_res_arg_update.resolver_result, on_resolution);
grpc_exec_ctx_flush(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&on_res_arg_update.ev,
- grpc_timeout_seconds_to_deadline(5)) != NULL);
+ grpc_timeout_seconds_to_deadline(5)) != nullptr);
// Requesting a new resolution without re-senting the response shouldn't
// trigger the resolution callback.
@@ -158,7 +158,7 @@ static void test_fake_resolver() {
grpc_exec_ctx_flush(&exec_ctx);
GPR_ASSERT(gpr_event_wait(&on_res_arg.ev,
grpc_timeout_milliseconds_to_deadline(100)) ==
- NULL);
+ nullptr);
GRPC_COMBINER_UNREF(&exec_ctx, combiner, "test_fake_resolver");
GRPC_RESOLVER_UNREF(&exec_ctx, resolver, "test_fake_resolver");
@@ -166,7 +166,7 @@ static void test_fake_resolver() {
grpc_fake_resolver_response_generator_unref(response_generator);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
grpc_init();
diff --git a/test/core/client_channel/resolvers/sockaddr_resolver_test.c b/test/core/client_channel/resolvers/sockaddr_resolver_test.cc
index 8b88619164..dfa2d12b5e 100644
--- a/test/core/client_channel/resolvers/sockaddr_resolver_test.c
+++ b/test/core/client_channel/resolvers/sockaddr_resolver_test.cc
@@ -28,23 +28,23 @@
#include "test/core/util/test_config.h"
-static grpc_combiner *g_combiner;
+static grpc_combiner* g_combiner;
typedef struct on_resolution_arg {
- char *expected_server_name;
- grpc_channel_args *resolver_result;
+ char* expected_server_name;
+ grpc_channel_args* resolver_result;
} on_resolution_arg;
-void on_resolution_cb(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
- on_resolution_arg *res = arg;
+void on_resolution_cb(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+ on_resolution_arg* res = static_cast<on_resolution_arg*>(arg);
grpc_channel_args_destroy(exec_ctx, res->resolver_result);
}
-static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
+static void test_succeeds(grpc_resolver_factory* factory, const char* string) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_uri *uri = grpc_uri_parse(&exec_ctx, string, 0);
+ grpc_uri* uri = grpc_uri_parse(&exec_ctx, string, 0);
grpc_resolver_args args;
- grpc_resolver *resolver;
+ grpc_resolver* resolver;
gpr_log(GPR_DEBUG, "test: '%s' should be valid for '%s'", string,
factory->vtable->scheme);
GPR_ASSERT(uri);
@@ -52,12 +52,12 @@ static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
args.uri = uri;
args.combiner = g_combiner;
resolver = grpc_resolver_factory_create_resolver(&exec_ctx, factory, &args);
- GPR_ASSERT(resolver != NULL);
+ GPR_ASSERT(resolver != nullptr);
on_resolution_arg on_res_arg;
memset(&on_res_arg, 0, sizeof(on_res_arg));
on_res_arg.expected_server_name = uri->path;
- grpc_closure *on_resolution = GRPC_CLOSURE_CREATE(
+ grpc_closure* on_resolution = GRPC_CLOSURE_CREATE(
on_resolution_cb, &on_res_arg, grpc_schedule_on_exec_ctx);
grpc_resolver_next_locked(&exec_ctx, resolver, &on_res_arg.resolver_result,
@@ -67,11 +67,11 @@ static void test_succeeds(grpc_resolver_factory *factory, const char *string) {
grpc_uri_destroy(uri);
}
-static void test_fails(grpc_resolver_factory *factory, const char *string) {
+static void test_fails(grpc_resolver_factory* factory, const char* string) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_uri *uri = grpc_uri_parse(&exec_ctx, string, 0);
+ grpc_uri* uri = grpc_uri_parse(&exec_ctx, string, 0);
grpc_resolver_args args;
- grpc_resolver *resolver;
+ grpc_resolver* resolver;
gpr_log(GPR_DEBUG, "test: '%s' should be invalid for '%s'", string,
factory->vtable->scheme);
GPR_ASSERT(uri);
@@ -79,12 +79,12 @@ static void test_fails(grpc_resolver_factory *factory, const char *string) {
args.uri = uri;
args.combiner = g_combiner;
resolver = grpc_resolver_factory_create_resolver(&exec_ctx, factory, &args);
- GPR_ASSERT(resolver == NULL);
+ GPR_ASSERT(resolver == nullptr);
grpc_uri_destroy(uri);
grpc_exec_ctx_finish(&exec_ctx);
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_resolver_factory *ipv4, *ipv6;
grpc_test_init(argc, argv);
grpc_init();
diff --git a/test/core/client_channel/uri_fuzzer_test.c b/test/core/client_channel/uri_fuzzer_test.cc
index e51d0031ec..ba31793ff3 100644
--- a/test/core/client_channel/uri_fuzzer_test.c
+++ b/test/core/client_channel/uri_fuzzer_test.cc
@@ -28,13 +28,13 @@
bool squelch = true;
bool leak_check = true;
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
- char *s = gpr_malloc(size + 1);
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+ char* s = static_cast<char*>(gpr_malloc(size + 1));
memcpy(s, data, size);
s[size] = 0;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_uri *x;
+ grpc_uri* x;
if ((x = grpc_uri_parse(&exec_ctx, s, 1))) {
grpc_uri_destroy(x);
}
diff --git a/test/core/client_channel/uri_parser_test.c b/test/core/client_channel/uri_parser_test.cc
index f53cae196b..30183f9f57 100644
--- a/test/core/client_channel/uri_parser_test.c
+++ b/test/core/client_channel/uri_parser_test.cc
@@ -25,11 +25,11 @@
#include "src/core/lib/iomgr/exec_ctx.h"
#include "test/core/util/test_config.h"
-static void test_succeeds(const char *uri_text, const char *scheme,
- const char *authority, const char *path,
- const char *query, const char *fragment) {
+static void test_succeeds(const char* uri_text, const char* scheme,
+ const char* authority, const char* path,
+ const char* query, const char* fragment) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+ grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
GPR_ASSERT(uri);
GPR_ASSERT(0 == strcmp(scheme, uri->scheme));
GPR_ASSERT(0 == strcmp(authority, uri->authority));
@@ -40,17 +40,17 @@ static void test_succeeds(const char *uri_text, const char *scheme,
grpc_uri_destroy(uri);
}
-static void test_fails(const char *uri_text) {
+static void test_fails(const char* uri_text) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- GPR_ASSERT(NULL == grpc_uri_parse(&exec_ctx, uri_text, 0));
+ GPR_ASSERT(nullptr == grpc_uri_parse(&exec_ctx, uri_text, 0));
grpc_exec_ctx_finish(&exec_ctx);
}
static void test_query_parts() {
{
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- const char *uri_text = "http://foo/path?a&b=B&c=&#frag";
- grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+ const char* uri_text = "http://foo/path?a&b=B&c=&#frag";
+ grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
GPR_ASSERT(uri);
GPR_ASSERT(0 == strcmp("http", uri->scheme));
@@ -60,7 +60,7 @@ static void test_query_parts() {
GPR_ASSERT(4 == uri->num_query_parts);
GPR_ASSERT(0 == strcmp("a", uri->query_parts[0]));
- GPR_ASSERT(NULL == uri->query_parts_values[0]);
+ GPR_ASSERT(nullptr == uri->query_parts_values[0]);
GPR_ASSERT(0 == strcmp("b", uri->query_parts[1]));
GPR_ASSERT(0 == strcmp("B", uri->query_parts_values[1]));
@@ -69,12 +69,12 @@ static void test_query_parts() {
GPR_ASSERT(0 == strcmp("", uri->query_parts_values[2]));
GPR_ASSERT(0 == strcmp("", uri->query_parts[3]));
- GPR_ASSERT(NULL == uri->query_parts_values[3]);
+ GPR_ASSERT(nullptr == uri->query_parts_values[3]);
- GPR_ASSERT(NULL == grpc_uri_get_query_arg(uri, "a"));
+ GPR_ASSERT(nullptr == grpc_uri_get_query_arg(uri, "a"));
GPR_ASSERT(0 == strcmp("B", grpc_uri_get_query_arg(uri, "b")));
GPR_ASSERT(0 == strcmp("", grpc_uri_get_query_arg(uri, "c")));
- GPR_ASSERT(NULL == grpc_uri_get_query_arg(uri, ""));
+ GPR_ASSERT(nullptr == grpc_uri_get_query_arg(uri, ""));
GPR_ASSERT(0 == strcmp("frag", uri->fragment));
grpc_exec_ctx_finish(&exec_ctx);
@@ -83,8 +83,8 @@ static void test_query_parts() {
{
/* test the current behavior of multiple query part values */
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- const char *uri_text = "http://auth/path?foo=bar=baz&foobar==";
- grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+ const char* uri_text = "http://auth/path?foo=bar=baz&foobar==";
+ grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
GPR_ASSERT(uri);
GPR_ASSERT(0 == strcmp("http", uri->scheme));
@@ -102,8 +102,8 @@ static void test_query_parts() {
{
/* empty query */
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- const char *uri_text = "http://foo/path";
- grpc_uri *uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
+ const char* uri_text = "http://foo/path";
+ grpc_uri* uri = grpc_uri_parse(&exec_ctx, uri_text, 0);
GPR_ASSERT(uri);
GPR_ASSERT(0 == strcmp("http", uri->scheme));
@@ -111,15 +111,15 @@ static void test_query_parts() {
GPR_ASSERT(0 == strcmp("/path", uri->path));
GPR_ASSERT(0 == strcmp("", uri->query));
GPR_ASSERT(0 == uri->num_query_parts);
- GPR_ASSERT(NULL == uri->query_parts);
- GPR_ASSERT(NULL == uri->query_parts_values);
+ GPR_ASSERT(nullptr == uri->query_parts);
+ GPR_ASSERT(nullptr == uri->query_parts_values);
GPR_ASSERT(0 == strcmp("", uri->fragment));
grpc_exec_ctx_finish(&exec_ctx);
grpc_uri_destroy(uri);
}
}
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
grpc_test_init(argc, argv);
test_succeeds("http://www.google.com", "http", "www.google.com", "", "", "");
test_succeeds("dns:///foo", "dns", "", "/foo", "", "");
generated by cgit v1.2.3 (git 2.39.1) at 2024-08-07 16:54:35 +0000