diff options
Diffstat (limited to 'test')
104 files changed, 7202 insertions, 1729 deletions
diff --git a/test/core/bad_client/bad_client.c b/test/core/bad_client/bad_client.c index ed46e7b009..e1a4b8ed90 100644 --- a/test/core/bad_client/bad_client.c +++ b/test/core/bad_client/bad_client.c @@ -64,14 +64,13 @@ static void done_write(grpc_exec_ctx *exec_ctx, void *arg, int success) { gpr_event_set(&a->done_write, (void *)1); } -static void server_setup_transport(void *ts, grpc_transport *transport, - grpc_mdctx *mdctx) { +static void server_setup_transport(void *ts, grpc_transport *transport) { thd_args *a = ts; static grpc_channel_filter const *extra_filters[] = { &grpc_http_server_filter}; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_server_setup_transport(&exec_ctx, a->server, transport, extra_filters, - GPR_ARRAY_SIZE(extra_filters), mdctx, + GPR_ARRAY_SIZE(extra_filters), grpc_server_get_channel_args(a->server)); grpc_exec_ctx_finish(&exec_ctx); } @@ -84,7 +83,6 @@ void grpc_run_bad_client_test(grpc_bad_client_server_side_validator validator, gpr_thd_id id; char *hex; grpc_transport *transport; - grpc_mdctx *mdctx = grpc_mdctx_create(); gpr_slice slice = gpr_slice_from_copied_buffer(client_payload, client_payload_length); gpr_slice_buffer outgoing; @@ -113,9 +111,8 @@ void grpc_run_bad_client_test(grpc_bad_client_server_side_validator validator, a.validator = validator; grpc_server_register_completion_queue(a.server, a.cq, NULL); grpc_server_start(a.server); - transport = - grpc_create_chttp2_transport(&exec_ctx, NULL, sfd.server, mdctx, 0); - server_setup_transport(&a, transport, mdctx); + transport = grpc_create_chttp2_transport(&exec_ctx, NULL, sfd.server, 0); + server_setup_transport(&a, transport); grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0); grpc_exec_ctx_finish(&exec_ctx); diff --git a/test/core/channel/channel_stack_test.c b/test/core/channel/channel_stack_test.c index 076a122e20..9dbb879300 100644 --- a/test/core/channel/channel_stack_test.c +++ b/test/core/channel/channel_stack_test.c @@ -42,22 +42,19 @@ #include "test/core/util/test_config.h" static void channel_init_func(grpc_exec_ctx *exec_ctx, - grpc_channel_element *elem, grpc_channel *master, - const grpc_channel_args *args, - grpc_mdctx *metadata_context, int is_first, - int is_last) { - GPR_ASSERT(args->num_args == 1); - GPR_ASSERT(args->args[0].type == GRPC_ARG_INTEGER); - GPR_ASSERT(0 == strcmp(args->args[0].key, "test_key")); - GPR_ASSERT(args->args[0].value.integer == 42); - GPR_ASSERT(is_first); - GPR_ASSERT(is_last); + grpc_channel_element *elem, + grpc_channel_element_args *args) { + GPR_ASSERT(args->channel_args->num_args == 1); + GPR_ASSERT(args->channel_args->args[0].type == GRPC_ARG_INTEGER); + GPR_ASSERT(0 == strcmp(args->channel_args->args[0].key, "test_key")); + GPR_ASSERT(args->channel_args->args[0].value.integer == 42); + GPR_ASSERT(args->is_first); + GPR_ASSERT(args->is_last); *(int *)(elem->channel_data) = 0; } static void call_init_func(grpc_exec_ctx *exec_ctx, grpc_call_element *elem, - const void *server_transport_data, - grpc_transport_stream_op *initial_op) { + grpc_call_element_args *args) { ++*(int *)(elem->channel_data); *(int *)(elem->call_data) = 0; } @@ -86,9 +83,9 @@ static char *get_peer(grpc_exec_ctx *exec_ctx, grpc_call_element *elem) { static void test_create_channel_stack(void) { const grpc_channel_filter filter = { - call_func, channel_func, sizeof(int), call_init_func, call_destroy_func, - sizeof(int), channel_init_func, channel_destroy_func, get_peer, - "some_test_filter"}; + call_func, channel_func, sizeof(int), call_init_func, + grpc_call_stack_ignore_set_pollset, call_destroy_func, sizeof(int), + channel_init_func, channel_destroy_func, get_peer, "some_test_filter"}; const grpc_channel_filter *filters = &filter; grpc_channel_stack *channel_stack; grpc_call_stack *call_stack; @@ -96,13 +93,10 @@ static void test_create_channel_stack(void) { grpc_call_element *call_elem; grpc_arg arg; grpc_channel_args chan_args; - grpc_mdctx *metadata_context; int *channel_data; int *call_data; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - metadata_context = grpc_mdctx_create(); - arg.type = GRPC_ARG_INTEGER; arg.key = "test_key"; arg.value.integer = 42; @@ -112,14 +106,15 @@ static void test_create_channel_stack(void) { channel_stack = gpr_malloc(grpc_channel_stack_size(&filters, 1)); grpc_channel_stack_init(&exec_ctx, &filters, 1, NULL, &chan_args, - metadata_context, channel_stack); + channel_stack); GPR_ASSERT(channel_stack->count == 1); channel_elem = grpc_channel_stack_element(channel_stack, 0); channel_data = (int *)channel_elem->channel_data; GPR_ASSERT(*channel_data == 0); call_stack = gpr_malloc(channel_stack->call_stack_size); - grpc_call_stack_init(&exec_ctx, channel_stack, NULL, NULL, call_stack); + grpc_call_stack_init(&exec_ctx, channel_stack, 0, NULL, NULL, NULL, NULL, + call_stack); GPR_ASSERT(call_stack->count == 1); call_elem = grpc_call_stack_element(call_stack, 0); GPR_ASSERT(call_elem->filter == channel_elem->filter); @@ -135,13 +130,13 @@ static void test_create_channel_stack(void) { grpc_channel_stack_destroy(&exec_ctx, channel_stack); gpr_free(channel_stack); - grpc_mdctx_unref(metadata_context); - grpc_exec_ctx_finish(&exec_ctx); } int main(int argc, char **argv) { grpc_test_init(argc, argv); + grpc_init(); test_create_channel_stack(); + grpc_shutdown(); return 0; } diff --git a/test/core/client_config/lb_policies_test.c b/test/core/client_config/lb_policies_test.c index 3eb6f11bf7..6f218e7f08 100644 --- a/test/core/client_config/lb_policies_test.c +++ b/test/core/client_config/lb_policies_test.c @@ -119,14 +119,15 @@ static void test_spec_destroy(test_spec *spec) { static void *tag(gpr_intptr t) { return (void *)t; } -static gpr_timespec n_seconds_time(int n) { - return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); +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) { grpc_event ev; do { - ev = grpc_completion_queue_next(cq, n_seconds_time(5), NULL); + ev = grpc_completion_queue_next(cq, n_millis_time(5000), NULL); } while (ev.type != GRPC_QUEUE_SHUTDOWN); } @@ -134,29 +135,46 @@ static void kill_server(const servers_fixture *f, size_t i) { gpr_log(GPR_INFO, "KILLING SERVER %d", i); GPR_ASSERT(f->servers[i] != NULL); grpc_server_shutdown_and_notify(f->servers[i], f->cq, tag(10000)); - GPR_ASSERT(grpc_completion_queue_pluck(f->cq, tag(10000), - GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5), + GPR_ASSERT(grpc_completion_queue_pluck(f->cq, tag(10000), n_millis_time(5000), NULL).type == GRPC_OP_COMPLETE); grpc_server_destroy(f->servers[i]); f->servers[i] = NULL; } -static void revive_server(const servers_fixture *f, size_t i) { +typedef struct request_data { + grpc_metadata_array initial_metadata_recv; + grpc_metadata_array trailing_metadata_recv; + char *details; + size_t details_capacity; + grpc_status_code status; + grpc_call_details *call_details; +} request_data; + +static void revive_server(const servers_fixture *f, request_data *rdata, + size_t i) { int got_port; gpr_log(GPR_INFO, "RAISE AGAIN SERVER %d", i); GPR_ASSERT(f->servers[i] == NULL); + + 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); GPR_ASSERT((got_port = grpc_server_add_insecure_http2_port( f->servers[i], f->servers_hostports[i])) > 0); grpc_server_start(f->servers[i]); + + GPR_ASSERT(GRPC_CALL_OK == + grpc_server_request_call(f->servers[i], &f->server_calls[i], + &rdata->call_details[i], + &f->request_metadata_recv[i], f->cq, + f->cq, tag(1000 + (int)i))); } 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)); - int *ports; - int got_port; size_t i; f->num_servers = num_servers; @@ -164,23 +182,16 @@ static servers_fixture *setup_servers(const char *server_host, f->request_metadata_recv = gpr_malloc(sizeof(grpc_metadata_array) * num_servers); /* Create servers. */ - ports = gpr_malloc(sizeof(int *) * num_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(NULL); for (i = 0; i < num_servers; i++) { - ports[i] = grpc_pick_unused_port_or_die(); - - gpr_join_host_port(&f->servers_hostports[i], server_host, ports[i]); - - f->servers[i] = grpc_server_create(NULL, NULL); - grpc_server_register_completion_queue(f->servers[i], f->cq, NULL); - GPR_ASSERT((got_port = grpc_server_add_insecure_http2_port( - f->servers[i], f->servers_hostports[i])) > 0); - GPR_ASSERT(ports[i] == got_port); - grpc_server_start(f->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; + revive_server(f, rdata, i); } - gpr_free(ports); return f; } @@ -191,7 +202,7 @@ static void teardown_servers(servers_fixture *f) { if (f->servers[i] == NULL) continue; grpc_server_shutdown_and_notify(f->servers[i], f->cq, tag(10000)); GPR_ASSERT(grpc_completion_queue_pluck(f->cq, tag(10000), - GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5), + n_millis_time(5000), NULL).type == GRPC_OP_COMPLETE); grpc_server_destroy(f->servers[i]); } @@ -203,6 +214,7 @@ static void teardown_servers(servers_fixture *f) { for (i = 0; i < f->num_servers; i++) { gpr_free(f->servers_hostports[i]); + grpc_metadata_array_destroy(&f->request_metadata_recv[i]); } gpr_free(f->servers_hostports); @@ -211,22 +223,12 @@ static void teardown_servers(servers_fixture *f) { gpr_free(f); } -typedef struct request_data { - grpc_metadata_array initial_metadata_recv; - grpc_metadata_array trailing_metadata_recv; - char *details; - size_t details_capacity; - grpc_status_code status; - grpc_call_details *call_details; -} request_data; - /** Returns connection sequence (server indices), which must be freed */ int *perform_request(servers_fixture *f, grpc_channel *client, request_data *rdata, const test_spec *spec) { grpc_call *c; int s_idx; int *s_valid; - gpr_timespec deadline; grpc_op ops[6]; grpc_op *op; int was_cancelled; @@ -234,13 +236,12 @@ int *perform_request(servers_fixture *f, grpc_channel *client, grpc_event ev; int read_tag; int *connection_sequence; + int completed_client; s_valid = gpr_malloc(sizeof(int) * f->num_servers); - rdata->call_details = gpr_malloc(sizeof(grpc_call_details) * f->num_servers); connection_sequence = gpr_malloc(sizeof(int) * spec->num_iters); /* Send a trivial request. */ - deadline = n_seconds_time(60); for (iter_num = 0; iter_num < spec->num_iters; iter_num++) { cq_verifier *cqv = cq_verifier_create(f->cq); @@ -253,7 +254,7 @@ int *perform_request(servers_fixture *f, grpc_channel *client, kill_server(f, i); } else if (spec->revive_at[iter_num][i] != 0) { /* killing takes precedence */ - revive_server(f, i); + revive_server(f, rdata, i); } } @@ -267,8 +268,10 @@ int *perform_request(servers_fixture *f, grpc_channel *client, memset(s_valid, 0, f->num_servers * sizeof(int)); c = grpc_channel_create_call(client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq, - "/foo", "foo.test.google.fr", deadline, NULL); + "/foo", "foo.test.google.fr", + gpr_inf_future(GPR_CLOCK_REALTIME), NULL); GPR_ASSERT(c); + completed_client = 0; op = ops; op->op = GRPC_OP_SEND_INITIAL_METADATA; @@ -286,32 +289,23 @@ int *perform_request(servers_fixture *f, grpc_channel *client, op->reserved = NULL; op++; op->op = GRPC_OP_RECV_STATUS_ON_CLIENT; - op->data.recv_status_on_client.trailing_metadata = &rdata->trailing_metadata_recv; + op->data.recv_status_on_client.trailing_metadata = + &rdata->trailing_metadata_recv; op->data.recv_status_on_client.status = &rdata->status; op->data.recv_status_on_client.status_details = &rdata->details; - op->data.recv_status_on_client.status_details_capacity = &rdata->details_capacity; + op->data.recv_status_on_client.status_details_capacity = + &rdata->details_capacity; op->flags = 0; op->reserved = NULL; op++; GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL)); - /* "listen" on all servers */ - for (i = 0; i < f->num_servers; i++) { - grpc_metadata_array_init(&f->request_metadata_recv[i]); - if (f->servers[i] != NULL) { - GPR_ASSERT(GRPC_CALL_OK == - grpc_server_request_call(f->servers[i], &f->server_calls[i], - &rdata->call_details[i], - &f->request_metadata_recv[i], f->cq, - f->cq, tag(1000 + (int)i))); - } - } - s_idx = -1; while ((ev = grpc_completion_queue_next( f->cq, GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1), NULL)).type != GRPC_QUEUE_TIMEOUT) { + GPR_ASSERT(ev.type == GRPC_OP_COMPLETE); read_tag = ((int)(gpr_intptr)ev.tag); gpr_log(GPR_DEBUG, "EVENT: success:%d, type:%d, tag:%d iter:%d", ev.success, ev.type, read_tag, iter_num); @@ -321,9 +315,16 @@ int *perform_request(servers_fixture *f, grpc_channel *client, s_idx = read_tag - 1000; s_valid[s_idx] = 1; connection_sequence[iter_num] = s_idx; + break; + } else if (read_tag == 1) { + gpr_log(GPR_DEBUG, "client timed out"); + GPR_ASSERT(ev.success); + completed_client = 1; } } + gpr_log(GPR_DEBUG, "s_idx=%d", s_idx); + if (s_idx >= 0) { op = ops; op->op = GRPC_OP_SEND_INITIAL_METADATA; @@ -348,23 +349,35 @@ int *perform_request(servers_fixture *f, grpc_channel *client, tag(102), NULL)); cq_expect_completion(cqv, tag(102), 1); - cq_expect_completion(cqv, tag(1), 1); + if (!completed_client) { + cq_expect_completion(cqv, tag(1), 1); + } cq_verify(cqv); + gpr_log(GPR_DEBUG, "status=%d; %s", rdata->status, rdata->details); GPR_ASSERT(rdata->status == GRPC_STATUS_UNIMPLEMENTED); GPR_ASSERT(0 == strcmp(rdata->details, "xyz")); GPR_ASSERT(0 == strcmp(rdata->call_details[s_idx].method, "/foo")); - GPR_ASSERT(0 == strcmp(rdata->call_details[s_idx].host, "foo.test.google.fr")); + GPR_ASSERT(0 == + strcmp(rdata->call_details[s_idx].host, "foo.test.google.fr")); GPR_ASSERT(was_cancelled == 1); - } else { - } - for (i = 0; i < f->num_servers; i++) { - if (s_valid[i] != 0) { - grpc_call_destroy(f->server_calls[i]); + grpc_call_destroy(f->server_calls[s_idx]); + + /* ask for the next request on this server */ + GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call( + f->servers[s_idx], &f->server_calls[s_idx], + &rdata->call_details[s_idx], + &f->request_metadata_recv[s_idx], f->cq, + f->cq, tag(1000 + (int)s_idx))); + } else { + grpc_call_cancel(c, NULL); + if (!completed_client) { + cq_expect_completion(cqv, tag(1), 1); + cq_verify(cqv); } - grpc_metadata_array_destroy(&f->request_metadata_recv[i]); } + grpc_metadata_array_destroy(&rdata->initial_metadata_recv); grpc_metadata_array_destroy(&rdata->trailing_metadata_recv); @@ -378,7 +391,6 @@ int *perform_request(servers_fixture *f, grpc_channel *client, gpr_free(rdata->details); } - gpr_free(rdata->call_details); gpr_free(s_valid); return connection_sequence; @@ -441,14 +453,26 @@ void run_spec(const test_spec *spec) { char *servers_hostports_str; int *actual_connection_sequence; request_data rdata; - servers_fixture *f = setup_servers("127.0.0.1", spec->num_servers); + servers_fixture *f; + grpc_channel_args args; + grpc_arg arg; + rdata.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); gpr_asprintf(&client_hostport, "ipv4:%s?lb_policy=round_robin", servers_hostports_str); - client = grpc_insecure_channel_create(client_hostport, NULL, NULL); + + arg.type = GRPC_ARG_INTEGER; + arg.key = "grpc.testing.fixed_reconnect_backoff"; + arg.value.integer = 100; + args.num_args = 1; + args.args = &arg; + + client = grpc_insecure_channel_create(client_hostport, &args, NULL); gpr_log(GPR_INFO, "Testing '%s' with servers=%s client=%s", spec->description, servers_hostports_str, client_hostport); @@ -460,6 +484,7 @@ void run_spec(const test_spec *spec) { gpr_free(client_hostport); gpr_free(servers_hostports_str); gpr_free(actual_connection_sequence); + gpr_free(rdata.call_details); grpc_channel_destroy(client); teardown_servers(f); diff --git a/test/core/client_config/set_initial_connect_string_test.c b/test/core/client_config/set_initial_connect_string_test.c new file mode 100644 index 0000000000..ceca56c833 --- /dev/null +++ b/test/core/client_config/set_initial_connect_string_test.c @@ -0,0 +1,221 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#include <string.h> + +#include <grpc/grpc.h> +#include <grpc/support/alloc.h> +#include <grpc/support/host_port.h> +#include <grpc/support/log.h> +#include <grpc/support/slice.h> + +#include "src/core/client_config/initial_connect_string.h" +#include "src/core/iomgr/sockaddr.h" +#include "src/core/security/credentials.h" +#include "src/core/support/string.h" +#include "test/core/util/port.h" +#include "test/core/util/test_config.h" +#include "test/core/util/test_tcp_server.h" + +struct rpc_state { + char *target; + grpc_channel_credentials *creds; + grpc_completion_queue *cq; + grpc_channel *channel; + grpc_call *call; + grpc_op op; + gpr_slice_buffer incoming_buffer; + gpr_slice_buffer temp_incoming_buffer; + grpc_endpoint *tcp; + int done; +}; + +static const char *magic_connect_string = "magic initial string"; +static int server_port; +static struct rpc_state state; +static grpc_closure on_read; + +static void handle_read(grpc_exec_ctx *exec_ctx, void *arg, int success) { + GPR_ASSERT(success); + gpr_slice_buffer_move_into(&state.temp_incoming_buffer, + &state.incoming_buffer); + if (state.incoming_buffer.length > strlen(magic_connect_string)) { + state.done = 1; + grpc_endpoint_shutdown(exec_ctx, state.tcp); + grpc_endpoint_destroy(exec_ctx, state.tcp); + } else { + grpc_endpoint_read(exec_ctx, state.tcp, &state.temp_incoming_buffer, + &on_read); + } +} + +static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp) { + test_tcp_server *server = arg; + grpc_closure_init(&on_read, handle_read, NULL); + gpr_slice_buffer_init(&state.incoming_buffer); + gpr_slice_buffer_init(&state.temp_incoming_buffer); + state.tcp = tcp; + grpc_endpoint_add_to_pollset(exec_ctx, tcp, &server->pollset); + grpc_endpoint_read(exec_ctx, tcp, &state.temp_incoming_buffer, &on_read); +} + +static void set_magic_initial_string(struct sockaddr **addr, size_t *addr_len, + gpr_slice *connect_string) { + GPR_ASSERT(addr); + GPR_ASSERT(addr_len); + *connect_string = gpr_slice_from_copied_string(magic_connect_string); +} + +static void reset_addr_and_set_magic_string(struct sockaddr **addr, + size_t *addr_len, + gpr_slice *connect_string) { + struct sockaddr_in target; + *connect_string = gpr_slice_from_copied_string(magic_connect_string); + gpr_free(*addr); + target.sin_family = AF_INET; + target.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + target.sin_port = htons((uint16_t)server_port); + *addr_len = sizeof(target); + *addr = (struct sockaddr *)gpr_malloc(sizeof(target)); + memcpy(*addr, &target, sizeof(target)); +} + +static gpr_timespec n_sec_deadline(int seconds) { + return gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), + gpr_time_from_seconds(seconds, GPR_TIMESPAN)); +} + +static void start_rpc(int use_creds, int target_port) { + state.done = 0; + state.cq = grpc_completion_queue_create(NULL); + if (use_creds) { + state.creds = grpc_fake_transport_security_credentials_create(); + } else { + state.creds = NULL; + } + gpr_join_host_port(&state.target, "127.0.0.1", target_port); + if (use_creds) { + state.channel = + grpc_secure_channel_create(state.creds, state.target, NULL, NULL); + } else { + state.channel = grpc_insecure_channel_create(state.target, NULL, NULL); + } + state.call = grpc_channel_create_call( + state.channel, NULL, GRPC_PROPAGATE_DEFAULTS, state.cq, "/Service/Method", + "localhost", gpr_inf_future(GPR_CLOCK_REALTIME), NULL); + state.op.op = GRPC_OP_SEND_INITIAL_METADATA; + state.op.data.send_initial_metadata.count = 0; + state.op.flags = 0; + state.op.reserved = NULL; + GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(state.call, &state.op, + (size_t)(1), NULL, NULL)); + grpc_completion_queue_next(state.cq, n_sec_deadline(1), NULL); +} + +static void cleanup_rpc(void) { + grpc_event ev; + gpr_slice_buffer_destroy(&state.incoming_buffer); + gpr_slice_buffer_destroy(&state.temp_incoming_buffer); + grpc_channel_credentials_unref(state.creds); + grpc_call_destroy(state.call); + grpc_completion_queue_shutdown(state.cq); + do { + ev = grpc_completion_queue_next(state.cq, n_sec_deadline(1), NULL); + } while (ev.type != GRPC_QUEUE_SHUTDOWN); + grpc_completion_queue_destroy(state.cq); + grpc_channel_destroy(state.channel); + gpr_free(state.target); +} + +static void poll_server_until_read_done(test_tcp_server *server) { + gpr_timespec deadline = n_sec_deadline(5); + while (state.done == 0 && + gpr_time_cmp(gpr_now(GPR_CLOCK_REALTIME), deadline) < 0) { + test_tcp_server_poll(server, 1); + } +} + +static void match_initial_magic_string(gpr_slice_buffer *buffer) { + size_t i, j, cmp_length; + size_t magic_length = strlen(magic_connect_string); + GPR_ASSERT(buffer->length >= magic_length); + for (i = 0, j = 0; i < state.incoming_buffer.count && j < magic_length; i++) { + char *dump = + gpr_dump_slice(state.incoming_buffer.slices[i], GPR_DUMP_ASCII); + cmp_length = GPR_MIN(strlen(dump), magic_length - j); + GPR_ASSERT(strncmp(dump, magic_connect_string + j, cmp_length) == 0); + j += cmp_length; + gpr_free(dump); + } +} + +static void test_initial_string(test_tcp_server *server, int secure) { + grpc_test_set_initial_connect_string_function(set_magic_initial_string); + start_rpc(secure, server_port); + poll_server_until_read_done(server); + match_initial_magic_string(&state.incoming_buffer); + cleanup_rpc(); +} + +static void test_initial_string_with_redirect(test_tcp_server *server, + int secure) { + int another_port = grpc_pick_unused_port_or_die(); + grpc_test_set_initial_connect_string_function( + reset_addr_and_set_magic_string); + start_rpc(secure, another_port); + poll_server_until_read_done(server); + match_initial_magic_string(&state.incoming_buffer); + cleanup_rpc(); +} + +static void run_test(void (*test)(test_tcp_server *server, int secure), + int secure) { + test_tcp_server test_server; + server_port = grpc_pick_unused_port_or_die(); + test_tcp_server_init(&test_server, on_connect, &test_server); + test_tcp_server_start(&test_server, server_port); + test(&test_server, secure); + test_tcp_server_destroy(&test_server); +} + +int main(int argc, char **argv) { + grpc_test_init(argc, argv); + grpc_init(); + + run_test(test_initial_string, 0); + run_test(test_initial_string, 1); + run_test(test_initial_string_with_redirect, 0); + run_test(test_initial_string_with_redirect, 1); + + grpc_shutdown(); + return 0; +} diff --git a/test/core/compression/compression_test.c b/test/core/compression/compression_test.c index 633fbd97f4..35fadc00c0 100644 --- a/test/core/compression/compression_test.c +++ b/test/core/compression/compression_test.c @@ -35,6 +35,7 @@ #include <string.h> #include <grpc/compression.h> +#include <grpc/grpc.h> #include <grpc/support/log.h> #include <grpc/support/useful.h> @@ -71,7 +72,9 @@ static void test_compression_algorithm_parse(void) { } int main(int argc, char **argv) { + grpc_init(); test_compression_algorithm_parse(); + grpc_shutdown(); return 0; } diff --git a/test/core/compression/message_compress_test.c b/test/core/compression/message_compress_test.c index 98da6a1eaa..dfaed8484e 100644 --- a/test/core/compression/message_compress_test.c +++ b/test/core/compression/message_compress_test.c @@ -36,10 +36,12 @@ #include <stdlib.h> #include <string.h> -#include "test/core/util/test_config.h" -#include "src/core/support/murmur_hash.h" +#include <grpc/grpc.h> #include <grpc/support/log.h> #include <grpc/support/useful.h> + +#include "test/core/util/test_config.h" +#include "src/core/support/murmur_hash.h" #include "test/core/util/slice_splitter.h" typedef enum { ONE_A = 0, ONE_KB_A, ONE_MB_A, TEST_VALUE_COUNT } test_value; @@ -175,6 +177,7 @@ int main(int argc, char **argv) { GRPC_SLICE_SPLIT_ONE_BYTE}; grpc_test_init(argc, argv); + grpc_init(); for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) { for (j = 0; j < GPR_ARRAY_SIZE(uncompressed_split_modes); j++) { @@ -189,6 +192,7 @@ int main(int argc, char **argv) { } test_bad_data(); + grpc_shutdown(); return 0; } diff --git a/test/core/end2end/data/server1_cert.c b/test/core/end2end/data/server1_cert.c index d31f2e2d0e..82d65cf551 100644 --- a/test/core/end2end/data/server1_cert.c +++ b/test/core/end2end/data/server1_cert.c @@ -34,82 +34,82 @@ const char test_server1_cert[] = { 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, - 0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43, 0x6d, 0x7a, 0x43, 0x43, - 0x41, 0x67, 0x53, 0x67, 0x41, 0x77, 0x49, 0x42, 0x41, 0x67, 0x49, 0x42, - 0x41, 0x7a, 0x41, 0x4e, 0x42, 0x67, 0x6b, 0x71, 0x68, 0x6b, 0x69, 0x47, - 0x39, 0x77, 0x30, 0x42, 0x41, 0x51, 0x55, 0x46, 0x41, 0x44, 0x42, 0x57, + 0x2d, 0x2d, 0x2d, 0x0a, 0x4d, 0x49, 0x49, 0x43, 0x6e, 0x44, 0x43, 0x43, + 0x41, 0x67, 0x57, 0x67, 0x41, 0x77, 0x49, 0x42, 0x41, 0x67, 0x49, 0x42, + 0x42, 0x7a, 0x41, 0x4e, 0x42, 0x67, 0x6b, 0x71, 0x68, 0x6b, 0x69, 0x47, + 0x39, 0x77, 0x30, 0x42, 0x41, 0x51, 0x73, 0x46, 0x41, 0x44, 0x42, 0x57, 0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x45, 0x77, 0x4a, 0x42, 0x56, 0x54, 0x45, 0x54, 0x0a, 0x4d, 0x42, 0x45, - 0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x41, 0x77, 0x4b, 0x55, 0x32, 0x39, + 0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x42, 0x4d, 0x4b, 0x55, 0x32, 0x39, 0x74, 0x5a, 0x53, 0x31, 0x54, 0x64, 0x47, 0x46, 0x30, 0x5a, 0x54, 0x45, - 0x68, 0x4d, 0x42, 0x38, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x67, 0x77, + 0x68, 0x4d, 0x42, 0x38, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x68, 0x4d, 0x59, 0x53, 0x57, 0x35, 0x30, 0x5a, 0x58, 0x4a, 0x75, 0x5a, 0x58, 0x51, 0x67, 0x56, 0x32, 0x6c, 0x6b, 0x5a, 0x32, 0x6c, 0x30, 0x63, 0x79, 0x42, 0x51, 0x0a, 0x64, 0x48, 0x6b, 0x67, 0x54, 0x48, 0x52, 0x6b, 0x4d, 0x51, - 0x38, 0x77, 0x44, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x44, 0x44, 0x41, + 0x38, 0x77, 0x44, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x44, 0x45, 0x77, 0x5a, 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x59, 0x32, 0x45, 0x77, 0x48, 0x68, - 0x63, 0x4e, 0x4d, 0x54, 0x51, 0x77, 0x4e, 0x7a, 0x49, 0x79, 0x4d, 0x44, - 0x59, 0x77, 0x4d, 0x44, 0x55, 0x33, 0x57, 0x68, 0x63, 0x4e, 0x4d, 0x6a, - 0x51, 0x77, 0x4e, 0x7a, 0x45, 0x35, 0x0a, 0x4d, 0x44, 0x59, 0x77, 0x4d, - 0x44, 0x55, 0x33, 0x57, 0x6a, 0x42, 0x6b, 0x4d, 0x51, 0x73, 0x77, 0x43, + 0x63, 0x4e, 0x4d, 0x54, 0x55, 0x78, 0x4d, 0x54, 0x41, 0x30, 0x4d, 0x44, + 0x49, 0x79, 0x4d, 0x44, 0x49, 0x30, 0x57, 0x68, 0x63, 0x4e, 0x4d, 0x6a, + 0x55, 0x78, 0x4d, 0x54, 0x41, 0x78, 0x0a, 0x4d, 0x44, 0x49, 0x79, 0x4d, + 0x44, 0x49, 0x30, 0x57, 0x6a, 0x42, 0x6c, 0x4d, 0x51, 0x73, 0x77, 0x43, 0x51, 0x59, 0x44, 0x56, 0x51, 0x51, 0x47, 0x45, 0x77, 0x4a, 0x56, 0x55, 0x7a, 0x45, 0x52, 0x4d, 0x41, 0x38, 0x47, 0x41, 0x31, 0x55, 0x45, 0x43, 0x42, 0x4d, 0x49, 0x53, 0x57, 0x78, 0x73, 0x61, 0x57, 0x35, 0x76, 0x61, 0x58, 0x4d, 0x78, 0x45, 0x44, 0x41, 0x4f, 0x42, 0x67, 0x4e, 0x56, 0x0a, 0x42, 0x41, 0x63, 0x54, 0x42, 0x30, 0x4e, 0x6f, 0x61, 0x57, 0x4e, 0x68, - 0x5a, 0x32, 0x38, 0x78, 0x46, 0x44, 0x41, 0x53, 0x42, 0x67, 0x4e, 0x56, - 0x42, 0x41, 0x6f, 0x54, 0x43, 0x30, 0x64, 0x76, 0x62, 0x32, 0x64, 0x73, - 0x5a, 0x53, 0x42, 0x4a, 0x62, 0x6d, 0x4d, 0x75, 0x4d, 0x52, 0x6f, 0x77, - 0x47, 0x41, 0x59, 0x44, 0x56, 0x51, 0x51, 0x44, 0x46, 0x42, 0x45, 0x71, - 0x4c, 0x6e, 0x52, 0x6c, 0x0a, 0x63, 0x33, 0x51, 0x75, 0x5a, 0x32, 0x39, - 0x76, 0x5a, 0x32, 0x78, 0x6c, 0x4c, 0x6d, 0x4e, 0x76, 0x62, 0x54, 0x43, - 0x42, 0x6e, 0x7a, 0x41, 0x4e, 0x42, 0x67, 0x6b, 0x71, 0x68, 0x6b, 0x69, - 0x47, 0x39, 0x77, 0x30, 0x42, 0x41, 0x51, 0x45, 0x46, 0x41, 0x41, 0x4f, - 0x42, 0x6a, 0x51, 0x41, 0x77, 0x67, 0x59, 0x6b, 0x43, 0x67, 0x59, 0x45, - 0x41, 0x34, 0x63, 0x4d, 0x56, 0x4a, 0x79, 0x67, 0x73, 0x0a, 0x4a, 0x55, - 0x6d, 0x6c, 0x67, 0x4d, 0x4d, 0x7a, 0x67, 0x64, 0x69, 0x30, 0x68, 0x31, - 0x58, 0x6f, 0x43, 0x52, 0x37, 0x2b, 0x77, 0x77, 0x31, 0x70, 0x6f, 0x70, - 0x30, 0x34, 0x4f, 0x4d, 0x4d, 0x79, 0x79, 0x37, 0x48, 0x2f, 0x69, 0x30, - 0x50, 0x4a, 0x32, 0x57, 0x36, 0x59, 0x33, 0x35, 0x2b, 0x62, 0x34, 0x43, - 0x4d, 0x38, 0x51, 0x72, 0x6b, 0x59, 0x65, 0x45, 0x61, 0x66, 0x55, 0x47, - 0x44, 0x4f, 0x0a, 0x52, 0x59, 0x58, 0x36, 0x79, 0x56, 0x2f, 0x63, 0x48, - 0x47, 0x47, 0x73, 0x44, 0x2f, 0x78, 0x30, 0x32, 0x79, 0x65, 0x36, 0x65, - 0x79, 0x31, 0x55, 0x44, 0x74, 0x6b, 0x47, 0x41, 0x44, 0x2f, 0x6d, 0x70, - 0x44, 0x45, 0x78, 0x38, 0x59, 0x43, 0x72, 0x6a, 0x41, 0x63, 0x31, 0x56, - 0x66, 0x76, 0x74, 0x38, 0x46, 0x6b, 0x36, 0x43, 0x6e, 0x31, 0x57, 0x56, - 0x49, 0x78, 0x56, 0x2f, 0x4a, 0x33, 0x30, 0x0a, 0x33, 0x78, 0x6a, 0x42, - 0x73, 0x46, 0x67, 0x42, 0x79, 0x51, 0x35, 0x35, 0x52, 0x42, 0x70, 0x31, - 0x4f, 0x4c, 0x5a, 0x66, 0x56, 0x4c, 0x6f, 0x36, 0x41, 0x6c, 0x65, 0x42, - 0x44, 0x53, 0x62, 0x63, 0x78, 0x61, 0x45, 0x43, 0x41, 0x77, 0x45, 0x41, - 0x41, 0x61, 0x4e, 0x72, 0x4d, 0x47, 0x6b, 0x77, 0x43, 0x51, 0x59, 0x44, - 0x56, 0x52, 0x30, 0x54, 0x42, 0x41, 0x49, 0x77, 0x41, 0x44, 0x41, 0x4c, - 0x0a, 0x42, 0x67, 0x4e, 0x56, 0x48, 0x51, 0x38, 0x45, 0x42, 0x41, 0x4d, - 0x43, 0x42, 0x65, 0x41, 0x77, 0x54, 0x77, 0x59, 0x44, 0x56, 0x52, 0x30, - 0x52, 0x42, 0x45, 0x67, 0x77, 0x52, 0x6f, 0x49, 0x51, 0x4b, 0x69, 0x35, - 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x4c, 0x6d, 0x64, 0x76, 0x62, 0x32, 0x64, - 0x73, 0x5a, 0x53, 0x35, 0x6d, 0x63, 0x6f, 0x49, 0x59, 0x64, 0x32, 0x46, - 0x30, 0x5a, 0x58, 0x4a, 0x36, 0x0a, 0x62, 0x32, 0x39, 0x70, 0x4c, 0x6e, - 0x52, 0x6c, 0x63, 0x33, 0x51, 0x75, 0x5a, 0x32, 0x39, 0x76, 0x5a, 0x32, - 0x78, 0x6c, 0x4c, 0x6d, 0x4a, 0x6c, 0x67, 0x68, 0x49, 0x71, 0x4c, 0x6e, - 0x52, 0x6c, 0x63, 0x33, 0x51, 0x75, 0x65, 0x57, 0x39, 0x31, 0x64, 0x48, - 0x56, 0x69, 0x5a, 0x53, 0x35, 0x6a, 0x62, 0x32, 0x32, 0x48, 0x42, 0x4d, - 0x43, 0x6f, 0x41, 0x51, 0x4d, 0x77, 0x44, 0x51, 0x59, 0x4a, 0x0a, 0x4b, - 0x6f, 0x5a, 0x49, 0x68, 0x76, 0x63, 0x4e, 0x41, 0x51, 0x45, 0x46, 0x42, - 0x51, 0x41, 0x44, 0x67, 0x59, 0x45, 0x41, 0x4d, 0x32, 0x49, 0x69, 0x30, - 0x4c, 0x67, 0x54, 0x47, 0x62, 0x4a, 0x31, 0x6a, 0x34, 0x6f, 0x71, 0x58, - 0x39, 0x62, 0x78, 0x56, 0x63, 0x78, 0x6d, 0x2b, 0x2f, 0x52, 0x35, 0x59, - 0x66, 0x38, 0x6f, 0x69, 0x30, 0x61, 0x5a, 0x71, 0x54, 0x4a, 0x6c, 0x6e, - 0x4c, 0x59, 0x53, 0x0a, 0x77, 0x58, 0x63, 0x42, 0x79, 0x6b, 0x78, 0x54, - 0x78, 0x31, 0x38, 0x31, 0x73, 0x37, 0x57, 0x79, 0x66, 0x4a, 0x34, 0x39, - 0x57, 0x77, 0x72, 0x59, 0x58, 0x6f, 0x37, 0x38, 0x7a, 0x54, 0x44, 0x41, - 0x6e, 0x66, 0x31, 0x6d, 0x61, 0x30, 0x66, 0x50, 0x71, 0x33, 0x65, 0x34, - 0x6d, 0x70, 0x73, 0x70, 0x76, 0x79, 0x6e, 0x64, 0x4c, 0x68, 0x31, 0x61, - 0x2b, 0x4f, 0x61, 0x72, 0x48, 0x61, 0x31, 0x65, 0x0a, 0x61, 0x54, 0x30, - 0x44, 0x49, 0x49, 0x59, 0x6b, 0x37, 0x71, 0x65, 0x45, 0x61, 0x31, 0x59, - 0x63, 0x56, 0x6c, 0x6a, 0x78, 0x32, 0x4b, 0x79, 0x4c, 0x64, 0x30, 0x72, - 0x31, 0x42, 0x42, 0x41, 0x66, 0x72, 0x77, 0x79, 0x47, 0x61, 0x45, 0x50, - 0x56, 0x65, 0x4a, 0x51, 0x56, 0x59, 0x57, 0x61, 0x4f, 0x4a, 0x52, 0x55, - 0x32, 0x77, 0x65, 0x2f, 0x4b, 0x44, 0x34, 0x6f, 0x6a, 0x66, 0x39, 0x73, - 0x3d, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45, 0x4e, 0x44, 0x20, 0x43, + 0x5a, 0x32, 0x38, 0x78, 0x46, 0x54, 0x41, 0x54, 0x42, 0x67, 0x4e, 0x56, + 0x42, 0x41, 0x6f, 0x54, 0x44, 0x45, 0x56, 0x34, 0x59, 0x57, 0x31, 0x77, + 0x62, 0x47, 0x55, 0x73, 0x49, 0x45, 0x4e, 0x76, 0x4c, 0x6a, 0x45, 0x61, + 0x4d, 0x42, 0x67, 0x47, 0x41, 0x31, 0x55, 0x45, 0x41, 0x78, 0x51, 0x52, + 0x4b, 0x69, 0x35, 0x30, 0x0a, 0x5a, 0x58, 0x4e, 0x30, 0x4c, 0x6d, 0x64, + 0x76, 0x62, 0x32, 0x64, 0x73, 0x5a, 0x53, 0x35, 0x6a, 0x62, 0x32, 0x30, + 0x77, 0x67, 0x5a, 0x38, 0x77, 0x44, 0x51, 0x59, 0x4a, 0x4b, 0x6f, 0x5a, + 0x49, 0x68, 0x76, 0x63, 0x4e, 0x41, 0x51, 0x45, 0x42, 0x42, 0x51, 0x41, + 0x44, 0x67, 0x59, 0x30, 0x41, 0x4d, 0x49, 0x47, 0x4a, 0x41, 0x6f, 0x47, + 0x42, 0x41, 0x4f, 0x48, 0x44, 0x46, 0x53, 0x63, 0x6f, 0x0a, 0x4c, 0x43, + 0x56, 0x4a, 0x70, 0x59, 0x44, 0x44, 0x4d, 0x34, 0x48, 0x59, 0x74, 0x49, + 0x64, 0x56, 0x36, 0x41, 0x6b, 0x65, 0x2f, 0x73, 0x4d, 0x4e, 0x61, 0x61, + 0x4b, 0x64, 0x4f, 0x44, 0x6a, 0x44, 0x4d, 0x73, 0x75, 0x78, 0x2f, 0x34, + 0x74, 0x44, 0x79, 0x64, 0x6c, 0x75, 0x6d, 0x4e, 0x2b, 0x66, 0x6d, 0x2b, + 0x41, 0x6a, 0x50, 0x45, 0x4b, 0x35, 0x47, 0x48, 0x68, 0x47, 0x6e, 0x31, + 0x42, 0x67, 0x0a, 0x7a, 0x6b, 0x57, 0x46, 0x2b, 0x73, 0x6c, 0x66, 0x33, + 0x42, 0x78, 0x68, 0x72, 0x41, 0x2f, 0x38, 0x64, 0x4e, 0x73, 0x6e, 0x75, + 0x6e, 0x73, 0x74, 0x56, 0x41, 0x37, 0x5a, 0x42, 0x67, 0x41, 0x2f, 0x35, + 0x71, 0x51, 0x78, 0x4d, 0x66, 0x47, 0x41, 0x71, 0x34, 0x77, 0x48, 0x4e, + 0x56, 0x58, 0x37, 0x37, 0x66, 0x42, 0x5a, 0x4f, 0x67, 0x70, 0x39, 0x56, + 0x6c, 0x53, 0x4d, 0x56, 0x66, 0x79, 0x64, 0x0a, 0x39, 0x4e, 0x38, 0x59, + 0x77, 0x62, 0x42, 0x59, 0x41, 0x63, 0x6b, 0x4f, 0x65, 0x55, 0x51, 0x61, + 0x64, 0x54, 0x69, 0x32, 0x58, 0x31, 0x53, 0x36, 0x4f, 0x67, 0x4a, 0x58, + 0x67, 0x51, 0x30, 0x6d, 0x33, 0x4d, 0x57, 0x68, 0x41, 0x67, 0x4d, 0x42, + 0x41, 0x41, 0x47, 0x6a, 0x61, 0x7a, 0x42, 0x70, 0x4d, 0x41, 0x6b, 0x47, + 0x41, 0x31, 0x55, 0x64, 0x45, 0x77, 0x51, 0x43, 0x4d, 0x41, 0x41, 0x77, + 0x0a, 0x43, 0x77, 0x59, 0x44, 0x56, 0x52, 0x30, 0x50, 0x42, 0x41, 0x51, + 0x44, 0x41, 0x67, 0x58, 0x67, 0x4d, 0x45, 0x38, 0x47, 0x41, 0x31, 0x55, + 0x64, 0x45, 0x51, 0x52, 0x49, 0x4d, 0x45, 0x61, 0x43, 0x45, 0x43, 0x6f, + 0x75, 0x64, 0x47, 0x56, 0x7a, 0x64, 0x43, 0x35, 0x6e, 0x62, 0x32, 0x39, + 0x6e, 0x62, 0x47, 0x55, 0x75, 0x5a, 0x6e, 0x4b, 0x43, 0x47, 0x48, 0x64, + 0x68, 0x64, 0x47, 0x56, 0x79, 0x0a, 0x65, 0x6d, 0x39, 0x76, 0x61, 0x53, + 0x35, 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x4c, 0x6d, 0x64, 0x76, 0x62, 0x32, + 0x64, 0x73, 0x5a, 0x53, 0x35, 0x69, 0x5a, 0x59, 0x49, 0x53, 0x4b, 0x69, + 0x35, 0x30, 0x5a, 0x58, 0x4e, 0x30, 0x4c, 0x6e, 0x6c, 0x76, 0x64, 0x58, + 0x52, 0x31, 0x59, 0x6d, 0x55, 0x75, 0x59, 0x32, 0x39, 0x74, 0x68, 0x77, + 0x54, 0x41, 0x71, 0x41, 0x45, 0x44, 0x4d, 0x41, 0x30, 0x47, 0x0a, 0x43, + 0x53, 0x71, 0x47, 0x53, 0x49, 0x62, 0x33, 0x44, 0x51, 0x45, 0x42, 0x43, + 0x77, 0x55, 0x41, 0x41, 0x34, 0x47, 0x42, 0x41, 0x4a, 0x46, 0x58, 0x56, + 0x69, 0x66, 0x51, 0x4e, 0x75, 0x62, 0x31, 0x4c, 0x55, 0x50, 0x34, 0x4a, + 0x6c, 0x6e, 0x58, 0x35, 0x6c, 0x58, 0x4e, 0x6c, 0x6f, 0x38, 0x46, 0x78, + 0x5a, 0x32, 0x61, 0x31, 0x32, 0x41, 0x46, 0x51, 0x73, 0x2b, 0x62, 0x7a, + 0x6f, 0x4a, 0x36, 0x0a, 0x68, 0x4d, 0x30, 0x34, 0x34, 0x45, 0x44, 0x6a, + 0x71, 0x79, 0x78, 0x55, 0x71, 0x53, 0x62, 0x56, 0x65, 0x50, 0x4b, 0x30, + 0x6e, 0x69, 0x33, 0x77, 0x31, 0x66, 0x48, 0x51, 0x42, 0x35, 0x72, 0x59, + 0x39, 0x79, 0x59, 0x43, 0x35, 0x66, 0x38, 0x47, 0x37, 0x61, 0x71, 0x71, + 0x54, 0x59, 0x31, 0x51, 0x4f, 0x68, 0x6f, 0x55, 0x6b, 0x38, 0x5a, 0x54, + 0x53, 0x54, 0x52, 0x70, 0x6e, 0x6b, 0x54, 0x68, 0x0a, 0x79, 0x34, 0x6a, + 0x6a, 0x64, 0x76, 0x54, 0x5a, 0x65, 0x4c, 0x44, 0x56, 0x42, 0x6c, 0x75, + 0x65, 0x5a, 0x55, 0x54, 0x44, 0x52, 0x6d, 0x79, 0x32, 0x66, 0x65, 0x59, + 0x35, 0x61, 0x5a, 0x49, 0x55, 0x31, 0x38, 0x76, 0x46, 0x44, 0x4b, 0x30, + 0x38, 0x64, 0x54, 0x47, 0x30, 0x41, 0x38, 0x37, 0x70, 0x70, 0x70, 0x75, + 0x76, 0x31, 0x4c, 0x4e, 0x49, 0x52, 0x33, 0x6c, 0x6f, 0x76, 0x65, 0x55, + 0x38, 0x0a, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x45, 0x4e, 0x44, 0x20, 0x43, 0x45, 0x52, 0x54, 0x49, 0x46, 0x49, 0x43, 0x41, 0x54, 0x45, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x00}; diff --git a/test/core/end2end/fixtures/h2_fakesec.c b/test/core/end2end/fixtures/h2_fakesec.c index 3e64cc08e8..bc009e1df1 100644 --- a/test/core/end2end/fixtures/h2_fakesec.c +++ b/test/core/end2end/fixtures/h2_fakesec.c @@ -73,14 +73,14 @@ static void process_auth_failure(void *state, grpc_auth_context *ctx, cb(user_data, NULL, 0, NULL, 0, GRPC_STATUS_UNAUTHENTICATED, NULL); } -static void chttp2_init_client_secure_fullstack(grpc_end2end_test_fixture *f, - grpc_channel_args *client_args, - grpc_credentials *creds) { +static void chttp2_init_client_secure_fullstack( + grpc_end2end_test_fixture *f, grpc_channel_args *client_args, + grpc_channel_credentials *creds) { fullstack_secure_fixture_data *ffd = f->fixture_data; f->client = grpc_secure_channel_create(creds, ffd->localaddr, client_args, NULL); GPR_ASSERT(f->client != NULL); - grpc_credentials_release(creds); + grpc_channel_credentials_release(creds); } static void chttp2_init_server_secure_fullstack( @@ -106,7 +106,7 @@ void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) { static void chttp2_init_client_fake_secure_fullstack( grpc_end2end_test_fixture *f, grpc_channel_args *client_args) { - grpc_credentials *fake_ts_creds = + grpc_channel_credentials *fake_ts_creds = grpc_fake_transport_security_credentials_create(); chttp2_init_client_secure_fullstack(f, client_args, fake_ts_creds); } diff --git a/test/core/end2end/fixtures/h2_oauth2.c b/test/core/end2end/fixtures/h2_oauth2.c index 10db6c2c6a..7a34cc67d8 100644 --- a/test/core/end2end/fixtures/h2_oauth2.c +++ b/test/core/end2end/fixtures/h2_oauth2.c @@ -118,14 +118,14 @@ static grpc_end2end_test_fixture chttp2_create_fixture_secure_fullstack( return f; } -static void chttp2_init_client_secure_fullstack(grpc_end2end_test_fixture *f, - grpc_channel_args *client_args, - grpc_credentials *creds) { +static void chttp2_init_client_secure_fullstack( + grpc_end2end_test_fixture *f, grpc_channel_args *client_args, + grpc_channel_credentials *creds) { fullstack_secure_fixture_data *ffd = f->fixture_data; f->client = grpc_secure_channel_create(creds, ffd->localaddr, client_args, NULL); GPR_ASSERT(f->client != NULL); - grpc_credentials_release(creds); + grpc_channel_credentials_release(creds); } static void chttp2_init_server_secure_fullstack( @@ -151,12 +151,12 @@ void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) { static void chttp2_init_client_simple_ssl_with_oauth2_secure_fullstack( grpc_end2end_test_fixture *f, grpc_channel_args *client_args) { - grpc_credentials *ssl_creds = + grpc_channel_credentials *ssl_creds = grpc_ssl_credentials_create(test_root_cert, NULL, NULL); - grpc_credentials *oauth2_creds = + grpc_call_credentials *oauth2_creds = grpc_md_only_test_credentials_create("Authorization", oauth2_md, 1); - grpc_credentials *ssl_oauth2_creds = - grpc_composite_credentials_create(ssl_creds, oauth2_creds, NULL); + grpc_channel_credentials *ssl_oauth2_creds = + grpc_composite_channel_credentials_create(ssl_creds, oauth2_creds, NULL); grpc_arg ssl_name_override = {GRPC_ARG_STRING, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, {"foo.test.google.fr"}}; @@ -164,8 +164,8 @@ static void chttp2_init_client_simple_ssl_with_oauth2_secure_fullstack( grpc_channel_args_copy_and_add(client_args, &ssl_name_override, 1); chttp2_init_client_secure_fullstack(f, new_client_args, ssl_oauth2_creds); grpc_channel_args_destroy(new_client_args); - grpc_credentials_release(ssl_creds); - grpc_credentials_release(oauth2_creds); + grpc_channel_credentials_release(ssl_creds); + grpc_call_credentials_release(oauth2_creds); } static int fail_server_auth_check(grpc_channel_args *server_args) { diff --git a/test/core/end2end/fixtures/h2_sockpair+trace.c b/test/core/end2end/fixtures/h2_sockpair+trace.c index 1f5051f0ab..ccc8631d94 100644 --- a/test/core/end2end/fixtures/h2_sockpair+trace.c +++ b/test/core/end2end/fixtures/h2_sockpair+trace.c @@ -57,14 +57,13 @@ /* chttp2 transport that is immediately available (used for testing connected_channel without a client_channel */ -static void server_setup_transport(void *ts, grpc_transport *transport, - grpc_mdctx *mdctx) { +static void server_setup_transport(void *ts, grpc_transport *transport) { grpc_end2end_test_fixture *f = ts; static grpc_channel_filter const *extra_filters[] = { &grpc_http_server_filter}; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_server_setup_transport(&exec_ctx, f->server, transport, extra_filters, - GPR_ARRAY_SIZE(extra_filters), mdctx, + GPR_ARRAY_SIZE(extra_filters), grpc_server_get_channel_args(f->server)); grpc_exec_ctx_finish(&exec_ctx); } @@ -75,17 +74,15 @@ typedef struct { } sp_client_setup; static void client_setup_transport(grpc_exec_ctx *exec_ctx, void *ts, - grpc_transport *transport, - grpc_mdctx *mdctx) { + grpc_transport *transport) { sp_client_setup *cs = ts; const grpc_channel_filter *filters[] = {&grpc_http_client_filter, &grpc_compress_filter, &grpc_connected_channel_filter}; size_t nfilters = sizeof(filters) / sizeof(*filters); - grpc_channel *channel = - grpc_channel_create_from_filters(exec_ctx, "socketpair-target", filters, - nfilters, cs->client_args, mdctx, 1); + grpc_channel *channel = grpc_channel_create_from_filters( + exec_ctx, "socketpair-target", filters, nfilters, cs->client_args, 1); cs->f->client = channel; @@ -112,13 +109,12 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f, grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_endpoint_pair *sfd = f->fixture_data; grpc_transport *transport; - grpc_mdctx *mdctx = grpc_mdctx_create(); sp_client_setup cs; cs.client_args = client_args; cs.f = f; - transport = grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client, - mdctx, 1); - client_setup_transport(&exec_ctx, &cs, transport, mdctx); + transport = + grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client, 1); + client_setup_transport(&exec_ctx, &cs, transport); GPR_ASSERT(f->client); grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0); grpc_exec_ctx_finish(&exec_ctx); @@ -128,15 +124,14 @@ static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f, grpc_channel_args *server_args) { grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_endpoint_pair *sfd = f->fixture_data; - grpc_mdctx *mdctx = grpc_mdctx_create(); grpc_transport *transport; GPR_ASSERT(!f->server); f->server = grpc_server_create_from_filters(NULL, 0, server_args); grpc_server_register_completion_queue(f->server, f->cq, NULL); grpc_server_start(f->server); - transport = grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server, - mdctx, 0); - server_setup_transport(f, transport, mdctx); + transport = + grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server, 0); + server_setup_transport(f, transport); grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0); grpc_exec_ctx_finish(&exec_ctx); } diff --git a/test/core/end2end/fixtures/h2_sockpair.c b/test/core/end2end/fixtures/h2_sockpair.c index b61fe98610..a6a84c9b1a 100644 --- a/test/core/end2end/fixtures/h2_sockpair.c +++ b/test/core/end2end/fixtures/h2_sockpair.c @@ -56,14 +56,13 @@ /* chttp2 transport that is immediately available (used for testing connected_channel without a client_channel */ -static void server_setup_transport(void *ts, grpc_transport *transport, - grpc_mdctx *mdctx) { +static void server_setup_transport(void *ts, grpc_transport *transport) { grpc_end2end_test_fixture *f = ts; static grpc_channel_filter const *extra_filters[] = { &grpc_http_server_filter}; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_server_setup_transport(&exec_ctx, f->server, transport, extra_filters, - GPR_ARRAY_SIZE(extra_filters), mdctx, + GPR_ARRAY_SIZE(extra_filters), grpc_server_get_channel_args(f->server)); grpc_exec_ctx_finish(&exec_ctx); } @@ -74,17 +73,15 @@ typedef struct { } sp_client_setup; static void client_setup_transport(grpc_exec_ctx *exec_ctx, void *ts, - grpc_transport *transport, - grpc_mdctx *mdctx) { + grpc_transport *transport) { sp_client_setup *cs = ts; const grpc_channel_filter *filters[] = {&grpc_http_client_filter, &grpc_compress_filter, &grpc_connected_channel_filter}; size_t nfilters = sizeof(filters) / sizeof(*filters); - grpc_channel *channel = - grpc_channel_create_from_filters(exec_ctx, "socketpair-target", filters, - nfilters, cs->client_args, mdctx, 1); + grpc_channel *channel = grpc_channel_create_from_filters( + exec_ctx, "socketpair-target", filters, nfilters, cs->client_args, 1); cs->f->client = channel; @@ -111,13 +108,12 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f, grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_endpoint_pair *sfd = f->fixture_data; grpc_transport *transport; - grpc_mdctx *mdctx = grpc_mdctx_create(); sp_client_setup cs; cs.client_args = client_args; cs.f = f; - transport = grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client, - mdctx, 1); - client_setup_transport(&exec_ctx, &cs, transport, mdctx); + transport = + grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client, 1); + client_setup_transport(&exec_ctx, &cs, transport); GPR_ASSERT(f->client); grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0); grpc_exec_ctx_finish(&exec_ctx); @@ -127,15 +123,14 @@ static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f, grpc_channel_args *server_args) { grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_endpoint_pair *sfd = f->fixture_data; - grpc_mdctx *mdctx = grpc_mdctx_create(); grpc_transport *transport; GPR_ASSERT(!f->server); f->server = grpc_server_create_from_filters(NULL, 0, server_args); grpc_server_register_completion_queue(f->server, f->cq, NULL); grpc_server_start(f->server); - transport = grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server, - mdctx, 0); - server_setup_transport(f, transport, mdctx); + transport = + grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server, 0); + server_setup_transport(f, transport); grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0); grpc_exec_ctx_finish(&exec_ctx); } diff --git a/test/core/end2end/fixtures/h2_sockpair_1byte.c b/test/core/end2end/fixtures/h2_sockpair_1byte.c index 9f0fd2ea9a..4b8f9054ef 100644 --- a/test/core/end2end/fixtures/h2_sockpair_1byte.c +++ b/test/core/end2end/fixtures/h2_sockpair_1byte.c @@ -56,14 +56,13 @@ /* chttp2 transport that is immediately available (used for testing connected_channel without a client_channel */ -static void server_setup_transport(void *ts, grpc_transport *transport, - grpc_mdctx *mdctx) { +static void server_setup_transport(void *ts, grpc_transport *transport) { grpc_end2end_test_fixture *f = ts; static grpc_channel_filter const *extra_filters[] = { &grpc_http_server_filter}; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_server_setup_transport(&exec_ctx, f->server, transport, extra_filters, - GPR_ARRAY_SIZE(extra_filters), mdctx, + GPR_ARRAY_SIZE(extra_filters), grpc_server_get_channel_args(f->server)); grpc_exec_ctx_finish(&exec_ctx); } @@ -74,17 +73,15 @@ typedef struct { } sp_client_setup; static void client_setup_transport(grpc_exec_ctx *exec_ctx, void *ts, - grpc_transport *transport, - grpc_mdctx *mdctx) { + grpc_transport *transport) { sp_client_setup *cs = ts; const grpc_channel_filter *filters[] = {&grpc_http_client_filter, &grpc_compress_filter, &grpc_connected_channel_filter}; size_t nfilters = sizeof(filters) / sizeof(*filters); - grpc_channel *channel = - grpc_channel_create_from_filters(exec_ctx, "socketpair-target", filters, - nfilters, cs->client_args, mdctx, 1); + grpc_channel *channel = grpc_channel_create_from_filters( + exec_ctx, "socketpair-target", filters, nfilters, cs->client_args, 1); cs->f->client = channel; @@ -111,13 +108,12 @@ static void chttp2_init_client_socketpair(grpc_end2end_test_fixture *f, grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_endpoint_pair *sfd = f->fixture_data; grpc_transport *transport; - grpc_mdctx *mdctx = grpc_mdctx_create(); sp_client_setup cs; cs.client_args = client_args; cs.f = f; - transport = grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client, - mdctx, 1); - client_setup_transport(&exec_ctx, &cs, transport, mdctx); + transport = + grpc_create_chttp2_transport(&exec_ctx, client_args, sfd->client, 1); + client_setup_transport(&exec_ctx, &cs, transport); GPR_ASSERT(f->client); grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0); grpc_exec_ctx_finish(&exec_ctx); @@ -127,15 +123,14 @@ static void chttp2_init_server_socketpair(grpc_end2end_test_fixture *f, grpc_channel_args *server_args) { grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_endpoint_pair *sfd = f->fixture_data; - grpc_mdctx *mdctx = grpc_mdctx_create(); grpc_transport *transport; GPR_ASSERT(!f->server); f->server = grpc_server_create_from_filters(NULL, 0, server_args); grpc_server_register_completion_queue(f->server, f->cq, NULL); grpc_server_start(f->server); - transport = grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server, - mdctx, 0); - server_setup_transport(f, transport, mdctx); + transport = + grpc_create_chttp2_transport(&exec_ctx, server_args, sfd->server, 0); + server_setup_transport(f, transport); grpc_chttp2_transport_start_reading(&exec_ctx, transport, NULL, 0); grpc_exec_ctx_finish(&exec_ctx); } diff --git a/test/core/end2end/fixtures/h2_ssl+poll.c b/test/core/end2end/fixtures/h2_ssl+poll.c index c2f41f4886..37e1758f00 100644 --- a/test/core/end2end/fixtures/h2_ssl+poll.c +++ b/test/core/end2end/fixtures/h2_ssl+poll.c @@ -76,14 +76,14 @@ static void process_auth_failure(void *state, grpc_auth_context *ctx, cb(user_data, NULL, 0, NULL, 0, GRPC_STATUS_UNAUTHENTICATED, NULL); } -static void chttp2_init_client_secure_fullstack(grpc_end2end_test_fixture *f, - grpc_channel_args *client_args, - grpc_credentials *creds) { +static void chttp2_init_client_secure_fullstack( + grpc_end2end_test_fixture *f, grpc_channel_args *client_args, + grpc_channel_credentials *creds) { fullstack_secure_fixture_data *ffd = f->fixture_data; f->client = grpc_secure_channel_create(creds, ffd->localaddr, client_args, NULL); GPR_ASSERT(f->client != NULL); - grpc_credentials_release(creds); + grpc_channel_credentials_release(creds); } static void chttp2_init_server_secure_fullstack( @@ -109,7 +109,8 @@ void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) { static void chttp2_init_client_simple_ssl_secure_fullstack( grpc_end2end_test_fixture *f, grpc_channel_args *client_args) { - grpc_credentials *ssl_creds = grpc_ssl_credentials_create(NULL, NULL, NULL); + grpc_channel_credentials *ssl_creds = + grpc_ssl_credentials_create(NULL, NULL, NULL); grpc_arg ssl_name_override = {GRPC_ARG_STRING, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, {"foo.test.google.fr"}}; diff --git a/test/core/end2end/fixtures/h2_ssl.c b/test/core/end2end/fixtures/h2_ssl.c index 896c60c507..f5a006bd08 100644 --- a/test/core/end2end/fixtures/h2_ssl.c +++ b/test/core/end2end/fixtures/h2_ssl.c @@ -76,14 +76,14 @@ static void process_auth_failure(void *state, grpc_auth_context *ctx, cb(user_data, NULL, 0, NULL, 0, GRPC_STATUS_UNAUTHENTICATED, NULL); } -static void chttp2_init_client_secure_fullstack(grpc_end2end_test_fixture *f, - grpc_channel_args *client_args, - grpc_credentials *creds) { +static void chttp2_init_client_secure_fullstack( + grpc_end2end_test_fixture *f, grpc_channel_args *client_args, + grpc_channel_credentials *creds) { fullstack_secure_fixture_data *ffd = f->fixture_data; f->client = grpc_secure_channel_create(creds, ffd->localaddr, client_args, NULL); GPR_ASSERT(f->client != NULL); - grpc_credentials_release(creds); + grpc_channel_credentials_release(creds); } static void chttp2_init_server_secure_fullstack( @@ -109,7 +109,8 @@ void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) { static void chttp2_init_client_simple_ssl_secure_fullstack( grpc_end2end_test_fixture *f, grpc_channel_args *client_args) { - grpc_credentials *ssl_creds = grpc_ssl_credentials_create(NULL, NULL, NULL); + grpc_channel_credentials *ssl_creds = + grpc_ssl_credentials_create(NULL, NULL, NULL); grpc_arg ssl_name_override = {GRPC_ARG_STRING, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, {"foo.test.google.fr"}}; diff --git a/test/core/end2end/fixtures/h2_ssl_proxy.c b/test/core/end2end/fixtures/h2_ssl_proxy.c index 413a8b84cd..7233cdbe2d 100644 --- a/test/core/end2end/fixtures/h2_ssl_proxy.c +++ b/test/core/end2end/fixtures/h2_ssl_proxy.c @@ -66,7 +66,8 @@ static grpc_server *create_proxy_server(const char *port) { static grpc_channel *create_proxy_client(const char *target) { grpc_channel *channel; - grpc_credentials *ssl_creds = grpc_ssl_credentials_create(NULL, NULL, NULL); + grpc_channel_credentials *ssl_creds = + grpc_ssl_credentials_create(NULL, NULL, NULL); grpc_arg ssl_name_override = {GRPC_ARG_STRING, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, {"foo.test.google.fr"}}; @@ -74,7 +75,7 @@ static grpc_channel *create_proxy_client(const char *target) { client_args.num_args = 1; client_args.args = &ssl_name_override; channel = grpc_secure_channel_create(ssl_creds, target, &client_args, NULL); - grpc_credentials_release(ssl_creds); + grpc_channel_credentials_release(ssl_creds); return channel; } @@ -104,15 +105,15 @@ static void process_auth_failure(void *state, grpc_auth_context *ctx, cb(user_data, NULL, 0, NULL, 0, GRPC_STATUS_UNAUTHENTICATED, NULL); } -static void chttp2_init_client_secure_fullstack(grpc_end2end_test_fixture *f, - grpc_channel_args *client_args, - grpc_credentials *creds) { +static void chttp2_init_client_secure_fullstack( + grpc_end2end_test_fixture *f, grpc_channel_args *client_args, + grpc_channel_credentials *creds) { fullstack_secure_fixture_data *ffd = f->fixture_data; f->client = grpc_secure_channel_create( creds, grpc_end2end_proxy_get_client_target(ffd->proxy), client_args, NULL); GPR_ASSERT(f->client != NULL); - grpc_credentials_release(creds); + grpc_channel_credentials_release(creds); } static void chttp2_init_server_secure_fullstack( @@ -138,7 +139,8 @@ void chttp2_tear_down_secure_fullstack(grpc_end2end_test_fixture *f) { static void chttp2_init_client_simple_ssl_secure_fullstack( grpc_end2end_test_fixture *f, grpc_channel_args *client_args) { - grpc_credentials *ssl_creds = grpc_ssl_credentials_create(NULL, NULL, NULL); + grpc_channel_credentials *ssl_creds = + grpc_ssl_credentials_create(NULL, NULL, NULL); grpc_arg ssl_name_override = {GRPC_ARG_STRING, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, {"foo.test.google.fr"}}; diff --git a/test/core/end2end/fixtures/h2_uchannel.c b/test/core/end2end/fixtures/h2_uchannel.c index d1f9d38b82..ee4a60c29a 100644 --- a/test/core/end2end/fixtures/h2_uchannel.c +++ b/test/core/end2end/fixtures/h2_uchannel.c @@ -66,8 +66,6 @@ typedef struct { grpc_endpoint *tcp; - grpc_mdctx *mdctx; - grpc_closure connected; } connector; @@ -79,7 +77,6 @@ static void connector_ref(grpc_connector *con) { static void connector_unref(grpc_exec_ctx *exec_ctx, grpc_connector *con) { connector *c = (connector *)con; if (gpr_unref(&c->refs)) { - grpc_mdctx_unref(c->mdctx); gpr_free(c); } } @@ -89,8 +86,8 @@ static void connected(grpc_exec_ctx *exec_ctx, void *arg, int success) { grpc_closure *notify; grpc_endpoint *tcp = c->tcp; if (tcp != NULL) { - c->result->transport = grpc_create_chttp2_transport( - exec_ctx, c->args.channel_args, tcp, c->mdctx, 1); + c->result->transport = + grpc_create_chttp2_transport(exec_ctx, c->args.channel_args, tcp, 1); grpc_chttp2_transport_start_reading(exec_ctx, c->result->transport, NULL, 0); GPR_ASSERT(c->result->transport); @@ -130,7 +127,6 @@ static const grpc_connector_vtable connector_vtable = { typedef struct { grpc_subchannel_factory base; gpr_refcount refs; - grpc_mdctx *mdctx; grpc_channel_args *merge_args; grpc_channel *master; grpc_subchannel **sniffed_subchannel; @@ -147,7 +143,6 @@ static void subchannel_factory_unref(grpc_exec_ctx *exec_ctx, if (gpr_unref(&f->refs)) { GRPC_CHANNEL_INTERNAL_UNREF(exec_ctx, f->master, "subchannel_factory"); grpc_channel_args_destroy(f->merge_args); - grpc_mdctx_unref(f->mdctx); gpr_free(f); } } @@ -162,10 +157,7 @@ static grpc_subchannel *subchannel_factory_create_subchannel( grpc_subchannel *s; memset(c, 0, sizeof(*c)); c->base.vtable = &connector_vtable; - c->mdctx = f->mdctx; - grpc_mdctx_ref(c->mdctx); gpr_ref_init(&c->refs, 1); - args->mdctx = f->mdctx; args->args = final_args; args->master = f->master; s = grpc_subchannel_create(&c->base, args); @@ -188,22 +180,19 @@ grpc_channel *channel_create(const char *target, const grpc_channel_args *args, const grpc_channel_filter *filters[MAX_FILTERS]; grpc_resolver *resolver; subchannel_factory *f; - grpc_mdctx *mdctx = grpc_mdctx_create(); grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; size_t n = 0; filters[n++] = &grpc_client_channel_filter; GPR_ASSERT(n <= MAX_FILTERS); - channel = grpc_channel_create_from_filters(&exec_ctx, target, filters, n, - args, mdctx, 1); + channel = + grpc_channel_create_from_filters(&exec_ctx, target, filters, n, args, 1); f = gpr_malloc(sizeof(*f)); f->sniffed_subchannel = sniffed_subchannel; f->base.vtable = &test_subchannel_factory_vtable; gpr_ref_init(&f->refs, 1); - grpc_mdctx_ref(mdctx); - f->mdctx = mdctx; f->merge_args = grpc_channel_args_copy(args); f->master = channel; GRPC_CHANNEL_INTERNAL_REF(f->master, "test_subchannel_factory"); diff --git a/test/core/end2end/gen_build_yaml.py b/test/core/end2end/gen_build_yaml.py index af8f48576c..6cb4a7a91d 100755 --- a/test/core/end2end/gen_build_yaml.py +++ b/test/core/end2end/gen_build_yaml.py @@ -37,8 +37,11 @@ import collections import hashlib -FixtureOptions = collections.namedtuple('FixtureOptions', 'fullstack includes_proxy dns_resolver secure platforms ci_mac') -default_unsecure_fixture_options = FixtureOptions(True, False, True, False, ['windows', 'linux', 'mac', 'posix'], True) +FixtureOptions = collections.namedtuple( + 'FixtureOptions', + 'fullstack includes_proxy dns_resolver secure platforms ci_mac tracing') +default_unsecure_fixture_options = FixtureOptions( + True, False, True, False, ['windows', 'linux', 'mac', 'posix'], True, False) socketpair_unsecure_fixture_options = default_unsecure_fixture_options._replace(fullstack=False, dns_resolver=False) default_secure_fixture_options = default_unsecure_fixture_options._replace(secure=True) uds_fixture_options = default_unsecure_fixture_options._replace(dns_resolver=False, platforms=['linux', 'mac', 'posix']) @@ -46,62 +49,73 @@ uds_fixture_options = default_unsecure_fixture_options._replace(dns_resolver=Fal # maps fixture name to whether it requires the security library END2END_FIXTURES = { + 'h2_compress': default_unsecure_fixture_options, 'h2_fakesec': default_secure_fixture_options._replace(ci_mac=False), 'h2_full': default_unsecure_fixture_options, - 'h2_uchannel': default_unsecure_fixture_options, - 'h2_compress': default_unsecure_fixture_options, - 'h2_uds': uds_fixture_options, - 'h2_uds+poll': uds_fixture_options._replace(platforms=['linux']), - 'h2_full+poll': default_unsecure_fixture_options._replace(platforms=['linux']), - 'h2_proxy': default_unsecure_fixture_options._replace(includes_proxy=True, ci_mac=False), - 'h2_ssl': default_secure_fixture_options, - 'h2_ssl+poll': default_secure_fixture_options._replace(platforms=['linux']), - 'h2_ssl_proxy': default_secure_fixture_options._replace(includes_proxy=True, ci_mac=False), + 'h2_full+poll': default_unsecure_fixture_options._replace( + platforms=['linux']), 'h2_oauth2': default_secure_fixture_options._replace(ci_mac=False), + 'h2_proxy': default_unsecure_fixture_options._replace(includes_proxy=True, + ci_mac=False), + 'h2_sockpair_1byte': socketpair_unsecure_fixture_options._replace( + ci_mac=False), 'h2_sockpair': socketpair_unsecure_fixture_options._replace(ci_mac=False), - 'h2_sockpair_1byte': socketpair_unsecure_fixture_options._replace(ci_mac=False), - 'h2_sockpair+trace': socketpair_unsecure_fixture_options, + 'h2_sockpair+trace': socketpair_unsecure_fixture_options._replace( + tracing=True), + 'h2_ssl': default_secure_fixture_options, + 'h2_ssl+poll': default_secure_fixture_options._replace(platforms=['linux']), + 'h2_ssl_proxy': default_secure_fixture_options._replace(includes_proxy=True, + ci_mac=False), + 'h2_uchannel': default_unsecure_fixture_options, + 'h2_uds+poll': uds_fixture_options._replace(platforms=['linux']), + 'h2_uds': uds_fixture_options, } -TestOptions = collections.namedtuple('TestOptions', 'needs_fullstack needs_dns proxyable flaky secure') -default_test_options = TestOptions(False, False, True, False, False) +TestOptions = collections.namedtuple( + 'TestOptions', 'needs_fullstack needs_dns proxyable flaky secure traceable') +default_test_options = TestOptions(False, False, True, False, False, True) connectivity_test_options = default_test_options._replace(needs_fullstack=True) # maps test names to options END2END_TESTS = { 'bad_hostname': default_test_options, - 'cancel_after_client_done': default_test_options, + 'binary_metadata': default_test_options, + 'call_creds': default_test_options._replace(secure=True), 'cancel_after_accept': default_test_options, + 'cancel_after_client_done': default_test_options, 'cancel_after_invoke': default_test_options, 'cancel_before_invoke': default_test_options, 'cancel_in_a_vacuum': default_test_options, + 'cancel_with_status': default_test_options, 'census_simple_request': default_test_options, 'channel_connectivity': connectivity_test_options._replace(proxyable=False), - 'default_host': default_test_options._replace(needs_fullstack=True, needs_dns=True), + 'compressed_payload': default_test_options._replace(proxyable=False), + 'default_host': default_test_options._replace(needs_fullstack=True, + needs_dns=True), 'disappearing_server': connectivity_test_options, - 'shutdown_finishes_calls': default_test_options, - 'shutdown_finishes_tags': default_test_options, 'empty_batch': default_test_options, 'graceful_server_shutdown': default_test_options, + 'hpack_size': default_test_options._replace(proxyable=False, + traceable=False), + 'high_initial_seqno': default_test_options, 'invoke_large_request': default_test_options, + 'large_metadata': default_test_options, 'max_concurrent_streams': default_test_options._replace(proxyable=False), 'max_message_length': default_test_options, + 'metadata': default_test_options, + 'negative_deadline': default_test_options, 'no_op': default_test_options, + 'payload': default_test_options, 'ping_pong_streaming': default_test_options, 'registered_call': default_test_options, - 'binary_metadata': default_test_options, - 'metadata': default_test_options, - 'call_creds': default_test_options._replace(secure=True), - 'payload': default_test_options, - 'trailing_metadata': default_test_options, - 'compressed_payload': default_test_options._replace(proxyable=False), 'request_with_flags': default_test_options._replace(proxyable=False), - 'large_metadata': default_test_options, 'request_with_payload': default_test_options, 'server_finishes_request': default_test_options, + 'shutdown_finishes_calls': default_test_options, + 'shutdown_finishes_tags': default_test_options, 'simple_delayed_request': connectivity_test_options, 'simple_request': default_test_options, - 'high_initial_seqno': default_test_options, + 'trailing_metadata': default_test_options, } @@ -115,6 +129,9 @@ def compatible(f, t): if not END2END_TESTS[t].proxyable: if END2END_FIXTURES[f].includes_proxy: return False + if not END2END_TESTS[t].traceable: + if END2END_FIXTURES[f].tracing: + return False return True @@ -147,12 +164,27 @@ def main(): 'language': 'c', 'secure': 'check' if END2END_FIXTURES[f].secure else False, 'src': ['test/core/end2end/fixtures/%s.c' % f], - 'platforms': [ 'linux', 'mac', 'posix' ] if f.endswith('_posix') else END2END_FIXTURES[f].platforms, - 'deps': sec_deps if END2END_FIXTURES[f].secure else unsec_deps, + 'platforms': ['linux', 'mac', 'posix'] if f.endswith('_posix') + else END2END_FIXTURES[f].platforms, + 'deps': sec_deps, 'headers': ['test/core/end2end/end2end_tests.h'], 'vs_proj_dir': 'test', - } - for f in sorted(END2END_FIXTURES.keys())] + [ + } for f in sorted(END2END_FIXTURES.keys()) + ] + [ + { + 'name': 'end2end_nosec_fixture_%s' % f, + 'build': 'private', + 'language': 'c', + 'secure': False, + 'src': ['test/core/end2end/fixtures/%s.c' % f], + 'platforms': ['linux', 'mac', 'posix'] if f.endswith('_posix') + else END2END_FIXTURES[f].platforms, + 'deps': unsec_deps, + 'headers': ['test/core/end2end/end2end_tests.h'], + 'vs_proj_dir': 'test', + } for f in sorted(END2END_FIXTURES.keys()) + if not END2END_FIXTURES[f].secure + ] + [ { 'name': 'end2end_test_%s' % t, 'build': 'private', @@ -161,10 +193,23 @@ def main(): 'src': ['test/core/end2end/tests/%s.c' % t], 'headers': ['test/core/end2end/tests/cancel_test_helpers.h', 'test/core/end2end/end2end_tests.h'], - 'deps': sec_deps if END2END_TESTS[t].secure else unsec_deps, + 'deps': sec_deps, 'vs_proj_dir': 'test', - } - for t in sorted(END2END_TESTS.keys())] + [ + } for t in sorted(END2END_TESTS.keys()) + ] + [ + { + 'name': 'end2end_nosec_test_%s' % t, + 'build': 'private', + 'language': 'c', + 'secure': False, + 'src': ['test/core/end2end/tests/%s.c' % t], + 'headers': ['test/core/end2end/tests/cancel_test_helpers.h', + 'test/core/end2end/end2end_tests.h'], + 'deps': unsec_deps, + 'vs_proj_dir': 'test', + } for t in sorted(END2END_TESTS.keys()) + if not END2END_TESTS[t].secure + ] + [ { 'name': 'end2end_certs', 'build': 'private', @@ -176,7 +221,7 @@ def main(): ], 'vs_proj_dir': 'test', } - ], + ], 'targets': [ { 'name': '%s_%s_test' % (f, t), @@ -185,17 +230,17 @@ def main(): 'src': [], 'flaky': END2END_TESTS[t].flaky, 'platforms': END2END_FIXTURES[f].platforms, - 'ci_platforms': (END2END_FIXTURES[f].platforms - if END2END_FIXTURES[f].ci_mac - else without(END2END_FIXTURES[f].platforms, 'mac')), + 'ci_platforms': (END2END_FIXTURES[f].platforms + if END2END_FIXTURES[f].ci_mac else without( + END2END_FIXTURES[f].platforms, 'mac')), 'deps': [ - 'end2end_fixture_%s' % f, - 'end2end_test_%s' % t] + sec_deps, + 'end2end_fixture_%s' % f, 'end2end_test_%s' % t + ] + sec_deps, 'vs_proj_dir': 'test', } - for f in sorted(END2END_FIXTURES.keys()) - for t in sorted(END2END_TESTS.keys()) - if compatible(f, t)] + [ + for f in sorted(END2END_FIXTURES.keys()) + for t in sorted(END2END_TESTS.keys()) if compatible(f, t) + ] + [ { 'name': '%s_%s_nosec_test' % (f, t), 'build': 'test', @@ -204,16 +249,20 @@ def main(): 'src': [], 'flaky': END2END_TESTS[t].flaky, 'platforms': END2END_FIXTURES[f].platforms, - 'ci_platforms': (END2END_FIXTURES[f].platforms - if END2END_FIXTURES[f].ci_mac - else without(END2END_FIXTURES[f].platforms, 'mac')), + 'ci_platforms': (END2END_FIXTURES[f].platforms + if END2END_FIXTURES[f].ci_mac else without( + END2END_FIXTURES[f].platforms, 'mac')), 'deps': [ - 'end2end_fixture_%s' % f, - 'end2end_test_%s' % t] + unsec_deps, + 'end2end_nosec_fixture_%s' % f, 'end2end_nosec_test_%s' % t + ] + unsec_deps, 'vs_proj_dir': 'test', } - for f in sorted(END2END_FIXTURES.keys()) if not END2END_FIXTURES[f].secure - for t in sorted(END2END_TESTS.keys()) if compatible(f, t) and not END2END_TESTS[t].secure]} + for f in sorted(END2END_FIXTURES.keys()) + if not END2END_FIXTURES[f].secure + for t in sorted(END2END_TESTS.keys()) + if compatible(f, t) and not END2END_TESTS[t].secure + ] + } print yaml.dump(json) diff --git a/test/core/end2end/tests/call_creds.c b/test/core/end2end/tests/call_creds.c index 4aeade1336..bbfad21b62 100644 --- a/test/core/end2end/tests/call_creds.c +++ b/test/core/end2end/tests/call_creds.c @@ -132,27 +132,6 @@ static void print_auth_context(int is_client, const grpc_auth_context *ctx) { } } -static void test_call_creds_failure(grpc_end2end_test_config config) { - grpc_call *c; - grpc_credentials *creds = NULL; - grpc_end2end_test_fixture f = - begin_test(config, "test_call_creds_failure", 0); - gpr_timespec deadline = five_seconds_time(); - c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, - "/foo", "foo.test.google.fr", deadline, NULL); - GPR_ASSERT(c); - - /* Try with credentials unfit to be set on a call (channel creds). */ - creds = grpc_fake_transport_security_credentials_create(); - GPR_ASSERT(grpc_call_set_credentials(c, creds) != GRPC_CALL_OK); - grpc_credentials_release(creds); - - grpc_call_destroy(c); - - end_test(&f); - config.tear_down_data(&f); -} - static void request_response_with_payload_and_call_creds( const char *test_name, grpc_end2end_test_config config, override_mode mode) { @@ -180,7 +159,7 @@ static void request_response_with_payload_and_call_creds( char *details = NULL; size_t details_capacity = 0; int was_cancelled = 2; - grpc_credentials *creds = NULL; + grpc_call_credentials *creds = NULL; grpc_auth_context *s_auth_context = NULL; grpc_auth_context *c_auth_context = NULL; @@ -197,7 +176,7 @@ static void request_response_with_payload_and_call_creds( case NONE: break; case OVERRIDE: - grpc_credentials_release(creds); + grpc_call_credentials_release(creds); creds = grpc_google_iam_credentials_create(overridden_iam_token, overridden_iam_selector, NULL); GPR_ASSERT(creds != NULL); @@ -207,7 +186,7 @@ static void request_response_with_payload_and_call_creds( GPR_ASSERT(grpc_call_set_credentials(c, NULL) == GRPC_CALL_OK); break; } - grpc_credentials_release(creds); + grpc_call_credentials_release(creds); grpc_metadata_array_init(&initial_metadata_recv); grpc_metadata_array_init(&trailing_metadata_recv); @@ -412,7 +391,7 @@ static void test_request_with_server_rejecting_client_creds( gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world"); grpc_byte_buffer *request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1); - grpc_credentials *creds; + grpc_call_credentials *creds; f = begin_test(config, "test_request_with_server_rejecting_client_creds", 1); cqv = cq_verifier_create(f.cq); @@ -424,7 +403,7 @@ static void test_request_with_server_rejecting_client_creds( creds = grpc_google_iam_credentials_create(iam_token, iam_selector, NULL); GPR_ASSERT(creds != NULL); GPR_ASSERT(grpc_call_set_credentials(c, creds) == GRPC_CALL_OK); - grpc_credentials_release(creds); + grpc_call_credentials_release(creds); grpc_metadata_array_init(&initial_metadata_recv); grpc_metadata_array_init(&trailing_metadata_recv); @@ -490,7 +469,6 @@ static void test_request_with_server_rejecting_client_creds( void grpc_end2end_tests(grpc_end2end_test_config config) { if (config.feature_mask & FEATURE_MASK_SUPPORTS_PER_CALL_CREDENTIALS) { - test_call_creds_failure(config); test_request_response_with_payload_and_call_creds(config); test_request_response_with_payload_and_overridden_call_creds(config); test_request_response_with_payload_and_deleted_call_creds(config); diff --git a/test/core/end2end/tests/cancel_with_status.c b/test/core/end2end/tests/cancel_with_status.c new file mode 100644 index 0000000000..2005e5f881 --- /dev/null +++ b/test/core/end2end/tests/cancel_with_status.c @@ -0,0 +1,184 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include "test/core/end2end/end2end_tests.h" + +#include <stdio.h> +#include <string.h> + +#include "src/core/support/string.h" +#include <grpc/byte_buffer.h> +#include <grpc/grpc.h> +#include <grpc/support/alloc.h> +#include <grpc/support/log.h> +#include <grpc/support/time.h> +#include <grpc/support/useful.h> +#include "test/core/end2end/cq_verifier.h" + +enum { TIMEOUT = 200000 }; + +static void *tag(gpr_intptr t) { return (void *)t; } + +static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, + const char *test_name, + grpc_channel_args *client_args, + grpc_channel_args *server_args) { + grpc_end2end_test_fixture f; + gpr_log(GPR_INFO, "%s/%s", test_name, config.name); + f = config.create_fixture(client_args, server_args); + config.init_client(&f, client_args); + config.init_server(&f, server_args); + return f; +} + +static gpr_timespec n_seconds_time(int n) { + return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); +} + +static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } + +static void drain_cq(grpc_completion_queue *cq) { + grpc_event ev; + do { + ev = grpc_completion_queue_next(cq, five_seconds_time(), NULL); + } while (ev.type != GRPC_QUEUE_SHUTDOWN); +} + +static void shutdown_server(grpc_end2end_test_fixture *f) { + if (!f->server) return; + grpc_server_shutdown_and_notify(f->server, f->cq, tag(1000)); + GPR_ASSERT(grpc_completion_queue_pluck(f->cq, tag(1000), + GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5), + NULL).type == GRPC_OP_COMPLETE); + grpc_server_destroy(f->server); + f->server = NULL; +} + +static void shutdown_client(grpc_end2end_test_fixture *f) { + if (!f->client) return; + grpc_channel_destroy(f->client); + f->client = NULL; +} + +static void end_test(grpc_end2end_test_fixture *f) { + shutdown_server(f); + shutdown_client(f); + + grpc_completion_queue_shutdown(f->cq); + drain_cq(f->cq); + grpc_completion_queue_destroy(f->cq); +} + +static void simple_request_body(grpc_end2end_test_fixture f, size_t num_ops) { + grpc_call *c; + gpr_timespec deadline = five_seconds_time(); + cq_verifier *cqv = cq_verifier_create(f.cq); + grpc_op ops[6]; + grpc_op *op; + grpc_metadata_array initial_metadata_recv; + grpc_metadata_array trailing_metadata_recv; + grpc_status_code status; + grpc_call_error error; + char *details = NULL; + size_t details_capacity = 0; + + gpr_log(GPR_DEBUG, "test with %d ops", num_ops); + + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr:1234", deadline, + NULL); + GPR_ASSERT(c); + + grpc_metadata_array_init(&initial_metadata_recv); + grpc_metadata_array_init(&trailing_metadata_recv); + + op = ops; + op->op = GRPC_OP_RECV_STATUS_ON_CLIENT; + op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv; + op->data.recv_status_on_client.status = &status; + op->data.recv_status_on_client.status_details = &details; + op->data.recv_status_on_client.status_details_capacity = &details_capacity; + op->flags = 0; + op->reserved = NULL; + op++; + op->op = GRPC_OP_RECV_INITIAL_METADATA; + op->data.recv_initial_metadata = &initial_metadata_recv; + op->flags = 0; + op->reserved = NULL; + op++; + op->op = GRPC_OP_SEND_INITIAL_METADATA; + op->data.send_initial_metadata.count = 0; + op->flags = 0; + op->reserved = NULL; + op++; + op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT; + op->flags = 0; + op->reserved = NULL; + op++; + GPR_ASSERT(num_ops <= (size_t)(op - ops)); + error = grpc_call_start_batch(c, ops, num_ops, tag(1), NULL); + GPR_ASSERT(GRPC_CALL_OK == error); + + grpc_call_cancel_with_status(c, GRPC_STATUS_UNIMPLEMENTED, "xyz", NULL); + + cq_expect_completion(cqv, tag(1), 1); + cq_verify(cqv); + + GPR_ASSERT(status == GRPC_STATUS_UNIMPLEMENTED); + GPR_ASSERT(0 == strcmp(details, "xyz")); + + gpr_free(details); + grpc_metadata_array_destroy(&initial_metadata_recv); + grpc_metadata_array_destroy(&trailing_metadata_recv); + + grpc_call_destroy(c); + + cq_verifier_destroy(cqv); +} + +static void test_invoke_simple_request(grpc_end2end_test_config config, + size_t num_ops) { + grpc_end2end_test_fixture f; + + f = begin_test(config, "test_invoke_simple_request", NULL, NULL); + simple_request_body(f, num_ops); + end_test(&f); + config.tear_down_data(&f); +} + +void grpc_end2end_tests(grpc_end2end_test_config config) { + size_t i; + for (i = 1; i <= 4; i++) { + test_invoke_simple_request(config, i); + } +} diff --git a/test/core/end2end/tests/hpack_size.c b/test/core/end2end/tests/hpack_size.c new file mode 100644 index 0000000000..997969d3cc --- /dev/null +++ b/test/core/end2end/tests/hpack_size.c @@ -0,0 +1,446 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include "test/core/end2end/end2end_tests.h" + +#include <stdio.h> +#include <string.h> + +#include <grpc/byte_buffer.h> +#include <grpc/grpc.h> +#include <grpc/support/alloc.h> +#include <grpc/support/log.h> +#include <grpc/support/string_util.h> +#include <grpc/support/time.h> +#include <grpc/support/useful.h> + +#include "src/core/support/string.h" +#include "test/core/end2end/cq_verifier.h" + +static void *tag(gpr_intptr t) { return (void *)t; } + +const char *hobbits[][2] = {{"Adaldrida", "Brandybuck"}, + {"Adamanta", "Took"}, + {"Adalgrim", "Took"}, + {"Adelard", "Took"}, + {"Amaranth", "Brandybuck"}, + {"Andwise", "Roper"}, + {"Angelica", "Baggins"}, + {"Asphodel", "Burrows"}, + {"Balbo", "Baggins"}, + {"Bandobras", "Took"}, + {"Belba", "Bolger"}, + {"Bell", "Gamgee"}, + {"Belladonna", "Baggins"}, + {"Berylla", "Baggins"}, + {"Bilbo", "Baggins"}, + {"Bilbo", "Gardner"}, + {"Bill", "Butcher"}, + {"Bingo", "Baggins"}, + {"Bodo", "Proudfoot"}, + {"Bowman", "Cotton"}, + {"Bungo", "Baggins"}, + {"Camellia", "Sackville"}, + {"Carl", "Cotton"}, + {"Celandine", "Brandybuck"}, + {"Chica", "Baggins"}, + {"Daddy", "Twofoot"}, + {"Daisy", "Boffin"}, + {"Diamond", "Took"}, + {"Dinodas", "Brandybuck"}, + {"Doderic", "Brandybuck"}, + {"Dodinas", "Brandybuck"}, + {"Donnamira", "Boffin"}, + {"Dora", "Baggins"}, + {"Drogo", "Baggins"}, + {"Dudo", "Baggins"}, + {"Eglantine", "Took"}, + {"Elanor", "Fairbairn"}, + {"Elfstan", "Fairbairn"}, + {"Esmeralda", "Brandybuck"}, + {"Estella", "Brandybuck"}, + {"Everard", "Took"}, + {"Falco", "Chubb-Baggins"}, + {"Faramir", "Took"}, + {"Farmer", "Maggot"}, + {"Fastolph", "Bolger"}, + {"Ferdibrand", "Took"}, + {"Ferdinand", "Took"}, + {"Ferumbras", "Took"}, + {"Ferumbras", "Took"}, + {"Filibert", "Bolger"}, + {"Firiel", "Fairbairn"}, + {"Flambard", "Took"}, + {"Folco", "Boffin"}, + {"Fortinbras", "Took"}, + {"Fortinbras", "Took"}, + {"Fosco", "Baggins"}, + {"Fredegar", "Bolger"}, + {"Frodo", "Baggins"}, + {"Frodo", "Gardner"}, + {"Gerontius", "Took"}, + {"Gilly", "Baggins"}, + {"Goldilocks", "Took"}, + {"Gorbadoc", "Brandybuck"}, + {"Gorbulas", "Brandybuck"}, + {"Gorhendad", "Brandybuck"}, + {"Gormadoc", "Brandybuck"}, + {"Griffo", "Boffin"}, + {"Halfast", "Gamgee"}, + {"Halfred", "Gamgee"}, + {"Halfred", "Greenhand"}, + {"Hanna", "Brandybuck"}, + {"Hamfast", "Gamgee"}, + {"Hamfast", "Gardner"}, + {"Hamson", "Gamgee"}, + {"Harding", "Gardner"}, + {"Hilda", "Brandybuck"}, + {"Hildibrand", "Took"}, + {"Hildifons", "Took"}, + {"Hildigard", "Took"}, + {"Hildigrim", "Took"}, + {"Hob", "Gammidge"}, + {"Hob", "Hayward"}, + {"Hobson", "Gamgee"}, + {"Holfast", "Gardner"}, + {"Holman", "Cotton"}, + {"Holman", "Greenhand"}, + {"Hugo", "Boffin"}, + {"Hugo", "Bracegirdle"}, + {"Ilberic", "Brandybuck"}, + {"Isembard", "Took"}, + {"Isembold", "Took"}, + {"Isengar", "Took"}, + {"Isengrim", "Took"}, + {"Isengrim", "Took"}, + {"Isumbras", "Took"}, + {"Isumbras", "Took"}, + {"Jolly", "Cotton"}, + {"Lalia", "Took"}, + {"Largo", "Baggins"}, + {"Laura", "Baggins"}, + {"Lily", "Goodbody"}, + {"Lily", "Cotton"}, + {"Linda", "Proudfoot"}, + {"Lobelia", "Sackville-Baggins"}, + {"Longo", "Baggins"}, + {"Lotho", "Sackville-Baggins"}, + {"Madoc", "Brandybuck"}, + {"Malva", "Brandybuck"}, + {"Marigold", "Cotton"}, + {"Marmadas", "Brandybuck"}, + {"Marmadoc", "Brandybuck"}, + {"Marroc", "Brandybuck"}, + {"May", "Gamgee"}, + {"Melilot", "Brandybuck"}, + {"Menegilda", "Brandybuck"}, + {"Mentha", "Brandybuck"}, + {"Meriadoc", "Brandybuck"}, + {"Merimac", "Brandybuck"}, + {"Merimas", "Brandybuck"}, + {"Merry", "Gardner"}, + {"Milo", "Burrows"}, + {"Mimosa", "Baggins"}, + {"Minto", "Burrows"}, + {"Mirabella", "Brandybuck"}, + {"Moro", "Burrows"}, + {"Mosco", "Burrows"}, + {"Mungo", "Baggins"}, + {"Myrtle", "Burrows"}, + {"Odo", "Proudfoot"}, + {"Odovacar", "Bolger"}, + {"Olo", "Proudfoot"}, + {"Orgulas", "Brandybuck"}, + {"Otho", "Sackville-Baggins"}, + {"Paladin", "Took"}, + {"Pansy", "Bolger"}, + {"Pearl", "Took"}, + {"Peony", "Burrows"}, + {"Peregrin", "Took"}, + {"Pervinca", "Took"}, + {"Pimpernel", "Took"}, + {"Pippin", "Gardner"}, + {"Polo", "Baggins"}, + {"Ponto", "Baggins"}, + {"Porto", "Baggins"}, + {"Posco", "Baggins"}, + {"Poppy", "Bolger"}, + {"Primrose", "Gardner"}, + {"Primula", "Baggins"}, + {"Prisca", "Bolger"}, + {"Reginard", "Took"}, + {"Robin", "Smallburrow"}, + {"Robin", "Gardner"}, + {"Rorimac", "Brandybuck"}, + {"Rosa", "Took"}, + {"Rosamunda", "Bolger"}, + {"Rose", "Gardner"}, + {"Ruby", "Baggins"}, + {"Ruby", "Gardner"}, + {"Rudigar", "Bolger"}, + {"Rufus", "Burrows"}, + {"Sadoc", "Brandybuck"}, + {"Salvia", "Bolger"}, + {"Samwise", "Gamgee"}, + {"Sancho", "Proudfoot"}, + {"Saradas", "Brandybuck"}, + {"Saradoc", "Brandybuck"}, + {"Seredic", "Brandybuck"}, + {"Sigismond", "Took"}, + {"Smeagol", "Gollum"}, + {"Tanta", "Baggins"}, + {"Ted", "Sandyman"}, + {"Tobold", "Hornblower"}, + {"Togo", "Goodbody"}, + {"Tolman", "Cotton"}, + {"Tolman", "Gardner"}, + {"Widow", "Rumble"}, + {"Wilcome", "Cotton"}, + {"Wilcome", "Cotton"}, + {"Wilibald", "Bolger"}, + {"Will", "Whitfoot"}, + {"Wiseman", "Gamwich"}}; + +const char *dragons[] = {"Ancalagon", "Glaurung", "Scatha", + "Smaug the Magnificent"}; + +static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, + const char *test_name, + grpc_channel_args *client_args, + grpc_channel_args *server_args) { + grpc_end2end_test_fixture f; + gpr_log(GPR_INFO, "%s/%s", test_name, config.name); + f = config.create_fixture(client_args, server_args); + config.init_client(&f, client_args); + config.init_server(&f, server_args); + return f; +} + +static gpr_timespec n_seconds_time(int n) { + return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); +} + +static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } + +static void drain_cq(grpc_completion_queue *cq) { + grpc_event ev; + do { + ev = grpc_completion_queue_next(cq, five_seconds_time(), NULL); + } while (ev.type != GRPC_QUEUE_SHUTDOWN); +} + +static void shutdown_server(grpc_end2end_test_fixture *f) { + if (!f->server) return; + grpc_server_shutdown_and_notify(f->server, f->cq, tag(1000)); + GPR_ASSERT(grpc_completion_queue_pluck(f->cq, tag(1000), + GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5), + NULL).type == GRPC_OP_COMPLETE); + grpc_server_destroy(f->server); + f->server = NULL; +} + +static void shutdown_client(grpc_end2end_test_fixture *f) { + if (!f->client) return; + grpc_channel_destroy(f->client); + f->client = NULL; +} + +static void end_test(grpc_end2end_test_fixture *f) { + shutdown_server(f); + shutdown_client(f); + + grpc_completion_queue_shutdown(f->cq); + drain_cq(f->cq); + grpc_completion_queue_destroy(f->cq); +} + +static void simple_request_body(grpc_end2end_test_fixture f, size_t index) { + grpc_call *c; + grpc_call *s; + gpr_timespec deadline = five_seconds_time(); + cq_verifier *cqv = cq_verifier_create(f.cq); + grpc_op ops[6]; + grpc_op *op; + grpc_metadata_array initial_metadata_recv; + grpc_metadata_array trailing_metadata_recv; + grpc_metadata_array request_metadata_recv; + grpc_call_details call_details; + grpc_status_code status; + grpc_call_error error; + grpc_metadata extra_metadata[3]; + char *details = NULL; + size_t details_capacity = 0; + int was_cancelled = 2; + + memset(extra_metadata, 0, sizeof(extra_metadata)); + extra_metadata[0].key = "hobbit-first-name"; + extra_metadata[0].value = hobbits[index % GPR_ARRAY_SIZE(hobbits)][0]; + extra_metadata[0].value_length = strlen(extra_metadata[0].value); + extra_metadata[1].key = "hobbit-second-name"; + extra_metadata[1].value = hobbits[index % GPR_ARRAY_SIZE(hobbits)][1]; + extra_metadata[1].value_length = strlen(extra_metadata[1].value); + extra_metadata[2].key = "dragon"; + extra_metadata[2].value = dragons[index % GPR_ARRAY_SIZE(dragons)]; + extra_metadata[2].value_length = strlen(extra_metadata[2].value); + + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr:1234", deadline, + NULL); + GPR_ASSERT(c); + + grpc_metadata_array_init(&initial_metadata_recv); + grpc_metadata_array_init(&trailing_metadata_recv); + grpc_metadata_array_init(&request_metadata_recv); + grpc_call_details_init(&call_details); + + op = ops; + op->op = GRPC_OP_SEND_INITIAL_METADATA; + op->data.send_initial_metadata.count = GPR_ARRAY_SIZE(extra_metadata); + op->data.send_initial_metadata.metadata = extra_metadata; + op->flags = 0; + op->reserved = NULL; + op++; + op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT; + op->flags = 0; + op->reserved = NULL; + op++; + op->op = GRPC_OP_RECV_INITIAL_METADATA; + op->data.recv_initial_metadata = &initial_metadata_recv; + op->flags = 0; + op->reserved = NULL; + op++; + op->op = GRPC_OP_RECV_STATUS_ON_CLIENT; + op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv; + op->data.recv_status_on_client.status = &status; + op->data.recv_status_on_client.status_details = &details; + op->data.recv_status_on_client.status_details_capacity = &details_capacity; + op->flags = 0; + op->reserved = NULL; + op++; + error = grpc_call_start_batch(c, ops, (size_t)(op - ops), tag(1), NULL); + GPR_ASSERT(GRPC_CALL_OK == error); + + error = + grpc_server_request_call(f.server, &s, &call_details, + &request_metadata_recv, f.cq, f.cq, tag(101)); + GPR_ASSERT(GRPC_CALL_OK == error); + cq_expect_completion(cqv, tag(101), 1); + cq_verify(cqv); + + op = ops; + op->op = GRPC_OP_SEND_INITIAL_METADATA; + op->data.send_initial_metadata.count = 0; + op->flags = 0; + op->reserved = NULL; + op++; + op->op = GRPC_OP_SEND_STATUS_FROM_SERVER; + op->data.send_status_from_server.trailing_metadata_count = 0; + op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED; + op->data.send_status_from_server.status_details = "xyz"; + op->flags = 0; + op->reserved = NULL; + 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++; + error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL); + GPR_ASSERT(GRPC_CALL_OK == error); + + cq_expect_completion(cqv, tag(102), 1); + cq_expect_completion(cqv, tag(1), 1); + cq_verify(cqv); + + GPR_ASSERT(status == GRPC_STATUS_UNIMPLEMENTED); + GPR_ASSERT(0 == strcmp(details, "xyz")); + GPR_ASSERT(0 == strcmp(call_details.method, "/foo")); + GPR_ASSERT(0 == strcmp(call_details.host, "foo.test.google.fr:1234")); + GPR_ASSERT(was_cancelled == 1); + + gpr_free(details); + grpc_metadata_array_destroy(&initial_metadata_recv); + grpc_metadata_array_destroy(&trailing_metadata_recv); + grpc_metadata_array_destroy(&request_metadata_recv); + grpc_call_details_destroy(&call_details); + + grpc_call_destroy(c); + grpc_call_destroy(s); + + cq_verifier_destroy(cqv); +} + +static void test_size(grpc_end2end_test_config config, int encode_size, + int decode_size) { + size_t i; + grpc_end2end_test_fixture f; + grpc_arg server_arg; + grpc_channel_args server_args; + grpc_arg client_arg; + grpc_channel_args client_args; + char *name; + + server_arg.type = GRPC_ARG_INTEGER; + server_arg.key = GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER; + server_arg.value.integer = decode_size; + server_args.num_args = 1; + server_args.args = &server_arg; + + client_arg.type = GRPC_ARG_INTEGER; + client_arg.key = GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER; + client_arg.value.integer = encode_size; + client_args.num_args = 1; + client_args.args = &client_arg; + + gpr_asprintf(&name, "test_size:e=%d:d=%d", encode_size, decode_size); + f = begin_test(config, name, encode_size != 4096 ? &client_args : NULL, + decode_size != 4096 ? &server_args : NULL); + for (i = 0; i < 4 * GPR_ARRAY_SIZE(hobbits); i++) { + simple_request_body(f, i); + } + end_test(&f); + config.tear_down_data(&f); + gpr_free(name); +} + +void grpc_end2end_tests(grpc_end2end_test_config config) { + static const int interesting_sizes[] = {4096, 0, 100, + 1000, 32768, 4 * 1024 * 1024}; + size_t i, j; + + for (i = 0; i < GPR_ARRAY_SIZE(interesting_sizes); i++) { + for (j = 0; j < GPR_ARRAY_SIZE(interesting_sizes); j++) { + test_size(config, interesting_sizes[i], interesting_sizes[j]); + } + } +} diff --git a/test/core/end2end/tests/max_message_length.c b/test/core/end2end/tests/max_message_length.c index 3dad47f37b..b3d8304d0b 100644 --- a/test/core/end2end/tests/max_message_length.c +++ b/test/core/end2end/tests/max_message_length.c @@ -109,6 +109,7 @@ static void test_max_message_length(grpc_end2end_test_config config) { gpr_slice request_payload_slice = gpr_slice_from_copied_string("hello world"); grpc_byte_buffer *request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1); + grpc_byte_buffer *recv_payload; grpc_metadata_array initial_metadata_recv; grpc_metadata_array trailing_metadata_recv; grpc_metadata_array request_metadata_recv; @@ -183,6 +184,11 @@ static void test_max_message_length(grpc_end2end_test_config config) { op->flags = 0; op->reserved = NULL; op++; + op->op = GRPC_OP_RECV_MESSAGE; + op->data.recv_message = &recv_payload; + op->flags = 0; + op->reserved = NULL; + op++; error = grpc_call_start_batch(s, ops, (size_t)(op - ops), tag(102), NULL); GPR_ASSERT(GRPC_CALL_OK == error); @@ -194,6 +200,7 @@ static void test_max_message_length(grpc_end2end_test_config config) { GPR_ASSERT(0 == strcmp(call_details.method, "/foo")); GPR_ASSERT(0 == strcmp(call_details.host, "foo.test.google.fr:1234")); GPR_ASSERT(was_cancelled == 1); + GPR_ASSERT(recv_payload == NULL); gpr_free(details); grpc_metadata_array_destroy(&initial_metadata_recv); diff --git a/test/core/end2end/tests/negative_deadline.c b/test/core/end2end/tests/negative_deadline.c new file mode 100644 index 0000000000..8fe9e7bcc5 --- /dev/null +++ b/test/core/end2end/tests/negative_deadline.c @@ -0,0 +1,181 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include "test/core/end2end/end2end_tests.h" + +#include <stdio.h> +#include <string.h> + +#include "src/core/support/string.h" +#include <grpc/byte_buffer.h> +#include <grpc/grpc.h> +#include <grpc/support/alloc.h> +#include <grpc/support/log.h> +#include <grpc/support/time.h> +#include <grpc/support/useful.h> +#include "test/core/end2end/cq_verifier.h" + +enum { TIMEOUT = 200000 }; + +static void *tag(gpr_intptr t) { return (void *)t; } + +static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config, + const char *test_name, + grpc_channel_args *client_args, + grpc_channel_args *server_args) { + grpc_end2end_test_fixture f; + gpr_log(GPR_INFO, "%s/%s", test_name, config.name); + f = config.create_fixture(client_args, server_args); + config.init_client(&f, client_args); + config.init_server(&f, server_args); + return f; +} + +static gpr_timespec n_seconds_time(int n) { + return GRPC_TIMEOUT_SECONDS_TO_DEADLINE(n); +} + +static gpr_timespec five_seconds_time(void) { return n_seconds_time(5); } + +static void drain_cq(grpc_completion_queue *cq) { + grpc_event ev; + do { + ev = grpc_completion_queue_next(cq, five_seconds_time(), NULL); + } while (ev.type != GRPC_QUEUE_SHUTDOWN); +} + +static void shutdown_server(grpc_end2end_test_fixture *f) { + if (!f->server) return; + grpc_server_shutdown_and_notify(f->server, f->cq, tag(1000)); + GPR_ASSERT(grpc_completion_queue_pluck(f->cq, tag(1000), + GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5), + NULL).type == GRPC_OP_COMPLETE); + grpc_server_destroy(f->server); + f->server = NULL; +} + +static void shutdown_client(grpc_end2end_test_fixture *f) { + if (!f->client) return; + grpc_channel_destroy(f->client); + f->client = NULL; +} + +static void end_test(grpc_end2end_test_fixture *f) { + shutdown_server(f); + shutdown_client(f); + + grpc_completion_queue_shutdown(f->cq); + drain_cq(f->cq); + grpc_completion_queue_destroy(f->cq); +} + +static void simple_request_body(grpc_end2end_test_fixture f, size_t num_ops) { + grpc_call *c; + gpr_timespec deadline = gpr_inf_past(GPR_CLOCK_REALTIME); + cq_verifier *cqv = cq_verifier_create(f.cq); + grpc_op ops[6]; + grpc_op *op; + grpc_metadata_array initial_metadata_recv; + grpc_metadata_array trailing_metadata_recv; + grpc_status_code status; + grpc_call_error error; + char *details = NULL; + size_t details_capacity = 0; + + gpr_log(GPR_DEBUG, "test with %d ops", num_ops); + + c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq, + "/foo", "foo.test.google.fr:1234", deadline, + NULL); + GPR_ASSERT(c); + + grpc_metadata_array_init(&initial_metadata_recv); + grpc_metadata_array_init(&trailing_metadata_recv); + + op = ops; + op->op = GRPC_OP_RECV_STATUS_ON_CLIENT; + op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv; + op->data.recv_status_on_client.status = &status; + op->data.recv_status_on_client.status_details = &details; + op->data.recv_status_on_client.status_details_capacity = &details_capacity; + op->flags = 0; + op->reserved = NULL; + op++; + op->op = GRPC_OP_RECV_INITIAL_METADATA; + op->data.recv_initial_metadata = &initial_metadata_recv; + op->flags = 0; + op->reserved = NULL; + op++; + op->op = GRPC_OP_SEND_INITIAL_METADATA; + op->data.send_initial_metadata.count = 0; + op->flags = 0; + op->reserved = NULL; + op++; + op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT; + op->flags = 0; + op->reserved = NULL; + op++; + GPR_ASSERT(num_ops <= (size_t)(op - ops)); + error = grpc_call_start_batch(c, ops, num_ops, tag(1), NULL); + GPR_ASSERT(GRPC_CALL_OK == error); + + cq_expect_completion(cqv, tag(1), 1); + cq_verify(cqv); + + GPR_ASSERT(status == GRPC_STATUS_DEADLINE_EXCEEDED); + + gpr_free(details); + grpc_metadata_array_destroy(&initial_metadata_recv); + grpc_metadata_array_destroy(&trailing_metadata_recv); + + grpc_call_destroy(c); + + cq_verifier_destroy(cqv); +} + +static void test_invoke_simple_request(grpc_end2end_test_config config, + size_t num_ops) { + grpc_end2end_test_fixture f; + + f = begin_test(config, "test_invoke_simple_request", NULL, NULL); + simple_request_body(f, num_ops); + end_test(&f); + config.tear_down_data(&f); +} + +void grpc_end2end_tests(grpc_end2end_test_config config) { + size_t i; + for (i = 1; i <= 4; i++) { + test_invoke_simple_request(config, i); + } +} diff --git a/test/core/end2end/tests/request_with_flags.c b/test/core/end2end/tests/request_with_flags.c index d7c4cff608..5ea845e0e5 100644 --- a/test/core/end2end/tests/request_with_flags.c +++ b/test/core/end2end/tests/request_with_flags.c @@ -41,7 +41,7 @@ #include <grpc/support/log.h> #include <grpc/support/time.h> #include <grpc/support/useful.h> -#include "src/core/transport/stream_op.h" +#include "src/core/transport/byte_stream.h" #include "test/core/end2end/cq_verifier.h" enum { TIMEOUT = 200000 }; diff --git a/test/core/fling/client.c b/test/core/fling/client.c index a53411c2f5..99b30d6c4a 100644 --- a/test/core/fling/client.c +++ b/test/core/fling/client.c @@ -41,6 +41,7 @@ #include <grpc/support/log.h> #include <grpc/support/time.h> #include <grpc/support/useful.h> +#include "src/core/profiling/timers.h" #include "test/core/util/grpc_profiler.h" #include "test/core/util/test_config.h" @@ -89,6 +90,7 @@ static void init_ping_pong_request(void) { } static void step_ping_pong_request(void) { + GPR_TIMER_BEGIN("ping_pong", 1); call = grpc_channel_create_call(channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq, "/Reflector/reflectUnary", "localhost", gpr_inf_future(GPR_CLOCK_REALTIME), NULL); @@ -99,6 +101,7 @@ static void step_ping_pong_request(void) { grpc_call_destroy(call); grpc_byte_buffer_destroy(response_payload_recv); call = NULL; + GPR_TIMER_END("ping_pong", 1); } static void init_ping_pong_stream(void) { @@ -122,10 +125,12 @@ static void init_ping_pong_stream(void) { static void step_ping_pong_stream(void) { grpc_call_error error; + GPR_TIMER_BEGIN("ping_pong", 1); error = grpc_call_start_batch(call, stream_step_ops, 2, (void *)1, NULL); GPR_ASSERT(GRPC_CALL_OK == error); grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL); grpc_byte_buffer_destroy(response_payload_recv); + GPR_TIMER_END("ping_pong", 1); } static double now(void) { @@ -159,12 +164,14 @@ int main(int argc, char **argv) { char *scenario_name = "ping-pong-request"; scenario sc = {NULL, NULL, NULL}; + gpr_timers_set_log_filename("latency_trace.fling_client.txt"); + + grpc_init(); + GPR_ASSERT(argc >= 1); fake_argv[0] = argv[0]; grpc_test_init(1, fake_argv); - grpc_init(); - cl = gpr_cmdline_create("fling client"); gpr_cmdline_add_int(cl, "payload_size", "Size of the payload to send", &payload_size); diff --git a/test/core/fling/server.c b/test/core/fling/server.c index 67631e5a07..14a1a815bc 100644 --- a/test/core/fling/server.c +++ b/test/core/fling/server.c @@ -44,15 +44,16 @@ #include <unistd.h> #endif -#include "test/core/util/grpc_profiler.h" -#include "test/core/util/test_config.h" #include <grpc/support/alloc.h> #include <grpc/support/cmdline.h> #include <grpc/support/host_port.h> #include <grpc/support/log.h> #include <grpc/support/time.h> +#include "src/core/profiling/timers.h" #include "test/core/util/port.h" #include "test/core/end2end/data/ssl_test_data.h" +#include "test/core/util/grpc_profiler.h" +#include "test/core/util/test_config.h" static grpc_completion_queue *cq; static grpc_server *server; @@ -192,6 +193,8 @@ int main(int argc, char **argv) { char *fake_argv[1]; + gpr_timers_set_log_filename("latency_trace.fling_server.txt"); + GPR_ASSERT(argc >= 1); fake_argv[0] = argv[0]; grpc_test_init(1, fake_argv); diff --git a/test/core/iomgr/fd_posix_test.c b/test/core/iomgr/fd_posix_test.c index f592f63ba9..4be6957a83 100644 --- a/test/core/iomgr/fd_posix_test.c +++ b/test/core/iomgr/fd_posix_test.c @@ -121,7 +121,7 @@ static void session_shutdown_cb(grpc_exec_ctx *exec_ctx, void *arg, /*session */ int success) { session *se = arg; server *sv = se->sv; - grpc_fd_orphan(exec_ctx, se->em_fd, NULL, "a"); + grpc_fd_orphan(exec_ctx, se->em_fd, NULL, NULL, "a"); gpr_free(se); /* Start to shutdown listen fd. */ grpc_fd_shutdown(exec_ctx, sv->em_fd); @@ -177,7 +177,7 @@ static void listen_shutdown_cb(grpc_exec_ctx *exec_ctx, void *arg /*server */, int success) { server *sv = arg; - grpc_fd_orphan(exec_ctx, sv->em_fd, NULL, "b"); + grpc_fd_orphan(exec_ctx, sv->em_fd, NULL, NULL, "b"); gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset)); sv->done = 1; @@ -294,7 +294,7 @@ static void client_init(client *cl) { 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, "c"); + grpc_fd_orphan(exec_ctx, cl->em_fd, NULL, NULL, "c"); cl->done = 1; grpc_pollset_kick(&g_pollset, NULL); } @@ -503,7 +503,7 @@ static void test_grpc_fd_change(void) { GPR_ASSERT(b.cb_that_ran == second_read_callback); gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset)); - grpc_fd_orphan(&exec_ctx, em_fd, NULL, "d"); + grpc_fd_orphan(&exec_ctx, em_fd, NULL, NULL, "d"); grpc_exec_ctx_finish(&exec_ctx); destroy_change_data(&a); destroy_change_data(&b); diff --git a/test/core/iomgr/tcp_posix_test.c b/test/core/iomgr/tcp_posix_test.c index f676454b7f..9feac931a3 100644 --- a/test/core/iomgr/tcp_posix_test.c +++ b/test/core/iomgr/tcp_posix_test.c @@ -383,6 +383,76 @@ 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, int success) { + int *done = arg; + *done = 1; + grpc_pollset_kick(&g_pollset, NULL); +} + +/* Do a read_test, then release fd and try to read/write again. */ +static void release_fd_test(size_t num_bytes, size_t slice_size) { + int sv[2]; + grpc_endpoint *ep; + struct read_socket_state state; + size_t written_bytes; + int fd; + gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20); + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + grpc_closure fd_released_cb; + int fd_released_done = 0; + grpc_closure_init(&fd_released_cb, &on_fd_released, &fd_released_done); + + gpr_log(GPR_INFO, "Release fd read_test of size %d, slice size %d", num_bytes, + slice_size); + + create_sockets(sv); + + ep = grpc_tcp_create(grpc_fd_create(sv[1], "read_test"), slice_size, "test"); + grpc_endpoint_add_to_pollset(&exec_ctx, ep, &g_pollset); + + written_bytes = fill_socket_partial(sv[0], num_bytes); + gpr_log(GPR_INFO, "Wrote %d bytes", written_bytes); + + state.ep = ep; + state.read_bytes = 0; + state.target_read_bytes = written_bytes; + gpr_slice_buffer_init(&state.incoming); + grpc_closure_init(&state.read_cb, read_cb, &state); + + grpc_endpoint_read(&exec_ctx, ep, &state.incoming, &state.read_cb); + + gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset)); + while (state.read_bytes < state.target_read_bytes) { + grpc_pollset_worker worker; + grpc_pollset_work(&exec_ctx, &g_pollset, &worker, + gpr_now(GPR_CLOCK_MONOTONIC), deadline); + gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset)); + grpc_exec_ctx_finish(&exec_ctx); + gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset)); + } + GPR_ASSERT(state.read_bytes == state.target_read_bytes); + gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset)); + + gpr_slice_buffer_destroy(&state.incoming); + grpc_tcp_destroy_and_release_fd(&exec_ctx, ep, &fd, &fd_released_cb); + gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset)); + while (!fd_released_done) { + grpc_pollset_worker worker; + grpc_pollset_work(&exec_ctx, &g_pollset, &worker, + gpr_now(GPR_CLOCK_MONOTONIC), deadline); + } + gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset)); + GPR_ASSERT(fd_released_done == 1); + GPR_ASSERT(fd == sv[1]); + grpc_exec_ctx_finish(&exec_ctx); + + written_bytes = fill_socket_partial(sv[0], num_bytes); + drain_socket_blocking(fd, written_bytes, written_bytes); + written_bytes = fill_socket_partial(fd, num_bytes); + drain_socket_blocking(sv[0], written_bytes, written_bytes); + close(fd); +} + void run_tests(void) { size_t i = 0; @@ -402,6 +472,8 @@ void run_tests(void) { for (i = 1; i < 1000; i = GPR_MAX(i + 1, i * 5 / 4)) { write_test(40320, i); } + + release_fd_test(100, 8192); } static void clean_up(void) {} diff --git a/test/core/network_benchmarks/low_level_ping_pong.c b/test/core/network_benchmarks/low_level_ping_pong.c index 0ce4bd4b25..dd1544c27b 100644 --- a/test/core/network_benchmarks/low_level_ping_pong.c +++ b/test/core/network_benchmarks/low_level_ping_pong.c @@ -82,7 +82,7 @@ typedef struct thread_args { /* Basic call to read() */ static int read_bytes(int fd, char *buf, size_t read_size, int spin) { size_t bytes_read = 0; - int err; + ssize_t err; do { err = read(fd, buf + bytes_read, read_size - bytes_read); if (err < 0) { @@ -96,7 +96,7 @@ static int read_bytes(int fd, char *buf, size_t read_size, int spin) { return -1; } } else { - bytes_read += err; + bytes_read += (size_t)err; } } while (bytes_read < read_size); return 0; @@ -115,6 +115,7 @@ static int poll_read_bytes(int fd, char *buf, size_t read_size, int spin) { struct pollfd pfd; size_t bytes_read = 0; int err; + ssize_t err2; pfd.fd = fd; pfd.events = POLLIN; @@ -132,13 +133,13 @@ static int poll_read_bytes(int fd, char *buf, size_t read_size, int spin) { GPR_ASSERT(err == 1); GPR_ASSERT(pfd.revents == POLLIN); do { - err = read(fd, buf + bytes_read, read_size - bytes_read); - } while (err < 0 && errno == EINTR); - if (err < 0 && errno != EAGAIN) { + err2 = read(fd, buf + bytes_read, read_size - bytes_read); + } while (err2 < 0 && errno == EINTR); + if (err2 < 0 && errno != EAGAIN) { gpr_log(GPR_ERROR, "Read failed: %s", strerror(errno)); return -1; } - bytes_read += err; + bytes_read += (size_t)err2; } while (bytes_read < read_size); return 0; } @@ -157,6 +158,7 @@ static int epoll_read_bytes(struct thread_args *args, char *buf, int spin) { struct epoll_event ev; size_t bytes_read = 0; int err; + ssize_t err2; size_t read_size = args->msg_size; do { @@ -172,10 +174,11 @@ static int epoll_read_bytes(struct thread_args *args, char *buf, int spin) { GPR_ASSERT(ev.data.fd == args->fds.read_fd); do { do { - err = read(args->fds.read_fd, buf + bytes_read, read_size - bytes_read); - } while (err < 0 && errno == EINTR); + err2 = + read(args->fds.read_fd, buf + bytes_read, read_size - bytes_read); + } while (err2 < 0 && errno == EINTR); if (errno == EAGAIN) break; - bytes_read += err; + bytes_read += (size_t)err2; /* TODO(klempner): This should really be doing an extra call after we are done to ensure we see an EAGAIN */ } while (bytes_read < read_size); @@ -199,7 +202,7 @@ static int epoll_read_bytes_spin(struct thread_args *args, char *buf) { */ static int blocking_write_bytes(struct thread_args *args, char *buf) { size_t bytes_written = 0; - int err; + ssize_t err; size_t write_size = args->msg_size; do { err = write(args->fds.write_fd, buf + bytes_written, @@ -212,7 +215,7 @@ static int blocking_write_bytes(struct thread_args *args, char *buf) { return -1; } } else { - bytes_written += err; + bytes_written += (size_t)err; } } while (bytes_written < write_size); return 0; @@ -297,7 +300,7 @@ static void print_histogram(gpr_histogram *histogram) { static double now(void) { gpr_timespec tv = gpr_now(GPR_CLOCK_REALTIME); - return 1e9 * tv.tv_sec + tv.tv_nsec; + return 1e9 * (double)tv.tv_sec + (double)tv.tv_nsec; } static void client_thread(thread_args *args) { @@ -373,7 +376,7 @@ error: return -1; } -static int connect_client(struct sockaddr *addr, int len) { +static int connect_client(struct sockaddr *addr, socklen_t len) { int fd = socket(addr->sa_family, SOCK_STREAM, 0); int err; if (fd < 0) { @@ -586,27 +589,27 @@ static int run_benchmark(char *socket_type, thread_args *client_args, return 0; } -static int run_all_benchmarks(int msg_size) { +static int run_all_benchmarks(size_t msg_size) { int error = 0; size_t i; for (i = 0; i < GPR_ARRAY_SIZE(test_strategies); ++i) { - test_strategy *test_strategy = &test_strategies[i]; + test_strategy *strategy = &test_strategies[i]; size_t j; for (j = 0; j < GPR_ARRAY_SIZE(socket_types); ++j) { thread_args *client_args = malloc(sizeof(thread_args)); thread_args *server_args = malloc(sizeof(thread_args)); char *socket_type = socket_types[j]; - client_args->read_bytes = test_strategy->read_strategy; + client_args->read_bytes = strategy->read_strategy; client_args->write_bytes = blocking_write_bytes; - client_args->setup = test_strategy->setup; + client_args->setup = strategy->setup; client_args->msg_size = msg_size; - client_args->strategy_name = test_strategy->name; - server_args->read_bytes = test_strategy->read_strategy; + client_args->strategy_name = strategy->name; + server_args->read_bytes = strategy->read_strategy; server_args->write_bytes = blocking_write_bytes; - server_args->setup = test_strategy->setup; + server_args->setup = strategy->setup; server_args->msg_size = msg_size; - server_args->strategy_name = test_strategy->name; + server_args->strategy_name = strategy->name; error = run_benchmark(socket_type, client_args, server_args); if (error < 0) { return error; @@ -623,7 +626,7 @@ int main(int argc, char **argv) { char *read_strategy = NULL; char *socket_type = NULL; size_t i; - const test_strategy *test_strategy = NULL; + const test_strategy *strategy = NULL; int error = 0; gpr_cmdline *cmdline = @@ -643,7 +646,7 @@ int main(int argc, char **argv) { if (read_strategy == NULL) { gpr_log(GPR_INFO, "No strategy specified, running all benchmarks"); - return run_all_benchmarks(msg_size); + return run_all_benchmarks((size_t)msg_size); } if (socket_type == NULL) { @@ -657,23 +660,23 @@ int main(int argc, char **argv) { for (i = 0; i < GPR_ARRAY_SIZE(test_strategies); ++i) { if (strcmp(test_strategies[i].name, read_strategy) == 0) { - test_strategy = &test_strategies[i]; + strategy = &test_strategies[i]; } } - if (test_strategy == NULL) { + if (strategy == NULL) { fprintf(stderr, "Invalid read strategy %s\n", read_strategy); return -1; } - client_args->read_bytes = test_strategy->read_strategy; + client_args->read_bytes = strategy->read_strategy; client_args->write_bytes = blocking_write_bytes; - client_args->setup = test_strategy->setup; - client_args->msg_size = msg_size; + client_args->setup = strategy->setup; + client_args->msg_size = (size_t)msg_size; client_args->strategy_name = read_strategy; - server_args->read_bytes = test_strategy->read_strategy; + server_args->read_bytes = strategy->read_strategy; server_args->write_bytes = blocking_write_bytes; - server_args->setup = test_strategy->setup; - server_args->msg_size = msg_size; + server_args->setup = strategy->setup; + server_args->msg_size = (size_t)msg_size; server_args->strategy_name = read_strategy; error = run_benchmark(socket_type, client_args, server_args); diff --git a/test/core/security/credentials_test.c b/test/core/security/credentials_test.c index 5c1e0f4b94..b2b7cfdb6e 100644 --- a/test/core/security/credentials_test.c +++ b/test/core/security/credentials_test.c @@ -50,11 +50,24 @@ #include <openssl/rsa.h> +/* -- Mock channel credentials. -- */ + +static grpc_channel_credentials *grpc_mock_channel_credentials_create( + const grpc_channel_credentials_vtable *vtable) { + grpc_channel_credentials *c = gpr_malloc(sizeof(*c)); + memset(c, 0, sizeof(*c)); + c->type = "mock"; + c->vtable = vtable; + gpr_ref_init(&c->refcount, 1); + return c; +} + +/* -- Constants. -- */ + static const char test_google_iam_authorization_token[] = "blahblahblhahb"; static const char test_google_iam_authority_selector[] = "respectmyauthoritah"; static const char test_oauth2_bearer_token[] = "Bearer blaaslkdjfaslkdfasdsfasf"; -static const char test_root_cert[] = "I am the root!"; /* This JSON key was generated with the GCE console and revoked immediately. The identifiers have been changed as well. @@ -113,6 +126,10 @@ static const char test_signed_jwt[] = static const char test_service_url[] = "https://foo.com/foo.v1"; static const char other_test_service_url[] = "https://bar.com/bar.v1"; +static const char test_method[] = "ThisIsNotAMethod"; + +/* -- Utils. -- */ + static char *test_json_key_str(void) { size_t result_len = strlen(test_json_key_str_part1) + strlen(test_json_key_str_part2) + @@ -141,6 +158,8 @@ static grpc_httpcli_response http_response(int status, const char *body) { return response; } +/* -- Tests. -- */ + static void test_empty_md_store(void) { grpc_credentials_md_store *store = grpc_credentials_md_store_create(0); GPR_ASSERT(store->num_entries == 0); @@ -219,7 +238,7 @@ static void test_oauth2_token_fetcher_creds_parsing_ok(void) { GPR_ASSERT(token_lifetime.tv_sec == 3599); GPR_ASSERT(token_lifetime.tv_nsec == 0); GPR_ASSERT(token_md->num_entries == 1); - GPR_ASSERT(gpr_slice_str_cmp(token_md->entries[0].key, "Authorization") == 0); + GPR_ASSERT(gpr_slice_str_cmp(token_md->entries[0].key, "authorization") == 0); GPR_ASSERT(gpr_slice_str_cmp(token_md->entries[0].value, "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_") == 0); @@ -319,7 +338,7 @@ static void check_google_iam_metadata(grpc_exec_ctx *exec_ctx, void *user_data, grpc_credentials_md *md_elems, size_t num_md, grpc_credentials_status status) { - grpc_credentials *c = (grpc_credentials *)user_data; + grpc_call_credentials *c = (grpc_call_credentials *)user_data; expected_md emd[] = {{GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY, test_google_iam_authorization_token}, {GRPC_IAM_AUTHORITY_SELECTOR_METADATA_KEY, @@ -327,19 +346,18 @@ static void check_google_iam_metadata(grpc_exec_ctx *exec_ctx, void *user_data, GPR_ASSERT(status == GRPC_CREDENTIALS_OK); GPR_ASSERT(num_md == 2); check_metadata(emd, md_elems, num_md); - grpc_credentials_unref(c); + grpc_call_credentials_unref(c); } static void test_google_iam_creds(void) { grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_credentials *creds = grpc_google_iam_credentials_create( + grpc_call_credentials *creds = grpc_google_iam_credentials_create( test_google_iam_authorization_token, test_google_iam_authority_selector, NULL); - GPR_ASSERT(grpc_credentials_has_request_metadata(creds)); - GPR_ASSERT(grpc_credentials_has_request_metadata_only(creds)); - grpc_credentials_get_request_metadata(&exec_ctx, creds, NULL, - test_service_url, - check_google_iam_metadata, creds); + grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL, + NULL}; + grpc_call_credentials_get_request_metadata( + &exec_ctx, creds, NULL, auth_md_ctx, check_google_iam_metadata, creds); grpc_exec_ctx_finish(&exec_ctx); } @@ -348,81 +366,59 @@ static void check_access_token_metadata(grpc_exec_ctx *exec_ctx, grpc_credentials_md *md_elems, size_t num_md, grpc_credentials_status status) { - grpc_credentials *c = (grpc_credentials *)user_data; + grpc_call_credentials *c = (grpc_call_credentials *)user_data; expected_md emd[] = {{GRPC_AUTHORIZATION_METADATA_KEY, "Bearer blah"}}; GPR_ASSERT(status == GRPC_CREDENTIALS_OK); GPR_ASSERT(num_md == 1); check_metadata(emd, md_elems, num_md); - grpc_credentials_unref(c); + grpc_call_credentials_unref(c); } static void test_access_token_creds(void) { grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_credentials *creds = grpc_access_token_credentials_create("blah", NULL); - GPR_ASSERT(grpc_credentials_has_request_metadata(creds)); - GPR_ASSERT(grpc_credentials_has_request_metadata_only(creds)); - GPR_ASSERT(strcmp(creds->type, GRPC_CREDENTIALS_TYPE_OAUTH2) == 0); - grpc_credentials_get_request_metadata(&exec_ctx, creds, NULL, - test_service_url, - check_access_token_metadata, creds); + grpc_call_credentials *creds = + grpc_access_token_credentials_create("blah", NULL); + grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL, + NULL}; + GPR_ASSERT(strcmp(creds->type, GRPC_CALL_CREDENTIALS_TYPE_OAUTH2) == 0); + grpc_call_credentials_get_request_metadata( + &exec_ctx, creds, NULL, auth_md_ctx, check_access_token_metadata, creds); grpc_exec_ctx_finish(&exec_ctx); } -static void check_ssl_oauth2_composite_metadata( - grpc_exec_ctx *exec_ctx, void *user_data, grpc_credentials_md *md_elems, - size_t num_md, grpc_credentials_status status) { - grpc_credentials *c = (grpc_credentials *)user_data; - expected_md emd[] = { - {GRPC_AUTHORIZATION_METADATA_KEY, test_oauth2_bearer_token}}; - GPR_ASSERT(status == GRPC_CREDENTIALS_OK); - GPR_ASSERT(num_md == 1); - check_metadata(emd, md_elems, num_md); - grpc_credentials_unref(c); +static grpc_security_status check_channel_oauth2_create_security_connector( + grpc_channel_credentials *c, grpc_call_credentials *call_creds, + const char *target, const grpc_channel_args *args, + grpc_channel_security_connector **sc, grpc_channel_args **new_args) { + GPR_ASSERT(strcmp(c->type, "mock") == 0); + GPR_ASSERT(call_creds != NULL); + GPR_ASSERT(strcmp(call_creds->type, GRPC_CALL_CREDENTIALS_TYPE_OAUTH2) == 0); + return GRPC_SECURITY_OK; } -static void test_ssl_oauth2_composite_creds(void) { - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_credentials *ssl_creds = - grpc_ssl_credentials_create(test_root_cert, NULL, NULL); - const grpc_credentials_array *creds_array; - grpc_credentials *oauth2_creds = grpc_md_only_test_credentials_create( - "Authorization", test_oauth2_bearer_token, 0); - grpc_credentials *composite_creds = - grpc_composite_credentials_create(ssl_creds, oauth2_creds, NULL); - grpc_credentials_unref(ssl_creds); - grpc_credentials_unref(oauth2_creds); - GPR_ASSERT(strcmp(composite_creds->type, GRPC_CREDENTIALS_TYPE_COMPOSITE) == - 0); - GPR_ASSERT(grpc_credentials_has_request_metadata(composite_creds)); - GPR_ASSERT(!grpc_credentials_has_request_metadata_only(composite_creds)); - creds_array = grpc_composite_credentials_get_credentials(composite_creds); - GPR_ASSERT(creds_array->num_creds == 2); - GPR_ASSERT(strcmp(creds_array->creds_array[0]->type, - GRPC_CREDENTIALS_TYPE_SSL) == 0); - GPR_ASSERT(strcmp(creds_array->creds_array[1]->type, - GRPC_CREDENTIALS_TYPE_OAUTH2) == 0); - grpc_credentials_get_request_metadata( - &exec_ctx, composite_creds, NULL, test_service_url, - check_ssl_oauth2_composite_metadata, composite_creds); - grpc_exec_ctx_finish(&exec_ctx); +static void test_channel_oauth2_composite_creds(void) { + grpc_channel_args *new_args; + grpc_channel_credentials_vtable vtable = { + NULL, check_channel_oauth2_create_security_connector}; + grpc_channel_credentials *channel_creds = + grpc_mock_channel_credentials_create(&vtable); + grpc_call_credentials *oauth2_creds = + grpc_access_token_credentials_create("blah", NULL); + grpc_channel_credentials *channel_oauth2_creds = + grpc_composite_channel_credentials_create(channel_creds, oauth2_creds, + NULL); + grpc_channel_credentials_release(channel_creds); + grpc_call_credentials_release(oauth2_creds); + GPR_ASSERT(grpc_channel_credentials_create_security_connector( + channel_oauth2_creds, NULL, NULL, NULL, &new_args) == + GRPC_SECURITY_OK); + grpc_channel_credentials_release(channel_oauth2_creds); } -void test_ssl_fake_transport_security_composite_creds_failure(void) { - grpc_credentials *ssl_creds = grpc_ssl_credentials_create(NULL, NULL, NULL); - grpc_credentials *fake_transport_security_creds = - grpc_fake_transport_security_credentials_create(); - - /* 2 connector credentials: should not work. */ - GPR_ASSERT(grpc_composite_credentials_create( - ssl_creds, fake_transport_security_creds, NULL) == NULL); - grpc_credentials_unref(ssl_creds); - grpc_credentials_unref(fake_transport_security_creds); -} - -static void check_ssl_oauth2_google_iam_composite_metadata( +static void check_oauth2_google_iam_composite_metadata( grpc_exec_ctx *exec_ctx, void *user_data, grpc_credentials_md *md_elems, size_t num_md, grpc_credentials_status status) { - grpc_credentials *c = (grpc_credentials *)user_data; + grpc_call_credentials *c = (grpc_call_credentials *)user_data; expected_md emd[] = { {GRPC_AUTHORIZATION_METADATA_KEY, test_oauth2_bearer_token}, {GRPC_IAM_AUTHORIZATION_TOKEN_METADATA_KEY, @@ -432,51 +428,92 @@ static void check_ssl_oauth2_google_iam_composite_metadata( GPR_ASSERT(status == GRPC_CREDENTIALS_OK); GPR_ASSERT(num_md == 3); check_metadata(emd, md_elems, num_md); - grpc_credentials_unref(c); + grpc_call_credentials_unref(c); } -static void test_ssl_oauth2_google_iam_composite_creds(void) { +static void test_oauth2_google_iam_composite_creds(void) { grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_credentials *ssl_creds = - grpc_ssl_credentials_create(test_root_cert, NULL, NULL); - const grpc_credentials_array *creds_array; - grpc_credentials *oauth2_creds = grpc_md_only_test_credentials_create( - "Authorization", test_oauth2_bearer_token, 0); - grpc_credentials *aux_creds = - grpc_composite_credentials_create(ssl_creds, oauth2_creds, NULL); - grpc_credentials *google_iam_creds = grpc_google_iam_credentials_create( + const grpc_call_credentials_array *creds_array; + grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL, + NULL}; + grpc_call_credentials *oauth2_creds = grpc_md_only_test_credentials_create( + "authorization", test_oauth2_bearer_token, 0); + grpc_call_credentials *google_iam_creds = grpc_google_iam_credentials_create( test_google_iam_authorization_token, test_google_iam_authority_selector, NULL); - grpc_credentials *composite_creds = - grpc_composite_credentials_create(aux_creds, google_iam_creds, NULL); - grpc_credentials_unref(ssl_creds); - grpc_credentials_unref(oauth2_creds); - grpc_credentials_unref(aux_creds); - grpc_credentials_unref(google_iam_creds); - GPR_ASSERT(strcmp(composite_creds->type, GRPC_CREDENTIALS_TYPE_COMPOSITE) == - 0); - GPR_ASSERT(grpc_credentials_has_request_metadata(composite_creds)); - GPR_ASSERT(!grpc_credentials_has_request_metadata_only(composite_creds)); - creds_array = grpc_composite_credentials_get_credentials(composite_creds); - GPR_ASSERT(creds_array->num_creds == 3); + grpc_call_credentials *composite_creds = + grpc_composite_call_credentials_create(oauth2_creds, google_iam_creds, + NULL); + grpc_call_credentials_unref(oauth2_creds); + grpc_call_credentials_unref(google_iam_creds); + GPR_ASSERT( + strcmp(composite_creds->type, GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE) == 0); + creds_array = + grpc_composite_call_credentials_get_credentials(composite_creds); + GPR_ASSERT(creds_array->num_creds == 2); GPR_ASSERT(strcmp(creds_array->creds_array[0]->type, - GRPC_CREDENTIALS_TYPE_SSL) == 0); + GRPC_CALL_CREDENTIALS_TYPE_OAUTH2) == 0); GPR_ASSERT(strcmp(creds_array->creds_array[1]->type, - GRPC_CREDENTIALS_TYPE_OAUTH2) == 0); - GPR_ASSERT(strcmp(creds_array->creds_array[2]->type, - GRPC_CREDENTIALS_TYPE_IAM) == 0); - grpc_credentials_get_request_metadata( - &exec_ctx, composite_creds, NULL, test_service_url, - check_ssl_oauth2_google_iam_composite_metadata, composite_creds); + GRPC_CALL_CREDENTIALS_TYPE_IAM) == 0); + grpc_call_credentials_get_request_metadata( + &exec_ctx, composite_creds, NULL, auth_md_ctx, + check_oauth2_google_iam_composite_metadata, composite_creds); grpc_exec_ctx_finish(&exec_ctx); } +static grpc_security_status +check_channel_oauth2_google_iam_create_security_connector( + grpc_channel_credentials *c, grpc_call_credentials *call_creds, + const char *target, const grpc_channel_args *args, + grpc_channel_security_connector **sc, grpc_channel_args **new_args) { + const grpc_call_credentials_array *creds_array; + GPR_ASSERT(strcmp(c->type, "mock") == 0); + GPR_ASSERT(call_creds != NULL); + GPR_ASSERT(strcmp(call_creds->type, GRPC_CALL_CREDENTIALS_TYPE_COMPOSITE) == + 0); + creds_array = grpc_composite_call_credentials_get_credentials(call_creds); + GPR_ASSERT(strcmp(creds_array->creds_array[0]->type, + GRPC_CALL_CREDENTIALS_TYPE_OAUTH2) == 0); + GPR_ASSERT(strcmp(creds_array->creds_array[1]->type, + GRPC_CALL_CREDENTIALS_TYPE_IAM) == 0); + return GRPC_SECURITY_OK; +} + +static void test_channel_oauth2_google_iam_composite_creds(void) { + grpc_channel_args *new_args; + grpc_channel_credentials_vtable vtable = { + NULL, check_channel_oauth2_google_iam_create_security_connector}; + grpc_channel_credentials *channel_creds = + grpc_mock_channel_credentials_create(&vtable); + grpc_call_credentials *oauth2_creds = + grpc_access_token_credentials_create("blah", NULL); + grpc_channel_credentials *channel_oauth2_creds = + grpc_composite_channel_credentials_create(channel_creds, oauth2_creds, + NULL); + grpc_call_credentials *google_iam_creds = grpc_google_iam_credentials_create( + test_google_iam_authorization_token, test_google_iam_authority_selector, + NULL); + grpc_channel_credentials *channel_oauth2_iam_creds = + grpc_composite_channel_credentials_create(channel_oauth2_creds, + google_iam_creds, NULL); + grpc_channel_credentials_release(channel_creds); + grpc_call_credentials_release(oauth2_creds); + grpc_channel_credentials_release(channel_oauth2_creds); + grpc_call_credentials_release(google_iam_creds); + + GPR_ASSERT(grpc_channel_credentials_create_security_connector( + channel_oauth2_iam_creds, NULL, NULL, NULL, &new_args) == + GRPC_SECURITY_OK); + + grpc_channel_credentials_release(channel_oauth2_iam_creds); +} + static void on_oauth2_creds_get_metadata_success( grpc_exec_ctx *exec_ctx, void *user_data, grpc_credentials_md *md_elems, size_t num_md, grpc_credentials_status status) { GPR_ASSERT(status == GRPC_CREDENTIALS_OK); GPR_ASSERT(num_md == 1); - GPR_ASSERT(gpr_slice_str_cmp(md_elems[0].key, "Authorization") == 0); + GPR_ASSERT(gpr_slice_str_cmp(md_elems[0].key, "authorization") == 0); GPR_ASSERT(gpr_slice_str_cmp(md_elems[0].value, "Bearer ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_") == 0); @@ -545,43 +582,43 @@ static int httpcli_get_should_not_be_called( static void test_compute_engine_creds_success(void) { grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_credentials *compute_engine_creds = + grpc_call_credentials *compute_engine_creds = grpc_google_compute_engine_credentials_create(NULL); - GPR_ASSERT(grpc_credentials_has_request_metadata(compute_engine_creds)); - GPR_ASSERT(grpc_credentials_has_request_metadata_only(compute_engine_creds)); + grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL, + NULL}; /* First request: http get should be called. */ grpc_httpcli_set_override(compute_engine_httpcli_get_success_override, httpcli_post_should_not_be_called); - grpc_credentials_get_request_metadata( - &exec_ctx, compute_engine_creds, NULL, test_service_url, + grpc_call_credentials_get_request_metadata( + &exec_ctx, compute_engine_creds, NULL, auth_md_ctx, on_oauth2_creds_get_metadata_success, (void *)test_user_data); grpc_exec_ctx_flush(&exec_ctx); /* Second request: the cached token should be served directly. */ grpc_httpcli_set_override(httpcli_get_should_not_be_called, httpcli_post_should_not_be_called); - grpc_credentials_get_request_metadata( - &exec_ctx, compute_engine_creds, NULL, test_service_url, + grpc_call_credentials_get_request_metadata( + &exec_ctx, compute_engine_creds, NULL, auth_md_ctx, on_oauth2_creds_get_metadata_success, (void *)test_user_data); grpc_exec_ctx_finish(&exec_ctx); - grpc_credentials_unref(compute_engine_creds); + grpc_call_credentials_unref(compute_engine_creds); grpc_httpcli_set_override(NULL, NULL); } static void test_compute_engine_creds_failure(void) { grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_credentials *compute_engine_creds = + grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL, + NULL}; + grpc_call_credentials *compute_engine_creds = grpc_google_compute_engine_credentials_create(NULL); grpc_httpcli_set_override(compute_engine_httpcli_get_failure_override, httpcli_post_should_not_be_called); - GPR_ASSERT(grpc_credentials_has_request_metadata(compute_engine_creds)); - GPR_ASSERT(grpc_credentials_has_request_metadata_only(compute_engine_creds)); - grpc_credentials_get_request_metadata( - &exec_ctx, compute_engine_creds, NULL, test_service_url, + grpc_call_credentials_get_request_metadata( + &exec_ctx, compute_engine_creds, NULL, auth_md_ctx, on_oauth2_creds_get_metadata_failure, (void *)test_user_data); - grpc_credentials_unref(compute_engine_creds); + grpc_call_credentials_unref(compute_engine_creds); grpc_httpcli_set_override(NULL, NULL); grpc_exec_ctx_finish(&exec_ctx); } @@ -631,46 +668,46 @@ static int refresh_token_httpcli_post_failure( static void test_refresh_token_creds_success(void) { grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_credentials *refresh_token_creds = + grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL, + NULL}; + grpc_call_credentials *refresh_token_creds = grpc_google_refresh_token_credentials_create(test_refresh_token_str, NULL); - GPR_ASSERT(grpc_credentials_has_request_metadata(refresh_token_creds)); - GPR_ASSERT(grpc_credentials_has_request_metadata_only(refresh_token_creds)); /* First request: http get should be called. */ grpc_httpcli_set_override(httpcli_get_should_not_be_called, refresh_token_httpcli_post_success); - grpc_credentials_get_request_metadata( - &exec_ctx, refresh_token_creds, NULL, test_service_url, + grpc_call_credentials_get_request_metadata( + &exec_ctx, refresh_token_creds, NULL, auth_md_ctx, on_oauth2_creds_get_metadata_success, (void *)test_user_data); grpc_exec_ctx_flush(&exec_ctx); /* Second request: the cached token should be served directly. */ grpc_httpcli_set_override(httpcli_get_should_not_be_called, httpcli_post_should_not_be_called); - grpc_credentials_get_request_metadata( - &exec_ctx, refresh_token_creds, NULL, test_service_url, + grpc_call_credentials_get_request_metadata( + &exec_ctx, refresh_token_creds, NULL, auth_md_ctx, on_oauth2_creds_get_metadata_success, (void *)test_user_data); grpc_exec_ctx_flush(&exec_ctx); - grpc_credentials_unref(refresh_token_creds); + grpc_call_credentials_unref(refresh_token_creds); grpc_httpcli_set_override(NULL, NULL); grpc_exec_ctx_finish(&exec_ctx); } static void test_refresh_token_creds_failure(void) { grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_credentials *refresh_token_creds = + grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL, + NULL}; + grpc_call_credentials *refresh_token_creds = grpc_google_refresh_token_credentials_create(test_refresh_token_str, NULL); grpc_httpcli_set_override(httpcli_get_should_not_be_called, refresh_token_httpcli_post_failure); - GPR_ASSERT(grpc_credentials_has_request_metadata(refresh_token_creds)); - GPR_ASSERT(grpc_credentials_has_request_metadata_only(refresh_token_creds)); - grpc_credentials_get_request_metadata( - &exec_ctx, refresh_token_creds, NULL, test_service_url, + grpc_call_credentials_get_request_metadata( + &exec_ctx, refresh_token_creds, NULL, auth_md_ctx, on_oauth2_creds_get_metadata_failure, (void *)test_user_data); - grpc_credentials_unref(refresh_token_creds); + grpc_call_credentials_unref(refresh_token_creds); grpc_httpcli_set_override(NULL, NULL); grpc_exec_ctx_finish(&exec_ctx); } @@ -730,7 +767,7 @@ static void on_jwt_creds_get_metadata_success(grpc_exec_ctx *exec_ctx, gpr_asprintf(&expected_md_value, "Bearer %s", test_signed_jwt); GPR_ASSERT(status == GRPC_CREDENTIALS_OK); GPR_ASSERT(num_md == 1); - GPR_ASSERT(gpr_slice_str_cmp(md_elems[0].key, "Authorization") == 0); + GPR_ASSERT(gpr_slice_str_cmp(md_elems[0].key, "authorization") == 0); GPR_ASSERT(gpr_slice_str_cmp(md_elems[0].value, expected_md_value) == 0); GPR_ASSERT(user_data != NULL); GPR_ASSERT(strcmp((const char *)user_data, test_user_data) == 0); @@ -751,56 +788,57 @@ static void on_jwt_creds_get_metadata_failure(grpc_exec_ctx *exec_ctx, static void test_jwt_creds_success(void) { char *json_key_string = test_json_key_str(); grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_credentials *jwt_creds = + grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL, + NULL}; + grpc_call_credentials *jwt_creds = grpc_service_account_jwt_access_credentials_create( json_key_string, grpc_max_auth_token_lifetime, NULL); - GPR_ASSERT(grpc_credentials_has_request_metadata(jwt_creds)); - GPR_ASSERT(grpc_credentials_has_request_metadata_only(jwt_creds)); /* First request: jwt_encode_and_sign should be called. */ grpc_jwt_encode_and_sign_set_override(encode_and_sign_jwt_success); - grpc_credentials_get_request_metadata( - &exec_ctx, jwt_creds, NULL, test_service_url, + grpc_call_credentials_get_request_metadata( + &exec_ctx, jwt_creds, NULL, auth_md_ctx, on_jwt_creds_get_metadata_success, (void *)test_user_data); grpc_exec_ctx_flush(&exec_ctx); /* Second request: the cached token should be served directly. */ grpc_jwt_encode_and_sign_set_override( encode_and_sign_jwt_should_not_be_called); - grpc_credentials_get_request_metadata( - &exec_ctx, jwt_creds, NULL, test_service_url, + grpc_call_credentials_get_request_metadata( + &exec_ctx, jwt_creds, NULL, auth_md_ctx, on_jwt_creds_get_metadata_success, (void *)test_user_data); grpc_exec_ctx_flush(&exec_ctx); /* Third request: Different service url so jwt_encode_and_sign should be called again (no caching). */ + auth_md_ctx.service_url = other_test_service_url; grpc_jwt_encode_and_sign_set_override(encode_and_sign_jwt_success); - grpc_credentials_get_request_metadata( - &exec_ctx, jwt_creds, NULL, other_test_service_url, + grpc_call_credentials_get_request_metadata( + &exec_ctx, jwt_creds, NULL, auth_md_ctx, on_jwt_creds_get_metadata_success, (void *)test_user_data); grpc_exec_ctx_flush(&exec_ctx); gpr_free(json_key_string); - grpc_credentials_unref(jwt_creds); + grpc_call_credentials_unref(jwt_creds); grpc_jwt_encode_and_sign_set_override(NULL); } static void test_jwt_creds_signing_failure(void) { char *json_key_string = test_json_key_str(); grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_credentials *jwt_creds = + grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL, + NULL}; + grpc_call_credentials *jwt_creds = grpc_service_account_jwt_access_credentials_create( json_key_string, grpc_max_auth_token_lifetime, NULL); - GPR_ASSERT(grpc_credentials_has_request_metadata(jwt_creds)); - GPR_ASSERT(grpc_credentials_has_request_metadata_only(jwt_creds)); grpc_jwt_encode_and_sign_set_override(encode_and_sign_jwt_failure); - grpc_credentials_get_request_metadata( - &exec_ctx, jwt_creds, NULL, test_service_url, + grpc_call_credentials_get_request_metadata( + &exec_ctx, jwt_creds, NULL, auth_md_ctx, on_jwt_creds_get_metadata_failure, (void *)test_user_data); gpr_free(json_key_string); - grpc_credentials_unref(jwt_creds); + grpc_call_credentials_unref(jwt_creds); grpc_jwt_encode_and_sign_set_override(NULL); grpc_exec_ctx_finish(&exec_ctx); } @@ -818,52 +856,39 @@ static void set_google_default_creds_env_var_with_file_contents( gpr_free(creds_file_name); } -static grpc_credentials *composite_inner_creds(grpc_credentials *creds, - const char *inner_creds_type) { - size_t i; - grpc_composite_credentials *composite; - GPR_ASSERT(strcmp(creds->type, GRPC_CREDENTIALS_TYPE_COMPOSITE) == 0); - composite = (grpc_composite_credentials *)creds; - for (i = 0; i < composite->inner.num_creds; i++) { - grpc_credentials *c = composite->inner.creds_array[i]; - if (strcmp(c->type, inner_creds_type) == 0) return c; - } - GPR_ASSERT(0); /* Not found. */ -} - static void test_google_default_creds_auth_key(void) { grpc_service_account_jwt_access_credentials *jwt; - grpc_credentials *creds; + grpc_composite_channel_credentials *creds; char *json_key = test_json_key_str(); grpc_flush_cached_google_default_credentials(); set_google_default_creds_env_var_with_file_contents( "json_key_google_default_creds", json_key); gpr_free(json_key); - creds = grpc_google_default_credentials_create(); + creds = (grpc_composite_channel_credentials *) + grpc_google_default_credentials_create(); GPR_ASSERT(creds != NULL); - jwt = (grpc_service_account_jwt_access_credentials *)composite_inner_creds( - creds, GRPC_CREDENTIALS_TYPE_JWT); + jwt = (grpc_service_account_jwt_access_credentials *)creds->call_creds; GPR_ASSERT( strcmp(jwt->key.client_id, "777-abaslkan11hlb6nmim3bpspl31ud.apps.googleusercontent.com") == 0); - grpc_credentials_unref(creds); + grpc_channel_credentials_unref(&creds->base); gpr_setenv(GRPC_GOOGLE_CREDENTIALS_ENV_VAR, ""); /* Reset. */ } static void test_google_default_creds_access_token(void) { grpc_google_refresh_token_credentials *refresh; - grpc_credentials *creds; + grpc_composite_channel_credentials *creds; grpc_flush_cached_google_default_credentials(); set_google_default_creds_env_var_with_file_contents( "refresh_token_google_default_creds", test_refresh_token_str); - creds = grpc_google_default_credentials_create(); + creds = (grpc_composite_channel_credentials *) + grpc_google_default_credentials_create(); GPR_ASSERT(creds != NULL); - refresh = (grpc_google_refresh_token_credentials *)composite_inner_creds( - creds, GRPC_CREDENTIALS_TYPE_OAUTH2); + refresh = (grpc_google_refresh_token_credentials *)creds->call_creds; GPR_ASSERT(strcmp(refresh->refresh_token.client_id, "32555999999.apps.googleusercontent.com") == 0); - grpc_credentials_unref(creds); + grpc_channel_credentials_unref(&creds->base); gpr_setenv(GRPC_GOOGLE_CREDENTIALS_ENV_VAR, ""); /* Reset. */ } @@ -880,13 +905,17 @@ typedef struct { static const plugin_metadata plugin_md[] = {{"foo", "bar"}, {"hi", "there"}}; -static void plugin_get_metadata_success(void *state, const char *service_url, +static void plugin_get_metadata_success(void *state, + grpc_auth_metadata_context context, grpc_credentials_plugin_metadata_cb cb, void *user_data) { size_t i; grpc_metadata md[GPR_ARRAY_SIZE(plugin_md)]; plugin_state *s = (plugin_state *)state; - GPR_ASSERT(strcmp(service_url, test_service_url) == 0); + GPR_ASSERT(strcmp(context.service_url, test_service_url) == 0); + GPR_ASSERT(strcmp(context.method_name, test_method) == 0); + GPR_ASSERT(context.channel_auth_context == NULL); + GPR_ASSERT(context.reserved == NULL); *s = PLUGIN_GET_METADATA_CALLED_STATE; for (i = 0; i < GPR_ARRAY_SIZE(plugin_md); i++) { memset(&md[i], 0, sizeof(grpc_metadata)); @@ -897,11 +926,15 @@ static void plugin_get_metadata_success(void *state, const char *service_url, cb(user_data, md, GPR_ARRAY_SIZE(md), GRPC_STATUS_OK, NULL); } -static void plugin_get_metadata_failure(void *state, const char *service_url, +static void plugin_get_metadata_failure(void *state, + grpc_auth_metadata_context context, grpc_credentials_plugin_metadata_cb cb, void *user_data) { plugin_state *s = (plugin_state *)state; - GPR_ASSERT(strcmp(service_url, test_service_url) == 0); + GPR_ASSERT(strcmp(context.service_url, test_service_url) == 0); + GPR_ASSERT(strcmp(context.method_name, test_method) == 0); + GPR_ASSERT(context.channel_auth_context == NULL); + GPR_ASSERT(context.reserved == NULL); *s = PLUGIN_GET_METADATA_CALLED_STATE; cb(user_data, NULL, 0, GRPC_STATUS_UNAUTHENTICATED, "Could not get metadata for plugin."); @@ -935,10 +968,12 @@ static void plugin_destroy(void *state) { } static void test_metadata_plugin_success(void) { - grpc_credentials *creds; + grpc_call_credentials *creds; plugin_state state = PLUGIN_INITIAL_STATE; grpc_metadata_credentials_plugin plugin; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL, + NULL}; plugin.state = &state; plugin.get_metadata = plugin_get_metadata_success; @@ -946,20 +981,22 @@ static void test_metadata_plugin_success(void) { creds = grpc_metadata_credentials_create_from_plugin(plugin, NULL); GPR_ASSERT(state == PLUGIN_INITIAL_STATE); - grpc_credentials_get_request_metadata( - &exec_ctx, creds, NULL, test_service_url, - on_plugin_metadata_received_success, NULL); + grpc_call_credentials_get_request_metadata( + &exec_ctx, creds, NULL, auth_md_ctx, on_plugin_metadata_received_success, + NULL); GPR_ASSERT(state == PLUGIN_GET_METADATA_CALLED_STATE); - grpc_credentials_release(creds); + grpc_call_credentials_release(creds); GPR_ASSERT(state == PLUGIN_DESTROY_CALLED_STATE); grpc_exec_ctx_finish(&exec_ctx); } static void test_metadata_plugin_failure(void) { - grpc_credentials *creds; + grpc_call_credentials *creds; plugin_state state = PLUGIN_INITIAL_STATE; grpc_metadata_credentials_plugin plugin; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + grpc_auth_metadata_context auth_md_ctx = {test_service_url, test_method, NULL, + NULL}; plugin.state = &state; plugin.get_metadata = plugin_get_metadata_failure; @@ -967,11 +1004,11 @@ static void test_metadata_plugin_failure(void) { creds = grpc_metadata_credentials_create_from_plugin(plugin, NULL); GPR_ASSERT(state == PLUGIN_INITIAL_STATE); - grpc_credentials_get_request_metadata( - &exec_ctx, creds, NULL, test_service_url, - on_plugin_metadata_received_failure, NULL); + grpc_call_credentials_get_request_metadata( + &exec_ctx, creds, NULL, auth_md_ctx, on_plugin_metadata_received_failure, + NULL); GPR_ASSERT(state == PLUGIN_GET_METADATA_CALLED_STATE); - grpc_credentials_release(creds); + grpc_call_credentials_release(creds); GPR_ASSERT(state == PLUGIN_DESTROY_CALLED_STATE); grpc_exec_ctx_finish(&exec_ctx); } @@ -993,8 +1030,9 @@ int main(int argc, char **argv) { test_oauth2_token_fetcher_creds_parsing_missing_token_lifetime(); test_google_iam_creds(); test_access_token_creds(); - test_ssl_oauth2_composite_creds(); - test_ssl_oauth2_google_iam_composite_creds(); + test_channel_oauth2_composite_creds(); + test_oauth2_google_iam_composite_creds(); + test_channel_oauth2_google_iam_composite_creds(); test_compute_engine_creds_success(); test_compute_engine_creds_failure(); test_refresh_token_creds_success(); diff --git a/test/core/security/fetch_oauth2.c b/test/core/security/fetch_oauth2.c index 764d8da9b6..ee1178cbdd 100644 --- a/test/core/security/fetch_oauth2.c +++ b/test/core/security/fetch_oauth2.c @@ -46,7 +46,7 @@ #include "src/core/support/file.h" #include "test/core/security/oauth2_utils.h" -static grpc_credentials *create_refresh_token_creds( +static grpc_call_credentials *create_refresh_token_creds( const char *json_refresh_token_file_path) { int success; gpr_slice refresh_token = @@ -60,7 +60,7 @@ static grpc_credentials *create_refresh_token_creds( } int main(int argc, char **argv) { - grpc_credentials *creds = NULL; + grpc_call_credentials *creds = NULL; char *json_key_file_path = NULL; char *json_refresh_token_file_path = NULL; char *token = NULL; @@ -115,7 +115,7 @@ int main(int argc, char **argv) { printf("Got token: %s.\n", token); gpr_free(token); } - grpc_credentials_release(creds); + grpc_call_credentials_release(creds); gpr_cmdline_destroy(cl); grpc_shutdown(); return 0; diff --git a/test/core/security/oauth2_utils.c b/test/core/security/oauth2_utils.c index f99d170592..fb62bf4134 100644 --- a/test/core/security/oauth2_utils.c +++ b/test/core/security/oauth2_utils.c @@ -75,17 +75,21 @@ static void on_oauth2_response(grpc_exec_ctx *exec_ctx, void *user_data, static void do_nothing(grpc_exec_ctx *exec_ctx, void *unused, int success) {} -char *grpc_test_fetch_oauth2_token_with_credentials(grpc_credentials *creds) { +char *grpc_test_fetch_oauth2_token_with_credentials( + grpc_call_credentials *creds) { oauth2_request request; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; grpc_closure do_nothing_closure; + grpc_auth_metadata_context null_ctx = {"", "", NULL, NULL}; + grpc_pollset_init(&request.pollset); request.is_done = 0; grpc_closure_init(&do_nothing_closure, do_nothing, NULL); - grpc_credentials_get_request_metadata(&exec_ctx, creds, &request.pollset, "", - on_oauth2_response, &request); + grpc_call_credentials_get_request_metadata(&exec_ctx, creds, &request.pollset, + null_ctx, on_oauth2_response, + &request); grpc_exec_ctx_finish(&exec_ctx); diff --git a/test/core/security/oauth2_utils.h b/test/core/security/oauth2_utils.h index 8082351b8a..b35fe7987f 100644 --- a/test/core/security/oauth2_utils.h +++ b/test/core/security/oauth2_utils.h @@ -42,7 +42,8 @@ extern "C" { /* Fetch oauth2 access token with a credentials object. Does not take ownership. Returns NULL on a failure. The caller should call gpr_free on the token. */ -char *grpc_test_fetch_oauth2_token_with_credentials(grpc_credentials *creds); +char *grpc_test_fetch_oauth2_token_with_credentials( + grpc_call_credentials *creds); #ifdef __cplusplus } diff --git a/test/core/security/print_google_default_creds_token.c b/test/core/security/print_google_default_creds_token.c index f207e05794..50fe61c996 100644 --- a/test/core/security/print_google_default_creds_token.c +++ b/test/core/security/print_google_default_creds_token.c @@ -72,12 +72,15 @@ int main(int argc, char **argv) { int result = 0; grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; synchronizer sync; - grpc_credentials *creds = NULL; + grpc_channel_credentials *creds = NULL; char *service_url = "https://test.foo.google.com/Foo"; + grpc_auth_metadata_context context; gpr_cmdline *cl = gpr_cmdline_create("print_google_default_creds_token"); gpr_cmdline_add_string(cl, "service_url", "Service URL for the token request.", &service_url); gpr_cmdline_parse(cl, argc, argv); + memset(&context, 0, sizeof(context)); + context.service_url = service_url; grpc_init(); @@ -91,9 +94,9 @@ int main(int argc, char **argv) { grpc_pollset_init(&sync.pollset); sync.is_done = 0; - grpc_credentials_get_request_metadata(&exec_ctx, creds, &sync.pollset, - service_url, on_metadata_response, - &sync); + grpc_call_credentials_get_request_metadata( + &exec_ctx, ((grpc_composite_channel_credentials *)creds)->call_creds, + &sync.pollset, context, on_metadata_response, &sync); gpr_mu_lock(GRPC_POLLSET_MU(&sync.pollset)); while (!sync.is_done) { @@ -107,7 +110,7 @@ int main(int argc, char **argv) { } gpr_mu_unlock(GRPC_POLLSET_MU(&sync.pollset)); - grpc_credentials_release(creds); + grpc_channel_credentials_release(creds); end: gpr_cmdline_destroy(cl); diff --git a/test/core/support/avl_test.c b/test/core/support/avl_test.c new file mode 100644 index 0000000000..6530fe4269 --- /dev/null +++ b/test/core/support/avl_test.c @@ -0,0 +1,3671 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include <grpc/support/avl.h> + +#include <stdio.h> +#include <string.h> + +#include <grpc/support/alloc.h> +#include <grpc/support/log.h> +#include <grpc/support/useful.h> + +#include "test/core/util/test_config.h" + +static int *box(int x) { + int *b = gpr_malloc(sizeof(*b)); + *b = x; + return b; +} + +static long int_compare(void *int1, void *int2) { + return (*(int *)int1) - (*(int *)int2); +} +static void *int_copy(void *p) { return box(*(int *)p); } + +static const gpr_avl_vtable int_int_vtable = {gpr_free, int_copy, int_compare, + gpr_free, int_copy}; + +static void check_get(gpr_avl avl, int key, int value) { + int *k = box(key); + GPR_ASSERT(*(int *)gpr_avl_get(avl, k) == value); + gpr_free(k); +} + +static void check_negget(gpr_avl avl, int key) { + int *k = box(key); + GPR_ASSERT(gpr_avl_get(avl, k) == NULL); + gpr_free(k); +} + +static gpr_avl remove_int(gpr_avl avl, int key) { + int *k = box(key); + avl = gpr_avl_remove(avl, k); + gpr_free(k); + return avl; +} + +static void test_get(void) { + gpr_avl avl; + gpr_log(GPR_DEBUG, "test_get"); + avl = gpr_avl_create(&int_int_vtable); + avl = gpr_avl_add(avl, box(1), box(11)); + avl = gpr_avl_add(avl, box(2), box(22)); + avl = gpr_avl_add(avl, box(3), box(33)); + check_get(avl, 1, 11); + check_get(avl, 2, 22); + check_get(avl, 3, 33); + check_negget(avl, 4); + gpr_avl_unref(avl); +} + +static void test_ll(void) { + gpr_avl avl; + gpr_log(GPR_DEBUG, "test_ll"); + avl = gpr_avl_create(&int_int_vtable); + avl = gpr_avl_add(avl, box(5), box(1)); + avl = gpr_avl_add(avl, box(4), box(2)); + avl = gpr_avl_add(avl, box(3), box(3)); + GPR_ASSERT(*(int *)avl.root->key == 4); + GPR_ASSERT(*(int *)avl.root->left->key == 3); + GPR_ASSERT(*(int *)avl.root->right->key == 5); + gpr_avl_unref(avl); +} + +static void test_lr(void) { + gpr_avl avl; + gpr_log(GPR_DEBUG, "test_lr"); + avl = gpr_avl_create(&int_int_vtable); + avl = gpr_avl_add(avl, box(5), box(1)); + avl = gpr_avl_add(avl, box(3), box(2)); + avl = gpr_avl_add(avl, box(4), box(3)); + GPR_ASSERT(*(int *)avl.root->key == 4); + GPR_ASSERT(*(int *)avl.root->left->key == 3); + GPR_ASSERT(*(int *)avl.root->right->key == 5); + gpr_avl_unref(avl); +} + +static void test_rr(void) { + gpr_avl avl; + gpr_log(GPR_DEBUG, "test_rr"); + avl = gpr_avl_create(&int_int_vtable); + avl = gpr_avl_add(avl, box(3), box(1)); + avl = gpr_avl_add(avl, box(4), box(2)); + avl = gpr_avl_add(avl, box(5), box(3)); + GPR_ASSERT(*(int *)avl.root->key == 4); + GPR_ASSERT(*(int *)avl.root->left->key == 3); + GPR_ASSERT(*(int *)avl.root->right->key == 5); + gpr_avl_unref(avl); +} + +static void test_rl(void) { + gpr_avl avl; + gpr_log(GPR_DEBUG, "test_rl"); + avl = gpr_avl_create(&int_int_vtable); + avl = gpr_avl_add(avl, box(3), box(1)); + avl = gpr_avl_add(avl, box(5), box(2)); + avl = gpr_avl_add(avl, box(4), box(3)); + GPR_ASSERT(*(int *)avl.root->key == 4); + GPR_ASSERT(*(int *)avl.root->left->key == 3); + GPR_ASSERT(*(int *)avl.root->right->key == 5); + gpr_avl_unref(avl); +} + +static void test_unbalanced(void) { + gpr_avl avl; + gpr_log(GPR_DEBUG, "test_unbalanced"); + avl = gpr_avl_create(&int_int_vtable); + avl = gpr_avl_add(avl, box(5), box(1)); + avl = gpr_avl_add(avl, box(4), box(2)); + avl = gpr_avl_add(avl, box(3), box(3)); + avl = gpr_avl_add(avl, box(2), box(4)); + avl = gpr_avl_add(avl, box(1), box(5)); + GPR_ASSERT(*(int *)avl.root->key == 4); + GPR_ASSERT(*(int *)avl.root->left->key == 2); + GPR_ASSERT(*(int *)avl.root->left->left->key == 1); + GPR_ASSERT(*(int *)avl.root->left->right->key == 3); + GPR_ASSERT(*(int *)avl.root->right->key == 5); + gpr_avl_unref(avl); +} + +static void test_replace(void) { + gpr_avl avl; + gpr_log(GPR_DEBUG, "test_replace"); + avl = gpr_avl_create(&int_int_vtable); + avl = gpr_avl_add(avl, box(1), box(1)); + avl = gpr_avl_add(avl, box(1), box(2)); + check_get(avl, 1, 2); + check_negget(avl, 2); + gpr_avl_unref(avl); +} + +static void test_remove(void) { + gpr_avl avl; + gpr_avl avl3, avl4, avl5, avln; + gpr_log(GPR_DEBUG, "test_remove"); + avl = gpr_avl_create(&int_int_vtable); + avl = gpr_avl_add(avl, box(3), box(1)); + avl = gpr_avl_add(avl, box(4), box(2)); + avl = gpr_avl_add(avl, box(5), box(3)); + + avl3 = remove_int(gpr_avl_ref(avl), 3); + avl4 = remove_int(gpr_avl_ref(avl), 4); + avl5 = remove_int(gpr_avl_ref(avl), 5); + avln = remove_int(gpr_avl_ref(avl), 1); + + gpr_avl_unref(avl); + + check_negget(avl3, 3); + check_get(avl3, 4, 2); + check_get(avl3, 5, 3); + gpr_avl_unref(avl3); + + check_get(avl4, 3, 1); + check_negget(avl4, 4); + check_get(avl4, 5, 3); + gpr_avl_unref(avl4); + + check_get(avl5, 3, 1); + check_get(avl5, 4, 2); + check_negget(avl5, 5); + gpr_avl_unref(avl5); + + check_get(avln, 3, 1); + check_get(avln, 4, 2); + check_get(avln, 5, 3); + gpr_avl_unref(avln); +} + +static void test_badcase1(void) { + gpr_avl avl; + + gpr_log(GPR_DEBUG, "test_badcase1"); + + avl = gpr_avl_create(&int_int_vtable); + avl = gpr_avl_add(avl, box(88), box(1)); + avl = remove_int(avl, 643); + avl = remove_int(avl, 983); + avl = gpr_avl_add(avl, box(985), box(4)); + avl = gpr_avl_add(avl, box(640), box(5)); + avl = gpr_avl_add(avl, box(41), box(6)); + avl = gpr_avl_add(avl, box(112), box(7)); + avl = gpr_avl_add(avl, box(342), box(8)); + avl = remove_int(avl, 1013); + avl = gpr_avl_add(avl, box(434), box(10)); + avl = gpr_avl_add(avl, box(520), box(11)); + avl = gpr_avl_add(avl, box(231), box(12)); + avl = gpr_avl_add(avl, box(852), box(13)); + avl = remove_int(avl, 461); + avl = gpr_avl_add(avl, box(108), box(15)); + avl = gpr_avl_add(avl, box(806), box(16)); + avl = gpr_avl_add(avl, box(827), box(17)); + avl = remove_int(avl, 796); + avl = gpr_avl_add(avl, box(340), box(19)); + avl = gpr_avl_add(avl, box(498), box(20)); + avl = gpr_avl_add(avl, box(203), box(21)); + avl = gpr_avl_add(avl, box(751), box(22)); + avl = gpr_avl_add(avl, box(150), box(23)); + avl = remove_int(avl, 237); + avl = gpr_avl_add(avl, box(830), box(25)); + avl = remove_int(avl, 1007); + avl = remove_int(avl, 394); + avl = gpr_avl_add(avl, box(65), box(28)); + avl = remove_int(avl, 904); + avl = remove_int(avl, 123); + avl = gpr_avl_add(avl, box(238), box(31)); + avl = gpr_avl_add(avl, box(184), box(32)); + avl = remove_int(avl, 331); + avl = gpr_avl_add(avl, box(827), box(34)); + + check_get(avl, 830, 25); + + gpr_avl_unref(avl); +} + +static void test_badcase2(void) { + gpr_avl avl; + + gpr_log(GPR_DEBUG, "test_badcase2"); + + avl = gpr_avl_create(&int_int_vtable); + avl = gpr_avl_add(avl, box(288), box(1)); + avl = remove_int(avl, 415); + avl = gpr_avl_add(avl, box(953), box(3)); + avl = gpr_avl_add(avl, box(101), box(4)); + avl = gpr_avl_add(avl, box(516), box(5)); + avl = gpr_avl_add(avl, box(547), box(6)); + avl = gpr_avl_add(avl, box(467), box(7)); + avl = gpr_avl_add(avl, box(793), box(8)); + avl = remove_int(avl, 190); + avl = gpr_avl_add(avl, box(687), box(10)); + avl = gpr_avl_add(avl, box(242), box(11)); + avl = gpr_avl_add(avl, box(142), box(12)); + avl = remove_int(avl, 705); + avl = remove_int(avl, 578); + avl = remove_int(avl, 767); + avl = remove_int(avl, 183); + avl = gpr_avl_add(avl, box(950), box(17)); + avl = gpr_avl_add(avl, box(622), box(18)); + avl = remove_int(avl, 513); + avl = remove_int(avl, 429); + avl = gpr_avl_add(avl, box(205), box(21)); + avl = remove_int(avl, 663); + avl = remove_int(avl, 953); + avl = remove_int(avl, 892); + avl = gpr_avl_add(avl, box(236), box(25)); + avl = remove_int(avl, 982); + avl = remove_int(avl, 201); + avl = remove_int(avl, 684); + avl = gpr_avl_add(avl, box(572), box(29)); + avl = remove_int(avl, 817); + avl = gpr_avl_add(avl, box(970), box(31)); + avl = remove_int(avl, 347); + avl = remove_int(avl, 574); + avl = gpr_avl_add(avl, box(752), box(34)); + avl = gpr_avl_add(avl, box(670), box(35)); + avl = gpr_avl_add(avl, box(69), box(36)); + avl = remove_int(avl, 111); + avl = remove_int(avl, 523); + avl = gpr_avl_add(avl, box(141), box(39)); + avl = remove_int(avl, 159); + avl = gpr_avl_add(avl, box(947), box(41)); + avl = gpr_avl_add(avl, box(855), box(42)); + avl = remove_int(avl, 218); + avl = remove_int(avl, 6); + avl = gpr_avl_add(avl, box(753), box(45)); + avl = remove_int(avl, 82); + avl = remove_int(avl, 799); + avl = gpr_avl_add(avl, box(572), box(48)); + avl = remove_int(avl, 376); + avl = remove_int(avl, 413); + avl = gpr_avl_add(avl, box(458), box(51)); + avl = remove_int(avl, 897); + avl = gpr_avl_add(avl, box(191), box(53)); + avl = gpr_avl_add(avl, box(609), box(54)); + avl = remove_int(avl, 787); + avl = remove_int(avl, 710); + avl = remove_int(avl, 886); + avl = remove_int(avl, 835); + avl = remove_int(avl, 33); + avl = gpr_avl_add(avl, box(871), box(60)); + avl = remove_int(avl, 641); + avl = gpr_avl_add(avl, box(462), box(62)); + avl = remove_int(avl, 359); + avl = remove_int(avl, 767); + avl = gpr_avl_add(avl, box(310), box(65)); + avl = remove_int(avl, 757); + avl = remove_int(avl, 639); + avl = remove_int(avl, 314); + avl = gpr_avl_add(avl, box(2), box(69)); + avl = remove_int(avl, 138); + avl = gpr_avl_add(avl, box(669), box(71)); + avl = remove_int(avl, 477); + avl = gpr_avl_add(avl, box(366), box(73)); + avl = gpr_avl_add(avl, box(612), box(74)); + avl = gpr_avl_add(avl, box(106), box(75)); + avl = remove_int(avl, 161); + avl = gpr_avl_add(avl, box(388), box(77)); + avl = gpr_avl_add(avl, box(141), box(78)); + avl = remove_int(avl, 633); + avl = remove_int(avl, 459); + avl = gpr_avl_add(avl, box(40), box(81)); + avl = remove_int(avl, 689); + avl = gpr_avl_add(avl, box(823), box(83)); + avl = remove_int(avl, 485); + avl = gpr_avl_add(avl, box(903), box(85)); + avl = gpr_avl_add(avl, box(592), box(86)); + avl = remove_int(avl, 448); + avl = gpr_avl_add(avl, box(56), box(88)); + avl = remove_int(avl, 333); + avl = gpr_avl_add(avl, box(189), box(90)); + avl = gpr_avl_add(avl, box(103), box(91)); + avl = remove_int(avl, 164); + avl = remove_int(avl, 974); + avl = gpr_avl_add(avl, box(215), box(94)); + avl = remove_int(avl, 189); + avl = remove_int(avl, 504); + avl = gpr_avl_add(avl, box(868), box(97)); + avl = remove_int(avl, 909); + avl = remove_int(avl, 148); + avl = remove_int(avl, 469); + avl = gpr_avl_add(avl, box(994), box(101)); + avl = gpr_avl_add(avl, box(576), box(102)); + avl = remove_int(avl, 82); + avl = remove_int(avl, 209); + avl = gpr_avl_add(avl, box(276), box(105)); + avl = remove_int(avl, 856); + avl = gpr_avl_add(avl, box(750), box(107)); + avl = remove_int(avl, 871); + avl = gpr_avl_add(avl, box(301), box(109)); + avl = remove_int(avl, 260); + avl = remove_int(avl, 737); + avl = remove_int(avl, 719); + avl = gpr_avl_add(avl, box(933), box(113)); + avl = gpr_avl_add(avl, box(225), box(114)); + avl = gpr_avl_add(avl, box(975), box(115)); + avl = gpr_avl_add(avl, box(86), box(116)); + avl = remove_int(avl, 732); + avl = gpr_avl_add(avl, box(340), box(118)); + avl = gpr_avl_add(avl, box(271), box(119)); + avl = remove_int(avl, 206); + avl = gpr_avl_add(avl, box(949), box(121)); + avl = gpr_avl_add(avl, box(927), box(122)); + avl = gpr_avl_add(avl, box(34), box(123)); + avl = gpr_avl_add(avl, box(351), box(124)); + avl = remove_int(avl, 836); + avl = gpr_avl_add(avl, box(825), box(126)); + avl = gpr_avl_add(avl, box(352), box(127)); + avl = remove_int(avl, 107); + avl = remove_int(avl, 101); + avl = gpr_avl_add(avl, box(320), box(130)); + avl = gpr_avl_add(avl, box(3), box(131)); + avl = remove_int(avl, 998); + avl = remove_int(avl, 44); + avl = gpr_avl_add(avl, box(525), box(134)); + avl = gpr_avl_add(avl, box(864), box(135)); + avl = gpr_avl_add(avl, box(863), box(136)); + avl = remove_int(avl, 770); + avl = gpr_avl_add(avl, box(440), box(138)); + avl = remove_int(avl, 516); + avl = gpr_avl_add(avl, box(116), box(140)); + avl = remove_int(avl, 380); + avl = gpr_avl_add(avl, box(878), box(142)); + avl = remove_int(avl, 439); + avl = gpr_avl_add(avl, box(994), box(144)); + avl = remove_int(avl, 294); + avl = remove_int(avl, 593); + avl = gpr_avl_add(avl, box(696), box(147)); + avl = remove_int(avl, 8); + avl = gpr_avl_add(avl, box(881), box(149)); + avl = remove_int(avl, 32); + avl = remove_int(avl, 242); + avl = gpr_avl_add(avl, box(487), box(152)); + avl = gpr_avl_add(avl, box(637), box(153)); + avl = gpr_avl_add(avl, box(793), box(154)); + avl = gpr_avl_add(avl, box(696), box(155)); + avl = remove_int(avl, 458); + avl = gpr_avl_add(avl, box(828), box(157)); + avl = remove_int(avl, 784); + avl = remove_int(avl, 274); + avl = gpr_avl_add(avl, box(783), box(160)); + avl = remove_int(avl, 21); + avl = gpr_avl_add(avl, box(866), box(162)); + avl = remove_int(avl, 919); + avl = gpr_avl_add(avl, box(435), box(164)); + avl = remove_int(avl, 385); + avl = gpr_avl_add(avl, box(475), box(166)); + avl = remove_int(avl, 339); + avl = gpr_avl_add(avl, box(615), box(168)); + avl = remove_int(avl, 866); + avl = remove_int(avl, 82); + avl = remove_int(avl, 271); + avl = gpr_avl_add(avl, box(590), box(172)); + avl = gpr_avl_add(avl, box(852), box(173)); + avl = remove_int(avl, 318); + avl = remove_int(avl, 82); + avl = gpr_avl_add(avl, box(672), box(176)); + avl = remove_int(avl, 430); + avl = gpr_avl_add(avl, box(821), box(178)); + avl = gpr_avl_add(avl, box(365), box(179)); + avl = remove_int(avl, 78); + avl = gpr_avl_add(avl, box(700), box(181)); + avl = gpr_avl_add(avl, box(353), box(182)); + avl = remove_int(avl, 492); + avl = gpr_avl_add(avl, box(991), box(184)); + avl = remove_int(avl, 330); + avl = gpr_avl_add(avl, box(873), box(186)); + avl = remove_int(avl, 589); + avl = gpr_avl_add(avl, box(676), box(188)); + avl = gpr_avl_add(avl, box(790), box(189)); + avl = remove_int(avl, 521); + avl = remove_int(avl, 47); + avl = gpr_avl_add(avl, box(976), box(192)); + avl = gpr_avl_add(avl, box(683), box(193)); + avl = remove_int(avl, 803); + avl = remove_int(avl, 1006); + avl = gpr_avl_add(avl, box(775), box(196)); + avl = gpr_avl_add(avl, box(411), box(197)); + avl = gpr_avl_add(avl, box(697), box(198)); + avl = remove_int(avl, 50); + avl = gpr_avl_add(avl, box(213), box(200)); + avl = remove_int(avl, 714); + avl = gpr_avl_add(avl, box(981), box(202)); + avl = gpr_avl_add(avl, box(502), box(203)); + avl = gpr_avl_add(avl, box(697), box(204)); + avl = gpr_avl_add(avl, box(603), box(205)); + avl = gpr_avl_add(avl, box(117), box(206)); + avl = remove_int(avl, 363); + avl = gpr_avl_add(avl, box(104), box(208)); + avl = remove_int(avl, 842); + avl = gpr_avl_add(avl, box(48), box(210)); + avl = remove_int(avl, 764); + avl = gpr_avl_add(avl, box(482), box(212)); + avl = gpr_avl_add(avl, box(928), box(213)); + avl = gpr_avl_add(avl, box(30), box(214)); + avl = gpr_avl_add(avl, box(820), box(215)); + avl = gpr_avl_add(avl, box(334), box(216)); + avl = remove_int(avl, 306); + avl = gpr_avl_add(avl, box(789), box(218)); + avl = remove_int(avl, 924); + avl = gpr_avl_add(avl, box(53), box(220)); + avl = remove_int(avl, 657); + avl = gpr_avl_add(avl, box(130), box(222)); + avl = gpr_avl_add(avl, box(239), box(223)); + avl = remove_int(avl, 20); + avl = gpr_avl_add(avl, box(117), box(225)); + avl = remove_int(avl, 882); + avl = remove_int(avl, 891); + avl = gpr_avl_add(avl, box(9), box(228)); + avl = gpr_avl_add(avl, box(496), box(229)); + avl = gpr_avl_add(avl, box(750), box(230)); + avl = gpr_avl_add(avl, box(283), box(231)); + avl = gpr_avl_add(avl, box(802), box(232)); + avl = remove_int(avl, 352); + avl = gpr_avl_add(avl, box(374), box(234)); + avl = gpr_avl_add(avl, box(6), box(235)); + avl = gpr_avl_add(avl, box(756), box(236)); + avl = gpr_avl_add(avl, box(597), box(237)); + avl = gpr_avl_add(avl, box(661), box(238)); + avl = remove_int(avl, 96); + avl = gpr_avl_add(avl, box(894), box(240)); + avl = remove_int(avl, 749); + avl = gpr_avl_add(avl, box(71), box(242)); + avl = remove_int(avl, 68); + avl = gpr_avl_add(avl, box(388), box(244)); + avl = remove_int(avl, 119); + avl = remove_int(avl, 856); + avl = gpr_avl_add(avl, box(176), box(247)); + avl = gpr_avl_add(avl, box(993), box(248)); + avl = remove_int(avl, 178); + avl = remove_int(avl, 781); + avl = remove_int(avl, 771); + avl = remove_int(avl, 848); + avl = remove_int(avl, 376); + avl = remove_int(avl, 157); + avl = remove_int(avl, 142); + avl = remove_int(avl, 686); + avl = gpr_avl_add(avl, box(779), box(257)); + avl = gpr_avl_add(avl, box(484), box(258)); + avl = remove_int(avl, 837); + avl = gpr_avl_add(avl, box(388), box(260)); + avl = remove_int(avl, 987); + avl = gpr_avl_add(avl, box(336), box(262)); + avl = remove_int(avl, 855); + avl = gpr_avl_add(avl, box(668), box(264)); + avl = remove_int(avl, 648); + avl = gpr_avl_add(avl, box(193), box(266)); + avl = remove_int(avl, 939); + avl = gpr_avl_add(avl, box(740), box(268)); + avl = gpr_avl_add(avl, box(503), box(269)); + avl = gpr_avl_add(avl, box(765), box(270)); + avl = remove_int(avl, 924); + avl = remove_int(avl, 513); + avl = gpr_avl_add(avl, box(161), box(273)); + avl = gpr_avl_add(avl, box(502), box(274)); + avl = gpr_avl_add(avl, box(846), box(275)); + avl = remove_int(avl, 931); + avl = gpr_avl_add(avl, box(87), box(277)); + avl = gpr_avl_add(avl, box(949), box(278)); + avl = gpr_avl_add(avl, box(548), box(279)); + avl = gpr_avl_add(avl, box(951), box(280)); + avl = remove_int(avl, 1018); + avl = remove_int(avl, 568); + avl = gpr_avl_add(avl, box(138), box(283)); + avl = gpr_avl_add(avl, box(202), box(284)); + avl = gpr_avl_add(avl, box(157), box(285)); + avl = gpr_avl_add(avl, box(264), box(286)); + avl = gpr_avl_add(avl, box(370), box(287)); + avl = remove_int(avl, 736); + avl = remove_int(avl, 751); + avl = remove_int(avl, 506); + avl = remove_int(avl, 81); + avl = remove_int(avl, 358); + avl = remove_int(avl, 657); + avl = remove_int(avl, 86); + avl = gpr_avl_add(avl, box(876), box(295)); + avl = remove_int(avl, 354); + avl = gpr_avl_add(avl, box(134), box(297)); + avl = remove_int(avl, 781); + avl = remove_int(avl, 183); + avl = gpr_avl_add(avl, box(914), box(300)); + avl = remove_int(avl, 926); + avl = remove_int(avl, 398); + avl = remove_int(avl, 932); + avl = remove_int(avl, 804); + avl = remove_int(avl, 326); + avl = gpr_avl_add(avl, box(208), box(306)); + avl = gpr_avl_add(avl, box(699), box(307)); + avl = remove_int(avl, 576); + avl = remove_int(avl, 850); + avl = remove_int(avl, 514); + avl = remove_int(avl, 676); + avl = remove_int(avl, 549); + avl = remove_int(avl, 767); + avl = gpr_avl_add(avl, box(58), box(314)); + avl = gpr_avl_add(avl, box(265), box(315)); + avl = gpr_avl_add(avl, box(268), box(316)); + avl = gpr_avl_add(avl, box(103), box(317)); + avl = gpr_avl_add(avl, box(440), box(318)); + avl = remove_int(avl, 777); + avl = gpr_avl_add(avl, box(670), box(320)); + avl = remove_int(avl, 506); + avl = remove_int(avl, 487); + avl = gpr_avl_add(avl, box(421), box(323)); + avl = remove_int(avl, 514); + avl = gpr_avl_add(avl, box(701), box(325)); + avl = remove_int(avl, 949); + avl = remove_int(avl, 872); + avl = remove_int(avl, 139); + avl = gpr_avl_add(avl, box(781), box(329)); + avl = gpr_avl_add(avl, box(543), box(330)); + avl = gpr_avl_add(avl, box(147), box(331)); + avl = remove_int(avl, 190); + avl = gpr_avl_add(avl, box(453), box(333)); + avl = remove_int(avl, 262); + avl = remove_int(avl, 850); + avl = remove_int(avl, 286); + avl = remove_int(avl, 787); + avl = gpr_avl_add(avl, box(514), box(338)); + avl = remove_int(avl, 812); + avl = gpr_avl_add(avl, box(431), box(340)); + avl = gpr_avl_add(avl, box(8), box(341)); + avl = remove_int(avl, 843); + avl = gpr_avl_add(avl, box(831), box(343)); + avl = remove_int(avl, 472); + avl = remove_int(avl, 157); + avl = gpr_avl_add(avl, box(612), box(346)); + avl = gpr_avl_add(avl, box(802), box(347)); + avl = remove_int(avl, 554); + avl = gpr_avl_add(avl, box(409), box(349)); + avl = gpr_avl_add(avl, box(439), box(350)); + avl = gpr_avl_add(avl, box(725), box(351)); + avl = gpr_avl_add(avl, box(568), box(352)); + avl = remove_int(avl, 475); + avl = remove_int(avl, 672); + avl = remove_int(avl, 62); + avl = remove_int(avl, 753); + avl = gpr_avl_add(avl, box(435), box(357)); + avl = gpr_avl_add(avl, box(950), box(358)); + avl = gpr_avl_add(avl, box(532), box(359)); + avl = gpr_avl_add(avl, box(832), box(360)); + avl = remove_int(avl, 390); + avl = gpr_avl_add(avl, box(993), box(362)); + avl = remove_int(avl, 198); + avl = remove_int(avl, 401); + avl = gpr_avl_add(avl, box(316), box(365)); + avl = remove_int(avl, 843); + avl = gpr_avl_add(avl, box(541), box(367)); + avl = gpr_avl_add(avl, box(505), box(368)); + avl = remove_int(avl, 445); + avl = remove_int(avl, 256); + avl = gpr_avl_add(avl, box(232), box(371)); + avl = remove_int(avl, 577); + avl = remove_int(avl, 558); + avl = gpr_avl_add(avl, box(910), box(374)); + avl = remove_int(avl, 902); + avl = remove_int(avl, 755); + avl = remove_int(avl, 114); + avl = remove_int(avl, 438); + avl = remove_int(avl, 224); + avl = gpr_avl_add(avl, box(920), box(380)); + avl = gpr_avl_add(avl, box(655), box(381)); + avl = remove_int(avl, 557); + avl = remove_int(avl, 102); + avl = remove_int(avl, 165); + avl = gpr_avl_add(avl, box(191), box(385)); + avl = remove_int(avl, 30); + avl = gpr_avl_add(avl, box(406), box(387)); + avl = gpr_avl_add(avl, box(66), box(388)); + avl = gpr_avl_add(avl, box(87), box(389)); + avl = remove_int(avl, 7); + avl = remove_int(avl, 671); + avl = gpr_avl_add(avl, box(234), box(392)); + avl = remove_int(avl, 463); + avl = gpr_avl_add(avl, box(75), box(394)); + avl = gpr_avl_add(avl, box(487), box(395)); + avl = remove_int(avl, 203); + avl = gpr_avl_add(avl, box(711), box(397)); + avl = remove_int(avl, 291); + avl = remove_int(avl, 798); + avl = remove_int(avl, 337); + avl = gpr_avl_add(avl, box(877), box(401)); + avl = gpr_avl_add(avl, box(388), box(402)); + avl = remove_int(avl, 975); + avl = gpr_avl_add(avl, box(200), box(404)); + avl = gpr_avl_add(avl, box(408), box(405)); + avl = gpr_avl_add(avl, box(3), box(406)); + avl = gpr_avl_add(avl, box(971), box(407)); + avl = remove_int(avl, 841); + avl = remove_int(avl, 910); + avl = remove_int(avl, 74); + avl = remove_int(avl, 888); + avl = gpr_avl_add(avl, box(492), box(412)); + avl = remove_int(avl, 14); + avl = remove_int(avl, 364); + avl = gpr_avl_add(avl, box(215), box(415)); + avl = remove_int(avl, 778); + avl = remove_int(avl, 45); + avl = gpr_avl_add(avl, box(328), box(418)); + avl = gpr_avl_add(avl, box(597), box(419)); + avl = remove_int(avl, 34); + avl = gpr_avl_add(avl, box(736), box(421)); + avl = remove_int(avl, 37); + avl = gpr_avl_add(avl, box(275), box(423)); + avl = gpr_avl_add(avl, box(70), box(424)); + avl = gpr_avl_add(avl, box(771), box(425)); + avl = remove_int(avl, 536); + avl = remove_int(avl, 421); + avl = gpr_avl_add(avl, box(186), box(428)); + avl = gpr_avl_add(avl, box(788), box(429)); + avl = gpr_avl_add(avl, box(224), box(430)); + avl = remove_int(avl, 228); + avl = gpr_avl_add(avl, box(48), box(432)); + avl = gpr_avl_add(avl, box(120), box(433)); + avl = gpr_avl_add(avl, box(269), box(434)); + avl = gpr_avl_add(avl, box(904), box(435)); + avl = remove_int(avl, 699); + avl = gpr_avl_add(avl, box(340), box(437)); + avl = remove_int(avl, 276); + avl = gpr_avl_add(avl, box(591), box(439)); + avl = gpr_avl_add(avl, box(778), box(440)); + avl = remove_int(avl, 490); + avl = remove_int(avl, 973); + avl = gpr_avl_add(avl, box(294), box(443)); + avl = gpr_avl_add(avl, box(323), box(444)); + avl = remove_int(avl, 685); + avl = gpr_avl_add(avl, box(38), box(446)); + avl = gpr_avl_add(avl, box(525), box(447)); + avl = remove_int(avl, 162); + avl = gpr_avl_add(avl, box(462), box(449)); + avl = gpr_avl_add(avl, box(340), box(450)); + avl = remove_int(avl, 734); + avl = remove_int(avl, 959); + avl = gpr_avl_add(avl, box(752), box(453)); + avl = gpr_avl_add(avl, box(667), box(454)); + avl = remove_int(avl, 558); + avl = remove_int(avl, 657); + avl = gpr_avl_add(avl, box(711), box(457)); + avl = remove_int(avl, 937); + avl = gpr_avl_add(avl, box(741), box(459)); + avl = gpr_avl_add(avl, box(40), box(460)); + avl = remove_int(avl, 784); + avl = gpr_avl_add(avl, box(292), box(462)); + avl = remove_int(avl, 164); + avl = remove_int(avl, 931); + avl = remove_int(avl, 886); + avl = gpr_avl_add(avl, box(968), box(466)); + avl = remove_int(avl, 263); + avl = gpr_avl_add(avl, box(647), box(468)); + avl = gpr_avl_add(avl, box(92), box(469)); + avl = remove_int(avl, 310); + avl = gpr_avl_add(avl, box(711), box(471)); + avl = gpr_avl_add(avl, box(675), box(472)); + avl = remove_int(avl, 549); + avl = gpr_avl_add(avl, box(380), box(474)); + avl = remove_int(avl, 825); + avl = gpr_avl_add(avl, box(668), box(476)); + avl = remove_int(avl, 498); + avl = gpr_avl_add(avl, box(870), box(478)); + avl = gpr_avl_add(avl, box(391), box(479)); + avl = gpr_avl_add(avl, box(264), box(480)); + avl = remove_int(avl, 1); + avl = remove_int(avl, 849); + avl = remove_int(avl, 88); + avl = remove_int(avl, 255); + avl = remove_int(avl, 763); + avl = remove_int(avl, 831); + avl = gpr_avl_add(avl, box(508), box(487)); + avl = remove_int(avl, 849); + avl = remove_int(avl, 47); + avl = gpr_avl_add(avl, box(299), box(490)); + avl = remove_int(avl, 625); + avl = remove_int(avl, 433); + avl = remove_int(avl, 904); + avl = remove_int(avl, 761); + avl = gpr_avl_add(avl, box(33), box(495)); + avl = gpr_avl_add(avl, box(524), box(496)); + avl = remove_int(avl, 210); + avl = remove_int(avl, 299); + avl = gpr_avl_add(avl, box(823), box(499)); + avl = remove_int(avl, 479); + avl = remove_int(avl, 96); + avl = remove_int(avl, 1013); + avl = gpr_avl_add(avl, box(768), box(503)); + avl = remove_int(avl, 638); + avl = remove_int(avl, 20); + avl = gpr_avl_add(avl, box(663), box(506)); + avl = remove_int(avl, 882); + avl = gpr_avl_add(avl, box(745), box(508)); + avl = remove_int(avl, 352); + avl = gpr_avl_add(avl, box(10), box(510)); + avl = remove_int(avl, 484); + avl = gpr_avl_add(avl, box(420), box(512)); + avl = gpr_avl_add(avl, box(884), box(513)); + avl = gpr_avl_add(avl, box(993), box(514)); + avl = gpr_avl_add(avl, box(251), box(515)); + avl = remove_int(avl, 222); + avl = gpr_avl_add(avl, box(734), box(517)); + avl = gpr_avl_add(avl, box(952), box(518)); + avl = remove_int(avl, 26); + avl = remove_int(avl, 270); + avl = remove_int(avl, 481); + avl = remove_int(avl, 693); + avl = remove_int(avl, 1006); + avl = gpr_avl_add(avl, box(77), box(524)); + avl = remove_int(avl, 897); + avl = gpr_avl_add(avl, box(719), box(526)); + avl = gpr_avl_add(avl, box(622), box(527)); + avl = remove_int(avl, 28); + avl = remove_int(avl, 836); + avl = remove_int(avl, 142); + avl = gpr_avl_add(avl, box(445), box(531)); + avl = gpr_avl_add(avl, box(410), box(532)); + avl = remove_int(avl, 575); + avl = gpr_avl_add(avl, box(634), box(534)); + avl = gpr_avl_add(avl, box(906), box(535)); + avl = remove_int(avl, 649); + avl = gpr_avl_add(avl, box(813), box(537)); + avl = remove_int(avl, 702); + avl = remove_int(avl, 732); + avl = gpr_avl_add(avl, box(105), box(540)); + avl = gpr_avl_add(avl, box(867), box(541)); + avl = remove_int(avl, 964); + avl = remove_int(avl, 941); + avl = gpr_avl_add(avl, box(947), box(544)); + avl = remove_int(avl, 990); + avl = gpr_avl_add(avl, box(816), box(546)); + avl = remove_int(avl, 429); + avl = remove_int(avl, 567); + avl = remove_int(avl, 541); + avl = remove_int(avl, 583); + avl = gpr_avl_add(avl, box(57), box(551)); + avl = gpr_avl_add(avl, box(786), box(552)); + avl = gpr_avl_add(avl, box(526), box(553)); + avl = remove_int(avl, 642); + avl = remove_int(avl, 220); + avl = remove_int(avl, 840); + avl = remove_int(avl, 548); + avl = gpr_avl_add(avl, box(528), box(558)); + avl = gpr_avl_add(avl, box(749), box(559)); + avl = gpr_avl_add(avl, box(194), box(560)); + avl = remove_int(avl, 517); + avl = gpr_avl_add(avl, box(102), box(562)); + avl = remove_int(avl, 189); + avl = gpr_avl_add(avl, box(927), box(564)); + avl = remove_int(avl, 846); + avl = remove_int(avl, 130); + avl = gpr_avl_add(avl, box(694), box(567)); + avl = remove_int(avl, 750); + avl = gpr_avl_add(avl, box(357), box(569)); + avl = remove_int(avl, 431); + avl = remove_int(avl, 91); + avl = gpr_avl_add(avl, box(640), box(572)); + avl = remove_int(avl, 4); + avl = gpr_avl_add(avl, box(81), box(574)); + avl = gpr_avl_add(avl, box(595), box(575)); + avl = remove_int(avl, 444); + avl = remove_int(avl, 262); + avl = remove_int(avl, 11); + avl = gpr_avl_add(avl, box(192), box(579)); + avl = gpr_avl_add(avl, box(158), box(580)); + avl = remove_int(avl, 401); + avl = remove_int(avl, 918); + avl = gpr_avl_add(avl, box(180), box(583)); + avl = remove_int(avl, 268); + avl = gpr_avl_add(avl, box(1012), box(585)); + avl = gpr_avl_add(avl, box(90), box(586)); + avl = gpr_avl_add(avl, box(946), box(587)); + avl = remove_int(avl, 719); + avl = gpr_avl_add(avl, box(874), box(589)); + avl = gpr_avl_add(avl, box(679), box(590)); + avl = remove_int(avl, 53); + avl = remove_int(avl, 534); + avl = gpr_avl_add(avl, box(646), box(593)); + avl = gpr_avl_add(avl, box(767), box(594)); + avl = gpr_avl_add(avl, box(460), box(595)); + avl = gpr_avl_add(avl, box(852), box(596)); + avl = gpr_avl_add(avl, box(189), box(597)); + avl = remove_int(avl, 932); + avl = remove_int(avl, 366); + avl = remove_int(avl, 907); + avl = gpr_avl_add(avl, box(875), box(601)); + avl = gpr_avl_add(avl, box(434), box(602)); + avl = gpr_avl_add(avl, box(704), box(603)); + avl = gpr_avl_add(avl, box(724), box(604)); + avl = gpr_avl_add(avl, box(930), box(605)); + avl = gpr_avl_add(avl, box(1000), box(606)); + avl = remove_int(avl, 479); + avl = gpr_avl_add(avl, box(275), box(608)); + avl = remove_int(avl, 32); + avl = gpr_avl_add(avl, box(939), box(610)); + avl = remove_int(avl, 943); + avl = remove_int(avl, 329); + avl = gpr_avl_add(avl, box(490), box(613)); + avl = remove_int(avl, 477); + avl = remove_int(avl, 414); + avl = remove_int(avl, 187); + avl = remove_int(avl, 334); + avl = gpr_avl_add(avl, box(40), box(618)); + avl = remove_int(avl, 751); + avl = gpr_avl_add(avl, box(568), box(620)); + avl = gpr_avl_add(avl, box(120), box(621)); + avl = gpr_avl_add(avl, box(617), box(622)); + avl = gpr_avl_add(avl, box(32), box(623)); + avl = remove_int(avl, 701); + avl = gpr_avl_add(avl, box(910), box(625)); + avl = remove_int(avl, 557); + avl = remove_int(avl, 361); + avl = remove_int(avl, 937); + avl = remove_int(avl, 100); + avl = remove_int(avl, 684); + avl = gpr_avl_add(avl, box(751), box(631)); + avl = remove_int(avl, 781); + avl = remove_int(avl, 469); + avl = remove_int(avl, 75); + avl = remove_int(avl, 561); + avl = gpr_avl_add(avl, box(854), box(636)); + avl = remove_int(avl, 164); + avl = remove_int(avl, 258); + avl = remove_int(avl, 315); + avl = remove_int(avl, 261); + avl = gpr_avl_add(avl, box(552), box(641)); + avl = gpr_avl_add(avl, box(6), box(642)); + avl = gpr_avl_add(avl, box(680), box(643)); + avl = remove_int(avl, 741); + avl = remove_int(avl, 309); + avl = remove_int(avl, 272); + avl = gpr_avl_add(avl, box(249), box(647)); + avl = remove_int(avl, 97); + avl = remove_int(avl, 850); + avl = gpr_avl_add(avl, box(915), box(650)); + avl = gpr_avl_add(avl, box(816), box(651)); + avl = gpr_avl_add(avl, box(45), box(652)); + avl = gpr_avl_add(avl, box(168), box(653)); + avl = remove_int(avl, 153); + avl = remove_int(avl, 239); + avl = gpr_avl_add(avl, box(684), box(656)); + avl = gpr_avl_add(avl, box(208), box(657)); + avl = gpr_avl_add(avl, box(681), box(658)); + avl = gpr_avl_add(avl, box(609), box(659)); + avl = gpr_avl_add(avl, box(645), box(660)); + avl = remove_int(avl, 799); + avl = gpr_avl_add(avl, box(955), box(662)); + avl = gpr_avl_add(avl, box(946), box(663)); + avl = gpr_avl_add(avl, box(744), box(664)); + avl = gpr_avl_add(avl, box(201), box(665)); + avl = gpr_avl_add(avl, box(136), box(666)); + avl = remove_int(avl, 357); + avl = gpr_avl_add(avl, box(974), box(668)); + avl = remove_int(avl, 485); + avl = gpr_avl_add(avl, box(1009), box(670)); + avl = gpr_avl_add(avl, box(517), box(671)); + avl = remove_int(avl, 491); + avl = gpr_avl_add(avl, box(336), box(673)); + avl = gpr_avl_add(avl, box(589), box(674)); + avl = remove_int(avl, 546); + avl = remove_int(avl, 840); + avl = remove_int(avl, 104); + avl = remove_int(avl, 347); + avl = gpr_avl_add(avl, box(801), box(679)); + avl = remove_int(avl, 799); + avl = remove_int(avl, 702); + avl = remove_int(avl, 996); + avl = remove_int(avl, 93); + avl = gpr_avl_add(avl, box(561), box(684)); + avl = gpr_avl_add(avl, box(25), box(685)); + avl = remove_int(avl, 278); + avl = gpr_avl_add(avl, box(191), box(687)); + avl = remove_int(avl, 243); + avl = remove_int(avl, 918); + avl = remove_int(avl, 449); + avl = gpr_avl_add(avl, box(19), box(691)); + avl = gpr_avl_add(avl, box(762), box(692)); + avl = gpr_avl_add(avl, box(13), box(693)); + avl = gpr_avl_add(avl, box(151), box(694)); + avl = gpr_avl_add(avl, box(152), box(695)); + avl = gpr_avl_add(avl, box(793), box(696)); + avl = remove_int(avl, 862); + avl = remove_int(avl, 890); + avl = gpr_avl_add(avl, box(687), box(699)); + avl = gpr_avl_add(avl, box(509), box(700)); + avl = gpr_avl_add(avl, box(973), box(701)); + avl = remove_int(avl, 230); + avl = gpr_avl_add(avl, box(532), box(703)); + avl = remove_int(avl, 668); + avl = gpr_avl_add(avl, box(281), box(705)); + avl = gpr_avl_add(avl, box(867), box(706)); + avl = gpr_avl_add(avl, box(359), box(707)); + avl = remove_int(avl, 425); + avl = gpr_avl_add(avl, box(691), box(709)); + avl = gpr_avl_add(avl, box(163), box(710)); + avl = gpr_avl_add(avl, box(502), box(711)); + avl = remove_int(avl, 674); + avl = gpr_avl_add(avl, box(697), box(713)); + avl = remove_int(avl, 271); + avl = gpr_avl_add(avl, box(968), box(715)); + avl = gpr_avl_add(avl, box(48), box(716)); + avl = remove_int(avl, 543); + avl = gpr_avl_add(avl, box(35), box(718)); + avl = gpr_avl_add(avl, box(751), box(719)); + avl = gpr_avl_add(avl, box(478), box(720)); + avl = remove_int(avl, 797); + avl = remove_int(avl, 309); + avl = gpr_avl_add(avl, box(927), box(723)); + avl = remove_int(avl, 504); + avl = gpr_avl_add(avl, box(286), box(725)); + avl = gpr_avl_add(avl, box(413), box(726)); + avl = gpr_avl_add(avl, box(599), box(727)); + avl = remove_int(avl, 105); + avl = remove_int(avl, 605); + avl = gpr_avl_add(avl, box(632), box(730)); + avl = gpr_avl_add(avl, box(133), box(731)); + avl = remove_int(avl, 443); + avl = gpr_avl_add(avl, box(958), box(733)); + avl = gpr_avl_add(avl, box(729), box(734)); + avl = remove_int(avl, 158); + avl = gpr_avl_add(avl, box(694), box(736)); + avl = gpr_avl_add(avl, box(505), box(737)); + avl = remove_int(avl, 63); + avl = remove_int(avl, 714); + avl = gpr_avl_add(avl, box(1002), box(740)); + avl = remove_int(avl, 211); + avl = gpr_avl_add(avl, box(765), box(742)); + avl = gpr_avl_add(avl, box(455), box(743)); + avl = remove_int(avl, 59); + avl = remove_int(avl, 224); + avl = gpr_avl_add(avl, box(586), box(746)); + avl = gpr_avl_add(avl, box(348), box(747)); + avl = remove_int(avl, 10); + avl = remove_int(avl, 484); + avl = gpr_avl_add(avl, box(968), box(750)); + avl = gpr_avl_add(avl, box(923), box(751)); + avl = remove_int(avl, 573); + avl = remove_int(avl, 617); + avl = gpr_avl_add(avl, box(812), box(754)); + avl = gpr_avl_add(avl, box(179), box(755)); + avl = remove_int(avl, 284); + avl = remove_int(avl, 157); + avl = remove_int(avl, 177); + avl = remove_int(avl, 896); + avl = gpr_avl_add(avl, box(649), box(760)); + avl = gpr_avl_add(avl, box(927), box(761)); + avl = gpr_avl_add(avl, box(454), box(762)); + avl = gpr_avl_add(avl, box(217), box(763)); + avl = remove_int(avl, 534); + avl = gpr_avl_add(avl, box(180), box(765)); + avl = gpr_avl_add(avl, box(319), box(766)); + avl = remove_int(avl, 92); + avl = gpr_avl_add(avl, box(483), box(768)); + avl = remove_int(avl, 504); + avl = remove_int(avl, 1017); + avl = remove_int(avl, 37); + avl = remove_int(avl, 50); + avl = gpr_avl_add(avl, box(302), box(773)); + avl = remove_int(avl, 807); + avl = gpr_avl_add(avl, box(463), box(775)); + avl = gpr_avl_add(avl, box(271), box(776)); + avl = gpr_avl_add(avl, box(644), box(777)); + avl = remove_int(avl, 618); + avl = gpr_avl_add(avl, box(166), box(779)); + avl = gpr_avl_add(avl, box(538), box(780)); + avl = remove_int(avl, 606); + avl = gpr_avl_add(avl, box(425), box(782)); + avl = remove_int(avl, 725); + avl = remove_int(avl, 383); + avl = gpr_avl_add(avl, box(155), box(785)); + avl = remove_int(avl, 889); + avl = gpr_avl_add(avl, box(653), box(787)); + avl = remove_int(avl, 386); + avl = gpr_avl_add(avl, box(142), box(789)); + avl = remove_int(avl, 107); + avl = remove_int(avl, 603); + avl = remove_int(avl, 971); + avl = gpr_avl_add(avl, box(80), box(793)); + avl = gpr_avl_add(avl, box(61), box(794)); + avl = gpr_avl_add(avl, box(693), box(795)); + avl = gpr_avl_add(avl, box(592), box(796)); + avl = gpr_avl_add(avl, box(433), box(797)); + avl = gpr_avl_add(avl, box(973), box(798)); + avl = remove_int(avl, 901); + avl = remove_int(avl, 340); + avl = remove_int(avl, 709); + avl = gpr_avl_add(avl, box(224), box(802)); + avl = remove_int(avl, 120); + avl = remove_int(avl, 271); + avl = gpr_avl_add(avl, box(780), box(805)); + avl = gpr_avl_add(avl, box(867), box(806)); + avl = gpr_avl_add(avl, box(756), box(807)); + avl = gpr_avl_add(avl, box(583), box(808)); + avl = gpr_avl_add(avl, box(356), box(809)); + avl = gpr_avl_add(avl, box(58), box(810)); + avl = remove_int(avl, 219); + avl = gpr_avl_add(avl, box(301), box(812)); + avl = remove_int(avl, 643); + avl = remove_int(avl, 787); + avl = remove_int(avl, 583); + avl = remove_int(avl, 552); + avl = remove_int(avl, 308); + avl = remove_int(avl, 608); + avl = remove_int(avl, 363); + avl = remove_int(avl, 690); + avl = gpr_avl_add(avl, box(233), box(821)); + avl = gpr_avl_add(avl, box(479), box(822)); + avl = gpr_avl_add(avl, box(323), box(823)); + avl = gpr_avl_add(avl, box(802), box(824)); + avl = remove_int(avl, 682); + avl = remove_int(avl, 705); + avl = remove_int(avl, 487); + avl = gpr_avl_add(avl, box(530), box(828)); + avl = gpr_avl_add(avl, box(232), box(829)); + avl = remove_int(avl, 627); + avl = gpr_avl_add(avl, box(396), box(831)); + avl = gpr_avl_add(avl, box(61), box(832)); + avl = gpr_avl_add(avl, box(932), box(833)); + avl = gpr_avl_add(avl, box(108), box(834)); + avl = gpr_avl_add(avl, box(524), box(835)); + avl = remove_int(avl, 390); + avl = remove_int(avl, 307); + avl = gpr_avl_add(avl, box(722), box(838)); + avl = gpr_avl_add(avl, box(907), box(839)); + avl = remove_int(avl, 286); + avl = remove_int(avl, 337); + avl = remove_int(avl, 443); + avl = gpr_avl_add(avl, box(973), box(843)); + avl = remove_int(avl, 930); + avl = remove_int(avl, 242); + avl = gpr_avl_add(avl, box(997), box(846)); + avl = gpr_avl_add(avl, box(689), box(847)); + avl = remove_int(avl, 318); + avl = gpr_avl_add(avl, box(703), box(849)); + avl = gpr_avl_add(avl, box(868), box(850)); + avl = gpr_avl_add(avl, box(200), box(851)); + avl = gpr_avl_add(avl, box(960), box(852)); + avl = gpr_avl_add(avl, box(80), box(853)); + avl = remove_int(avl, 113); + avl = gpr_avl_add(avl, box(135), box(855)); + avl = remove_int(avl, 529); + avl = gpr_avl_add(avl, box(366), box(857)); + avl = remove_int(avl, 272); + avl = gpr_avl_add(avl, box(921), box(859)); + avl = remove_int(avl, 497); + avl = gpr_avl_add(avl, box(712), box(861)); + avl = remove_int(avl, 777); + avl = remove_int(avl, 505); + avl = remove_int(avl, 974); + avl = remove_int(avl, 497); + avl = gpr_avl_add(avl, box(388), box(866)); + avl = gpr_avl_add(avl, box(29), box(867)); + avl = gpr_avl_add(avl, box(180), box(868)); + avl = gpr_avl_add(avl, box(983), box(869)); + avl = gpr_avl_add(avl, box(72), box(870)); + avl = gpr_avl_add(avl, box(693), box(871)); + avl = gpr_avl_add(avl, box(567), box(872)); + avl = remove_int(avl, 549); + avl = remove_int(avl, 351); + avl = gpr_avl_add(avl, box(1019), box(875)); + avl = remove_int(avl, 585); + avl = remove_int(avl, 294); + avl = remove_int(avl, 61); + avl = gpr_avl_add(avl, box(409), box(879)); + avl = gpr_avl_add(avl, box(984), box(880)); + avl = gpr_avl_add(avl, box(830), box(881)); + avl = remove_int(avl, 579); + avl = gpr_avl_add(avl, box(672), box(883)); + avl = remove_int(avl, 968); + + gpr_avl_unref(avl); +} + +static void test_badcase3(void) { + gpr_avl avl; + + gpr_log(GPR_DEBUG, "test_badcase3"); + + avl = gpr_avl_create(&int_int_vtable); + avl = remove_int(avl, 624); + avl = gpr_avl_add(avl, box(59), box(2)); + avl = gpr_avl_add(avl, box(494), box(3)); + avl = gpr_avl_add(avl, box(226), box(4)); + avl = remove_int(avl, 524); + avl = gpr_avl_add(avl, box(540), box(6)); + avl = remove_int(avl, 1008); + avl = gpr_avl_add(avl, box(502), box(8)); + avl = remove_int(avl, 267); + avl = remove_int(avl, 764); + avl = remove_int(avl, 443); + avl = gpr_avl_add(avl, box(8), box(12)); + avl = remove_int(avl, 291); + avl = remove_int(avl, 796); + avl = remove_int(avl, 1002); + avl = gpr_avl_add(avl, box(778), box(16)); + avl = remove_int(avl, 621); + avl = remove_int(avl, 891); + avl = remove_int(avl, 880); + avl = gpr_avl_add(avl, box(197), box(20)); + avl = gpr_avl_add(avl, box(441), box(21)); + avl = gpr_avl_add(avl, box(719), box(22)); + avl = remove_int(avl, 109); + avl = gpr_avl_add(avl, box(458), box(24)); + avl = remove_int(avl, 86); + avl = gpr_avl_add(avl, box(897), box(26)); + avl = gpr_avl_add(avl, box(997), box(27)); + avl = remove_int(avl, 235); + avl = remove_int(avl, 425); + avl = remove_int(avl, 186); + avl = gpr_avl_add(avl, box(887), box(31)); + avl = gpr_avl_add(avl, box(1005), box(32)); + avl = gpr_avl_add(avl, box(778), box(33)); + avl = gpr_avl_add(avl, box(575), box(34)); + avl = remove_int(avl, 966); + avl = remove_int(avl, 1015); + avl = gpr_avl_add(avl, box(486), box(37)); + avl = gpr_avl_add(avl, box(809), box(38)); + avl = gpr_avl_add(avl, box(907), box(39)); + avl = gpr_avl_add(avl, box(971), box(40)); + avl = remove_int(avl, 441); + avl = remove_int(avl, 498); + avl = gpr_avl_add(avl, box(727), box(43)); + avl = remove_int(avl, 679); + avl = remove_int(avl, 740); + avl = remove_int(avl, 532); + avl = gpr_avl_add(avl, box(805), box(47)); + avl = remove_int(avl, 64); + avl = gpr_avl_add(avl, box(362), box(49)); + avl = gpr_avl_add(avl, box(170), box(50)); + avl = gpr_avl_add(avl, box(389), box(51)); + avl = gpr_avl_add(avl, box(689), box(52)); + avl = remove_int(avl, 871); + avl = gpr_avl_add(avl, box(447), box(54)); + avl = remove_int(avl, 718); + avl = gpr_avl_add(avl, box(724), box(56)); + avl = remove_int(avl, 215); + avl = gpr_avl_add(avl, box(550), box(58)); + avl = remove_int(avl, 932); + avl = gpr_avl_add(avl, box(47), box(60)); + avl = remove_int(avl, 46); + avl = remove_int(avl, 229); + avl = gpr_avl_add(avl, box(68), box(63)); + avl = gpr_avl_add(avl, box(387), box(64)); + avl = remove_int(avl, 933); + avl = remove_int(avl, 736); + avl = remove_int(avl, 719); + avl = gpr_avl_add(avl, box(150), box(68)); + avl = remove_int(avl, 875); + avl = remove_int(avl, 298); + avl = gpr_avl_add(avl, box(991), box(71)); + avl = remove_int(avl, 705); + avl = gpr_avl_add(avl, box(197), box(73)); + avl = gpr_avl_add(avl, box(101), box(74)); + avl = remove_int(avl, 436); + avl = gpr_avl_add(avl, box(755), box(76)); + avl = gpr_avl_add(avl, box(727), box(77)); + avl = remove_int(avl, 309); + avl = remove_int(avl, 253); + avl = gpr_avl_add(avl, box(203), box(80)); + avl = remove_int(avl, 231); + avl = gpr_avl_add(avl, box(461), box(82)); + avl = remove_int(avl, 316); + avl = remove_int(avl, 493); + avl = gpr_avl_add(avl, box(184), box(85)); + avl = remove_int(avl, 737); + avl = gpr_avl_add(avl, box(790), box(87)); + avl = gpr_avl_add(avl, box(335), box(88)); + avl = remove_int(avl, 649); + avl = gpr_avl_add(avl, box(69), box(90)); + avl = remove_int(avl, 585); + avl = remove_int(avl, 543); + avl = gpr_avl_add(avl, box(784), box(93)); + avl = gpr_avl_add(avl, box(60), box(94)); + avl = gpr_avl_add(avl, box(525), box(95)); + avl = gpr_avl_add(avl, box(177), box(96)); + avl = gpr_avl_add(avl, box(178), box(97)); + avl = gpr_avl_add(avl, box(683), box(98)); + avl = gpr_avl_add(avl, box(226), box(99)); + avl = gpr_avl_add(avl, box(662), box(100)); + avl = remove_int(avl, 944); + avl = gpr_avl_add(avl, box(562), box(102)); + avl = gpr_avl_add(avl, box(793), box(103)); + avl = remove_int(avl, 673); + avl = gpr_avl_add(avl, box(310), box(105)); + avl = remove_int(avl, 479); + avl = remove_int(avl, 543); + avl = remove_int(avl, 159); + avl = remove_int(avl, 850); + avl = gpr_avl_add(avl, box(318), box(110)); + avl = gpr_avl_add(avl, box(483), box(111)); + avl = gpr_avl_add(avl, box(84), box(112)); + avl = remove_int(avl, 109); + avl = gpr_avl_add(avl, box(132), box(114)); + avl = gpr_avl_add(avl, box(920), box(115)); + avl = remove_int(avl, 746); + avl = gpr_avl_add(avl, box(145), box(117)); + avl = gpr_avl_add(avl, box(526), box(118)); + avl = remove_int(avl, 158); + avl = gpr_avl_add(avl, box(332), box(120)); + avl = gpr_avl_add(avl, box(918), box(121)); + avl = remove_int(avl, 339); + avl = gpr_avl_add(avl, box(809), box(123)); + avl = gpr_avl_add(avl, box(742), box(124)); + avl = gpr_avl_add(avl, box(718), box(125)); + avl = remove_int(avl, 988); + avl = remove_int(avl, 531); + avl = remove_int(avl, 840); + avl = gpr_avl_add(avl, box(816), box(129)); + avl = gpr_avl_add(avl, box(976), box(130)); + avl = remove_int(avl, 743); + avl = remove_int(avl, 528); + avl = remove_int(avl, 982); + avl = gpr_avl_add(avl, box(803), box(134)); + avl = gpr_avl_add(avl, box(205), box(135)); + avl = gpr_avl_add(avl, box(584), box(136)); + avl = remove_int(avl, 923); + avl = remove_int(avl, 538); + avl = remove_int(avl, 398); + avl = remove_int(avl, 320); + avl = remove_int(avl, 292); + avl = gpr_avl_add(avl, box(270), box(142)); + avl = gpr_avl_add(avl, box(333), box(143)); + avl = remove_int(avl, 439); + avl = gpr_avl_add(avl, box(35), box(145)); + avl = gpr_avl_add(avl, box(837), box(146)); + avl = remove_int(avl, 65); + avl = remove_int(avl, 642); + avl = remove_int(avl, 371); + avl = remove_int(avl, 140); + avl = remove_int(avl, 533); + avl = remove_int(avl, 676); + avl = gpr_avl_add(avl, box(624), box(153)); + avl = gpr_avl_add(avl, box(116), box(154)); + avl = gpr_avl_add(avl, box(446), box(155)); + avl = remove_int(avl, 91); + avl = remove_int(avl, 721); + avl = remove_int(avl, 537); + avl = gpr_avl_add(avl, box(448), box(159)); + avl = remove_int(avl, 155); + avl = remove_int(avl, 344); + avl = remove_int(avl, 237); + avl = gpr_avl_add(avl, box(309), box(163)); + avl = gpr_avl_add(avl, box(434), box(164)); + avl = gpr_avl_add(avl, box(277), box(165)); + avl = remove_int(avl, 233); + avl = gpr_avl_add(avl, box(275), box(167)); + avl = gpr_avl_add(avl, box(218), box(168)); + avl = gpr_avl_add(avl, box(76), box(169)); + avl = gpr_avl_add(avl, box(898), box(170)); + avl = remove_int(avl, 771); + avl = gpr_avl_add(avl, box(237), box(172)); + avl = remove_int(avl, 327); + avl = gpr_avl_add(avl, box(499), box(174)); + avl = remove_int(avl, 727); + avl = remove_int(avl, 234); + avl = remove_int(avl, 623); + avl = remove_int(avl, 458); + avl = remove_int(avl, 326); + avl = remove_int(avl, 589); + avl = gpr_avl_add(avl, box(442), box(181)); + avl = remove_int(avl, 389); + avl = gpr_avl_add(avl, box(708), box(183)); + avl = gpr_avl_add(avl, box(594), box(184)); + avl = gpr_avl_add(avl, box(942), box(185)); + avl = gpr_avl_add(avl, box(282), box(186)); + avl = remove_int(avl, 434); + avl = remove_int(avl, 134); + avl = remove_int(avl, 270); + avl = remove_int(avl, 512); + avl = remove_int(avl, 265); + avl = remove_int(avl, 21); + avl = remove_int(avl, 193); + avl = remove_int(avl, 797); + avl = remove_int(avl, 347); + avl = gpr_avl_add(avl, box(99), box(196)); + avl = gpr_avl_add(avl, box(161), box(197)); + avl = remove_int(avl, 484); + avl = gpr_avl_add(avl, box(72), box(199)); + avl = remove_int(avl, 629); + avl = gpr_avl_add(avl, box(522), box(201)); + avl = remove_int(avl, 679); + avl = gpr_avl_add(avl, box(407), box(203)); + avl = remove_int(avl, 693); + avl = gpr_avl_add(avl, box(424), box(205)); + avl = gpr_avl_add(avl, box(651), box(206)); + avl = gpr_avl_add(avl, box(927), box(207)); + avl = remove_int(avl, 553); + avl = gpr_avl_add(avl, box(128), box(209)); + avl = gpr_avl_add(avl, box(616), box(210)); + avl = gpr_avl_add(avl, box(690), box(211)); + avl = remove_int(avl, 241); + avl = remove_int(avl, 179); + avl = gpr_avl_add(avl, box(697), box(214)); + avl = remove_int(avl, 779); + avl = gpr_avl_add(avl, box(241), box(216)); + avl = remove_int(avl, 190); + avl = remove_int(avl, 210); + avl = gpr_avl_add(avl, box(711), box(219)); + avl = remove_int(avl, 251); + avl = remove_int(avl, 61); + avl = gpr_avl_add(avl, box(800), box(222)); + avl = remove_int(avl, 551); + avl = gpr_avl_add(avl, box(61), box(224)); + avl = gpr_avl_add(avl, box(656), box(225)); + avl = remove_int(avl, 130); + avl = remove_int(avl, 368); + avl = remove_int(avl, 150); + avl = remove_int(avl, 73); + avl = gpr_avl_add(avl, box(799), box(230)); + avl = gpr_avl_add(avl, box(125), box(231)); + avl = remove_int(avl, 107); + avl = gpr_avl_add(avl, box(938), box(233)); + avl = gpr_avl_add(avl, box(914), box(234)); + avl = gpr_avl_add(avl, box(197), box(235)); + avl = remove_int(avl, 736); + avl = gpr_avl_add(avl, box(20), box(237)); + avl = remove_int(avl, 224); + avl = remove_int(avl, 841); + avl = gpr_avl_add(avl, box(226), box(240)); + avl = remove_int(avl, 963); + avl = remove_int(avl, 796); + avl = remove_int(avl, 728); + avl = gpr_avl_add(avl, box(855), box(244)); + avl = gpr_avl_add(avl, box(769), box(245)); + avl = gpr_avl_add(avl, box(631), box(246)); + avl = remove_int(avl, 648); + avl = gpr_avl_add(avl, box(187), box(248)); + avl = gpr_avl_add(avl, box(31), box(249)); + avl = remove_int(avl, 163); + avl = gpr_avl_add(avl, box(218), box(251)); + avl = gpr_avl_add(avl, box(488), box(252)); + avl = gpr_avl_add(avl, box(387), box(253)); + avl = gpr_avl_add(avl, box(809), box(254)); + avl = gpr_avl_add(avl, box(997), box(255)); + avl = remove_int(avl, 678); + avl = gpr_avl_add(avl, box(368), box(257)); + avl = gpr_avl_add(avl, box(220), box(258)); + avl = gpr_avl_add(avl, box(373), box(259)); + avl = remove_int(avl, 874); + avl = remove_int(avl, 682); + avl = remove_int(avl, 1014); + avl = remove_int(avl, 195); + avl = gpr_avl_add(avl, box(868), box(264)); + avl = remove_int(avl, 254); + avl = remove_int(avl, 456); + avl = gpr_avl_add(avl, box(906), box(267)); + avl = remove_int(avl, 711); + avl = gpr_avl_add(avl, box(632), box(269)); + avl = remove_int(avl, 474); + avl = gpr_avl_add(avl, box(508), box(271)); + avl = gpr_avl_add(avl, box(518), box(272)); + avl = remove_int(avl, 579); + avl = remove_int(avl, 948); + avl = gpr_avl_add(avl, box(789), box(275)); + avl = gpr_avl_add(avl, box(48), box(276)); + avl = gpr_avl_add(avl, box(256), box(277)); + avl = gpr_avl_add(avl, box(754), box(278)); + avl = remove_int(avl, 215); + avl = gpr_avl_add(avl, box(679), box(280)); + avl = gpr_avl_add(avl, box(606), box(281)); + avl = remove_int(avl, 941); + avl = remove_int(avl, 31); + avl = gpr_avl_add(avl, box(758), box(284)); + avl = remove_int(avl, 101); + avl = gpr_avl_add(avl, box(244), box(286)); + avl = gpr_avl_add(avl, box(337), box(287)); + avl = gpr_avl_add(avl, box(461), box(288)); + avl = remove_int(avl, 476); + avl = gpr_avl_add(avl, box(845), box(290)); + avl = remove_int(avl, 160); + avl = gpr_avl_add(avl, box(690), box(292)); + avl = remove_int(avl, 931); + avl = gpr_avl_add(avl, box(869), box(294)); + avl = gpr_avl_add(avl, box(1019), box(295)); + avl = remove_int(avl, 591); + avl = remove_int(avl, 635); + avl = remove_int(avl, 67); + avl = gpr_avl_add(avl, box(113), box(299)); + avl = remove_int(avl, 305); + avl = gpr_avl_add(avl, box(10), box(301)); + avl = remove_int(avl, 823); + avl = remove_int(avl, 288); + avl = remove_int(avl, 239); + avl = gpr_avl_add(avl, box(646), box(305)); + avl = gpr_avl_add(avl, box(1006), box(306)); + avl = gpr_avl_add(avl, box(954), box(307)); + avl = gpr_avl_add(avl, box(199), box(308)); + avl = gpr_avl_add(avl, box(69), box(309)); + avl = gpr_avl_add(avl, box(984), box(310)); + avl = remove_int(avl, 568); + avl = remove_int(avl, 666); + avl = remove_int(avl, 37); + avl = gpr_avl_add(avl, box(845), box(314)); + avl = remove_int(avl, 535); + avl = remove_int(avl, 365); + avl = remove_int(avl, 676); + avl = remove_int(avl, 892); + avl = remove_int(avl, 425); + avl = remove_int(avl, 704); + avl = remove_int(avl, 168); + avl = gpr_avl_add(avl, box(853), box(322)); + avl = gpr_avl_add(avl, box(335), box(323)); + avl = gpr_avl_add(avl, box(961), box(324)); + avl = gpr_avl_add(avl, box(73), box(325)); + avl = remove_int(avl, 469); + avl = gpr_avl_add(avl, box(449), box(327)); + avl = remove_int(avl, 821); + avl = gpr_avl_add(avl, box(845), box(329)); + avl = remove_int(avl, 637); + avl = gpr_avl_add(avl, box(769), box(331)); + avl = gpr_avl_add(avl, box(901), box(332)); + avl = remove_int(avl, 142); + avl = remove_int(avl, 361); + avl = remove_int(avl, 876); + avl = gpr_avl_add(avl, box(614), box(336)); + avl = gpr_avl_add(avl, box(729), box(337)); + avl = remove_int(avl, 120); + avl = remove_int(avl, 473); + avl = remove_int(avl, 445); + avl = gpr_avl_add(avl, box(978), box(341)); + avl = gpr_avl_add(avl, box(164), box(342)); + avl = gpr_avl_add(avl, box(1), box(343)); + avl = remove_int(avl, 890); + avl = gpr_avl_add(avl, box(605), box(345)); + avl = gpr_avl_add(avl, box(178), box(346)); + avl = gpr_avl_add(avl, box(481), box(347)); + avl = gpr_avl_add(avl, box(772), box(348)); + avl = remove_int(avl, 824); + avl = remove_int(avl, 167); + avl = remove_int(avl, 151); + avl = gpr_avl_add(avl, box(698), box(352)); + avl = gpr_avl_add(avl, box(202), box(353)); + avl = gpr_avl_add(avl, box(921), box(354)); + avl = gpr_avl_add(avl, box(875), box(355)); + avl = remove_int(avl, 197); + avl = remove_int(avl, 232); + avl = gpr_avl_add(avl, box(209), box(358)); + avl = remove_int(avl, 324); + avl = remove_int(avl, 56); + avl = remove_int(avl, 579); + avl = remove_int(avl, 255); + avl = remove_int(avl, 290); + avl = gpr_avl_add(avl, box(661), box(364)); + avl = gpr_avl_add(avl, box(113), box(365)); + avl = remove_int(avl, 767); + avl = gpr_avl_add(avl, box(586), box(367)); + avl = gpr_avl_add(avl, box(121), box(368)); + avl = remove_int(avl, 235); + avl = remove_int(avl, 439); + avl = remove_int(avl, 360); + avl = gpr_avl_add(avl, box(916), box(372)); + avl = remove_int(avl, 999); + avl = gpr_avl_add(avl, box(825), box(374)); + avl = gpr_avl_add(avl, box(177), box(375)); + avl = remove_int(avl, 204); + avl = remove_int(avl, 92); + avl = gpr_avl_add(avl, box(794), box(378)); + avl = gpr_avl_add(avl, box(463), box(379)); + avl = gpr_avl_add(avl, box(472), box(380)); + avl = remove_int(avl, 235); + avl = gpr_avl_add(avl, box(840), box(382)); + avl = remove_int(avl, 657); + avl = gpr_avl_add(avl, box(586), box(384)); + avl = gpr_avl_add(avl, box(979), box(385)); + avl = remove_int(avl, 979); + avl = gpr_avl_add(avl, box(639), box(387)); + avl = remove_int(avl, 907); + avl = remove_int(avl, 973); + avl = gpr_avl_add(avl, box(913), box(390)); + avl = gpr_avl_add(avl, box(566), box(391)); + avl = gpr_avl_add(avl, box(883), box(392)); + avl = gpr_avl_add(avl, box(552), box(393)); + avl = gpr_avl_add(avl, box(16), box(394)); + avl = remove_int(avl, 60); + avl = gpr_avl_add(avl, box(567), box(396)); + avl = gpr_avl_add(avl, box(705), box(397)); + avl = gpr_avl_add(avl, box(94), box(398)); + avl = remove_int(avl, 321); + avl = gpr_avl_add(avl, box(207), box(400)); + avl = gpr_avl_add(avl, box(682), box(401)); + avl = gpr_avl_add(avl, box(592), box(402)); + avl = gpr_avl_add(avl, box(10), box(403)); + avl = remove_int(avl, 911); + avl = remove_int(avl, 161); + avl = gpr_avl_add(avl, box(86), box(406)); + avl = remove_int(avl, 893); + avl = remove_int(avl, 362); + avl = gpr_avl_add(avl, box(599), box(409)); + avl = remove_int(avl, 413); + avl = gpr_avl_add(avl, box(867), box(411)); + avl = remove_int(avl, 955); + avl = gpr_avl_add(avl, box(341), box(413)); + avl = gpr_avl_add(avl, box(887), box(414)); + avl = remove_int(avl, 706); + avl = gpr_avl_add(avl, box(939), box(416)); + avl = remove_int(avl, 233); + avl = remove_int(avl, 662); + avl = remove_int(avl, 984); + avl = remove_int(avl, 203); + avl = gpr_avl_add(avl, box(326), box(421)); + avl = remove_int(avl, 848); + avl = gpr_avl_add(avl, box(235), box(423)); + avl = remove_int(avl, 617); + avl = gpr_avl_add(avl, box(565), box(425)); + avl = remove_int(avl, 469); + avl = gpr_avl_add(avl, box(988), box(427)); + avl = remove_int(avl, 957); + avl = gpr_avl_add(avl, box(426), box(429)); + avl = remove_int(avl, 967); + avl = gpr_avl_add(avl, box(890), box(431)); + avl = gpr_avl_add(avl, box(473), box(432)); + avl = remove_int(avl, 367); + avl = remove_int(avl, 344); + avl = remove_int(avl, 660); + avl = remove_int(avl, 448); + avl = remove_int(avl, 837); + avl = remove_int(avl, 158); + avl = gpr_avl_add(avl, box(459), box(439)); + avl = remove_int(avl, 882); + avl = remove_int(avl, 782); + avl = gpr_avl_add(avl, box(408), box(442)); + avl = gpr_avl_add(avl, box(728), box(443)); + avl = remove_int(avl, 27); + avl = gpr_avl_add(avl, box(137), box(445)); + avl = gpr_avl_add(avl, box(239), box(446)); + avl = remove_int(avl, 854); + avl = gpr_avl_add(avl, box(104), box(448)); + avl = gpr_avl_add(avl, box(823), box(449)); + avl = gpr_avl_add(avl, box(524), box(450)); + avl = gpr_avl_add(avl, box(995), box(451)); + avl = remove_int(avl, 422); + avl = remove_int(avl, 220); + avl = gpr_avl_add(avl, box(856), box(454)); + avl = remove_int(avl, 332); + avl = gpr_avl_add(avl, box(679), box(456)); + avl = remove_int(avl, 18); + avl = gpr_avl_add(avl, box(837), box(458)); + avl = remove_int(avl, 405); + avl = remove_int(avl, 877); + avl = remove_int(avl, 835); + avl = gpr_avl_add(avl, box(547), box(462)); + avl = remove_int(avl, 805); + avl = remove_int(avl, 862); + avl = gpr_avl_add(avl, box(75), box(465)); + avl = remove_int(avl, 41); + avl = gpr_avl_add(avl, box(310), box(467)); + avl = remove_int(avl, 855); + avl = gpr_avl_add(avl, box(20), box(469)); + avl = remove_int(avl, 186); + avl = remove_int(avl, 378); + avl = remove_int(avl, 442); + avl = remove_int(avl, 930); + avl = gpr_avl_add(avl, box(118), box(474)); + avl = gpr_avl_add(avl, box(96), box(475)); + avl = remove_int(avl, 854); + avl = gpr_avl_add(avl, box(65), box(477)); + avl = gpr_avl_add(avl, box(573), box(478)); + avl = gpr_avl_add(avl, box(4), box(479)); + avl = gpr_avl_add(avl, box(451), box(480)); + avl = gpr_avl_add(avl, box(774), box(481)); + avl = gpr_avl_add(avl, box(126), box(482)); + avl = remove_int(avl, 956); + avl = remove_int(avl, 591); + avl = remove_int(avl, 644); + avl = gpr_avl_add(avl, box(304), box(486)); + avl = remove_int(avl, 620); + avl = remove_int(avl, 394); + avl = gpr_avl_add(avl, box(1002), box(489)); + avl = gpr_avl_add(avl, box(837), box(490)); + avl = remove_int(avl, 485); + avl = gpr_avl_add(avl, box(1005), box(492)); + avl = remove_int(avl, 21); + avl = gpr_avl_add(avl, box(396), box(494)); + avl = remove_int(avl, 966); + avl = gpr_avl_add(avl, box(105), box(496)); + avl = gpr_avl_add(avl, box(316), box(497)); + avl = remove_int(avl, 776); + avl = gpr_avl_add(avl, box(188), box(499)); + avl = remove_int(avl, 200); + avl = gpr_avl_add(avl, box(98), box(501)); + avl = gpr_avl_add(avl, box(831), box(502)); + avl = gpr_avl_add(avl, box(227), box(503)); + avl = gpr_avl_add(avl, box(220), box(504)); + avl = remove_int(avl, 715); + avl = remove_int(avl, 279); + avl = gpr_avl_add(avl, box(701), box(507)); + avl = gpr_avl_add(avl, box(726), box(508)); + avl = gpr_avl_add(avl, box(815), box(509)); + avl = gpr_avl_add(avl, box(749), box(510)); + avl = remove_int(avl, 946); + avl = remove_int(avl, 449); + avl = remove_int(avl, 62); + avl = remove_int(avl, 487); + avl = gpr_avl_add(avl, box(545), box(515)); + avl = remove_int(avl, 59); + avl = gpr_avl_add(avl, box(168), box(517)); + avl = remove_int(avl, 337); + avl = gpr_avl_add(avl, box(69), box(519)); + avl = remove_int(avl, 600); + avl = gpr_avl_add(avl, box(591), box(521)); + avl = gpr_avl_add(avl, box(960), box(522)); + avl = gpr_avl_add(avl, box(116), box(523)); + avl = remove_int(avl, 991); + avl = gpr_avl_add(avl, box(760), box(525)); + avl = gpr_avl_add(avl, box(664), box(526)); + avl = gpr_avl_add(avl, box(547), box(527)); + avl = remove_int(avl, 922); + avl = gpr_avl_add(avl, box(290), box(529)); + avl = gpr_avl_add(avl, box(859), box(530)); + avl = gpr_avl_add(avl, box(49), box(531)); + avl = remove_int(avl, 455); + avl = remove_int(avl, 786); + avl = gpr_avl_add(avl, box(613), box(534)); + avl = gpr_avl_add(avl, box(326), box(535)); + avl = remove_int(avl, 615); + avl = gpr_avl_add(avl, box(45), box(537)); + avl = gpr_avl_add(avl, box(162), box(538)); + avl = gpr_avl_add(avl, box(189), box(539)); + avl = remove_int(avl, 68); + avl = remove_int(avl, 846); + avl = gpr_avl_add(avl, box(608), box(542)); + avl = remove_int(avl, 821); + avl = gpr_avl_add(avl, box(978), box(544)); + avl = gpr_avl_add(avl, box(892), box(545)); + avl = remove_int(avl, 924); + avl = gpr_avl_add(avl, box(708), box(547)); + avl = remove_int(avl, 135); + avl = remove_int(avl, 124); + avl = gpr_avl_add(avl, box(301), box(550)); + avl = gpr_avl_add(avl, box(939), box(551)); + avl = gpr_avl_add(avl, box(344), box(552)); + avl = remove_int(avl, 443); + avl = remove_int(avl, 122); + avl = gpr_avl_add(avl, box(636), box(555)); + avl = remove_int(avl, 558); + avl = gpr_avl_add(avl, box(923), box(557)); + avl = remove_int(avl, 827); + avl = gpr_avl_add(avl, box(649), box(559)); + avl = gpr_avl_add(avl, box(808), box(560)); + avl = remove_int(avl, 570); + avl = remove_int(avl, 434); + avl = gpr_avl_add(avl, box(40), box(563)); + avl = gpr_avl_add(avl, box(725), box(564)); + avl = remove_int(avl, 295); + avl = remove_int(avl, 615); + avl = remove_int(avl, 919); + avl = remove_int(avl, 170); + avl = remove_int(avl, 442); + avl = remove_int(avl, 971); + avl = gpr_avl_add(avl, box(483), box(571)); + avl = gpr_avl_add(avl, box(512), box(572)); + avl = remove_int(avl, 648); + avl = remove_int(avl, 78); + avl = remove_int(avl, 72); + avl = remove_int(avl, 790); + avl = remove_int(avl, 571); + avl = gpr_avl_add(avl, box(898), box(578)); + avl = remove_int(avl, 770); + avl = remove_int(avl, 776); + avl = gpr_avl_add(avl, box(602), box(581)); + avl = remove_int(avl, 251); + avl = gpr_avl_add(avl, box(303), box(583)); + avl = remove_int(avl, 837); + avl = gpr_avl_add(avl, box(714), box(585)); + avl = remove_int(avl, 800); + avl = gpr_avl_add(avl, box(266), box(587)); + avl = gpr_avl_add(avl, box(555), box(588)); + avl = remove_int(avl, 604); + avl = remove_int(avl, 163); + avl = remove_int(avl, 497); + avl = gpr_avl_add(avl, box(296), box(592)); + avl = remove_int(avl, 129); + avl = gpr_avl_add(avl, box(656), box(594)); + avl = remove_int(avl, 769); + avl = remove_int(avl, 941); + avl = gpr_avl_add(avl, box(775), box(597)); + avl = gpr_avl_add(avl, box(846), box(598)); + avl = remove_int(avl, 591); + avl = remove_int(avl, 801); + avl = remove_int(avl, 419); + avl = remove_int(avl, 455); + avl = gpr_avl_add(avl, box(866), box(603)); + avl = gpr_avl_add(avl, box(575), box(604)); + avl = gpr_avl_add(avl, box(620), box(605)); + avl = remove_int(avl, 100); + avl = remove_int(avl, 667); + avl = gpr_avl_add(avl, box(138), box(608)); + avl = gpr_avl_add(avl, box(566), box(609)); + avl = gpr_avl_add(avl, box(673), box(610)); + avl = gpr_avl_add(avl, box(178), box(611)); + avl = remove_int(avl, 659); + avl = gpr_avl_add(avl, box(759), box(613)); + avl = gpr_avl_add(avl, box(1008), box(614)); + avl = remove_int(avl, 116); + avl = gpr_avl_add(avl, box(608), box(616)); + avl = gpr_avl_add(avl, box(339), box(617)); + avl = gpr_avl_add(avl, box(197), box(618)); + avl = remove_int(avl, 25); + avl = remove_int(avl, 628); + avl = gpr_avl_add(avl, box(487), box(621)); + avl = remove_int(avl, 739); + avl = remove_int(avl, 100); + avl = remove_int(avl, 928); + avl = gpr_avl_add(avl, box(647), box(625)); + avl = remove_int(avl, 978); + avl = remove_int(avl, 143); + avl = remove_int(avl, 755); + avl = gpr_avl_add(avl, box(71), box(629)); + avl = remove_int(avl, 205); + avl = gpr_avl_add(avl, box(501), box(631)); + avl = remove_int(avl, 723); + avl = remove_int(avl, 852); + avl = remove_int(avl, 1021); + avl = remove_int(avl, 670); + avl = remove_int(avl, 500); + avl = gpr_avl_add(avl, box(330), box(637)); + avl = remove_int(avl, 264); + avl = gpr_avl_add(avl, box(69), box(639)); + avl = remove_int(avl, 73); + avl = gpr_avl_add(avl, box(745), box(641)); + avl = remove_int(avl, 518); + avl = remove_int(avl, 641); + avl = remove_int(avl, 768); + avl = gpr_avl_add(avl, box(988), box(645)); + avl = gpr_avl_add(avl, box(899), box(646)); + avl = remove_int(avl, 763); + avl = remove_int(avl, 281); + avl = remove_int(avl, 496); + avl = gpr_avl_add(avl, box(445), box(650)); + avl = remove_int(avl, 905); + avl = gpr_avl_add(avl, box(275), box(652)); + avl = gpr_avl_add(avl, box(137), box(653)); + avl = remove_int(avl, 642); + avl = gpr_avl_add(avl, box(708), box(655)); + avl = remove_int(avl, 922); + avl = gpr_avl_add(avl, box(743), box(657)); + avl = remove_int(avl, 295); + avl = remove_int(avl, 665); + avl = remove_int(avl, 48); + avl = gpr_avl_add(avl, box(1012), box(661)); + avl = remove_int(avl, 71); + avl = remove_int(avl, 523); + avl = gpr_avl_add(avl, box(319), box(664)); + avl = remove_int(avl, 632); + avl = gpr_avl_add(avl, box(137), box(666)); + avl = gpr_avl_add(avl, box(686), box(667)); + avl = gpr_avl_add(avl, box(724), box(668)); + avl = gpr_avl_add(avl, box(952), box(669)); + avl = gpr_avl_add(avl, box(5), box(670)); + avl = remove_int(avl, 35); + avl = gpr_avl_add(avl, box(43), box(672)); + avl = gpr_avl_add(avl, box(320), box(673)); + avl = gpr_avl_add(avl, box(115), box(674)); + avl = remove_int(avl, 377); + avl = remove_int(avl, 591); + avl = remove_int(avl, 87); + avl = remove_int(avl, 93); + avl = gpr_avl_add(avl, box(1016), box(679)); + avl = gpr_avl_add(avl, box(605), box(680)); + avl = gpr_avl_add(avl, box(152), box(681)); + avl = gpr_avl_add(avl, box(113), box(682)); + avl = remove_int(avl, 131); + avl = remove_int(avl, 637); + avl = gpr_avl_add(avl, box(156), box(685)); + avl = remove_int(avl, 696); + avl = gpr_avl_add(avl, box(546), box(687)); + avl = remove_int(avl, 970); + avl = remove_int(avl, 53); + avl = remove_int(avl, 827); + avl = remove_int(avl, 224); + avl = remove_int(avl, 796); + avl = remove_int(avl, 34); + avl = remove_int(avl, 922); + avl = remove_int(avl, 277); + avl = remove_int(avl, 650); + avl = remove_int(avl, 222); + avl = remove_int(avl, 244); + avl = remove_int(avl, 576); + avl = remove_int(avl, 413); + avl = gpr_avl_add(avl, box(500), box(701)); + avl = remove_int(avl, 924); + avl = gpr_avl_add(avl, box(825), box(703)); + avl = remove_int(avl, 888); + avl = remove_int(avl, 931); + avl = gpr_avl_add(avl, box(285), box(706)); + avl = remove_int(avl, 62); + avl = remove_int(avl, 444); + avl = remove_int(avl, 946); + avl = gpr_avl_add(avl, box(122), box(710)); + avl = gpr_avl_add(avl, box(846), box(711)); + avl = remove_int(avl, 628); + avl = gpr_avl_add(avl, box(511), box(713)); + avl = gpr_avl_add(avl, box(398), box(714)); + avl = remove_int(avl, 730); + avl = gpr_avl_add(avl, box(797), box(716)); + avl = remove_int(avl, 897); + avl = remove_int(avl, 228); + avl = remove_int(avl, 544); + avl = remove_int(avl, 552); + avl = remove_int(avl, 783); + avl = remove_int(avl, 583); + avl = remove_int(avl, 894); + avl = remove_int(avl, 942); + avl = gpr_avl_add(avl, box(346), box(725)); + avl = gpr_avl_add(avl, box(1015), box(726)); + avl = remove_int(avl, 813); + avl = gpr_avl_add(avl, box(213), box(728)); + avl = remove_int(avl, 468); + avl = remove_int(avl, 365); + avl = remove_int(avl, 399); + avl = gpr_avl_add(avl, box(380), box(732)); + avl = remove_int(avl, 835); + avl = remove_int(avl, 970); + avl = gpr_avl_add(avl, box(700), box(735)); + avl = gpr_avl_add(avl, box(807), box(736)); + avl = remove_int(avl, 312); + avl = remove_int(avl, 282); + avl = remove_int(avl, 370); + avl = remove_int(avl, 999); + avl = remove_int(avl, 241); + avl = remove_int(avl, 884); + avl = gpr_avl_add(avl, box(587), box(743)); + avl = gpr_avl_add(avl, box(332), box(744)); + avl = remove_int(avl, 686); + avl = remove_int(avl, 206); + avl = remove_int(avl, 835); + avl = gpr_avl_add(avl, box(334), box(748)); + avl = remove_int(avl, 171); + avl = gpr_avl_add(avl, box(1002), box(750)); + avl = gpr_avl_add(avl, box(779), box(751)); + avl = gpr_avl_add(avl, box(307), box(752)); + avl = gpr_avl_add(avl, box(127), box(753)); + avl = gpr_avl_add(avl, box(251), box(754)); + avl = remove_int(avl, 790); + avl = remove_int(avl, 189); + avl = remove_int(avl, 193); + avl = remove_int(avl, 38); + avl = remove_int(avl, 124); + avl = gpr_avl_add(avl, box(812), box(760)); + avl = remove_int(avl, 43); + avl = gpr_avl_add(avl, box(871), box(762)); + avl = gpr_avl_add(avl, box(580), box(763)); + avl = remove_int(avl, 501); + avl = remove_int(avl, 462); + avl = remove_int(avl, 599); + avl = gpr_avl_add(avl, box(240), box(767)); + avl = gpr_avl_add(avl, box(285), box(768)); + avl = gpr_avl_add(avl, box(472), box(769)); + avl = remove_int(avl, 865); + avl = remove_int(avl, 763); + avl = remove_int(avl, 245); + avl = remove_int(avl, 80); + avl = remove_int(avl, 713); + avl = remove_int(avl, 654); + avl = remove_int(avl, 1014); + avl = gpr_avl_add(avl, box(495), box(777)); + avl = gpr_avl_add(avl, box(552), box(778)); + avl = remove_int(avl, 19); + avl = remove_int(avl, 803); + avl = gpr_avl_add(avl, box(508), box(781)); + avl = remove_int(avl, 699); + avl = remove_int(avl, 260); + avl = remove_int(avl, 92); + avl = remove_int(avl, 497); + avl = gpr_avl_add(avl, box(970), box(786)); + avl = remove_int(avl, 987); + avl = remove_int(avl, 168); + avl = remove_int(avl, 476); + avl = remove_int(avl, 248); + avl = gpr_avl_add(avl, box(358), box(791)); + avl = remove_int(avl, 804); + avl = remove_int(avl, 77); + avl = remove_int(avl, 905); + avl = remove_int(avl, 362); + avl = gpr_avl_add(avl, box(578), box(796)); + avl = remove_int(avl, 38); + avl = remove_int(avl, 595); + avl = gpr_avl_add(avl, box(213), box(799)); + avl = remove_int(avl, 7); + avl = remove_int(avl, 620); + avl = gpr_avl_add(avl, box(946), box(802)); + avl = remove_int(avl, 145); + avl = gpr_avl_add(avl, box(628), box(804)); + avl = remove_int(avl, 972); + avl = gpr_avl_add(avl, box(728), box(806)); + avl = remove_int(avl, 91); + avl = gpr_avl_add(avl, box(136), box(808)); + avl = gpr_avl_add(avl, box(841), box(809)); + avl = gpr_avl_add(avl, box(265), box(810)); + avl = gpr_avl_add(avl, box(701), box(811)); + avl = gpr_avl_add(avl, box(27), box(812)); + avl = remove_int(avl, 72); + avl = remove_int(avl, 14); + avl = gpr_avl_add(avl, box(286), box(815)); + avl = remove_int(avl, 996); + avl = remove_int(avl, 998); + avl = gpr_avl_add(avl, box(466), box(818)); + avl = remove_int(avl, 1009); + avl = remove_int(avl, 741); + avl = remove_int(avl, 947); + avl = remove_int(avl, 241); + avl = remove_int(avl, 954); + avl = remove_int(avl, 183); + avl = remove_int(avl, 395); + avl = remove_int(avl, 951); + avl = gpr_avl_add(avl, box(267), box(827)); + avl = remove_int(avl, 812); + avl = gpr_avl_add(avl, box(577), box(829)); + avl = remove_int(avl, 624); + avl = remove_int(avl, 847); + avl = remove_int(avl, 745); + avl = gpr_avl_add(avl, box(491), box(833)); + avl = gpr_avl_add(avl, box(941), box(834)); + avl = remove_int(avl, 258); + avl = gpr_avl_add(avl, box(410), box(836)); + avl = gpr_avl_add(avl, box(80), box(837)); + avl = gpr_avl_add(avl, box(196), box(838)); + avl = gpr_avl_add(avl, box(5), box(839)); + avl = remove_int(avl, 782); + avl = gpr_avl_add(avl, box(827), box(841)); + avl = remove_int(avl, 472); + avl = remove_int(avl, 664); + avl = gpr_avl_add(avl, box(409), box(844)); + avl = gpr_avl_add(avl, box(62), box(845)); + avl = remove_int(avl, 56); + avl = remove_int(avl, 606); + avl = remove_int(avl, 707); + avl = remove_int(avl, 989); + avl = remove_int(avl, 549); + avl = remove_int(avl, 259); + avl = gpr_avl_add(avl, box(405), box(852)); + avl = remove_int(avl, 587); + avl = remove_int(avl, 350); + avl = gpr_avl_add(avl, box(980), box(855)); + avl = gpr_avl_add(avl, box(992), box(856)); + avl = gpr_avl_add(avl, box(818), box(857)); + avl = remove_int(avl, 853); + avl = remove_int(avl, 701); + avl = gpr_avl_add(avl, box(675), box(860)); + avl = remove_int(avl, 248); + avl = remove_int(avl, 649); + avl = gpr_avl_add(avl, box(508), box(863)); + avl = remove_int(avl, 927); + avl = gpr_avl_add(avl, box(957), box(865)); + avl = gpr_avl_add(avl, box(698), box(866)); + avl = gpr_avl_add(avl, box(388), box(867)); + avl = gpr_avl_add(avl, box(532), box(868)); + avl = gpr_avl_add(avl, box(681), box(869)); + avl = remove_int(avl, 544); + avl = remove_int(avl, 991); + avl = remove_int(avl, 397); + avl = gpr_avl_add(avl, box(954), box(873)); + avl = gpr_avl_add(avl, box(219), box(874)); + avl = gpr_avl_add(avl, box(465), box(875)); + avl = remove_int(avl, 371); + avl = gpr_avl_add(avl, box(601), box(877)); + avl = gpr_avl_add(avl, box(543), box(878)); + avl = remove_int(avl, 329); + avl = gpr_avl_add(avl, box(560), box(880)); + avl = remove_int(avl, 898); + avl = gpr_avl_add(avl, box(455), box(882)); + avl = remove_int(avl, 313); + avl = gpr_avl_add(avl, box(215), box(884)); + avl = remove_int(avl, 846); + avl = gpr_avl_add(avl, box(608), box(886)); + avl = remove_int(avl, 248); + avl = gpr_avl_add(avl, box(575), box(888)); + avl = remove_int(avl, 207); + avl = remove_int(avl, 810); + avl = remove_int(avl, 665); + avl = remove_int(avl, 361); + avl = gpr_avl_add(avl, box(154), box(893)); + avl = gpr_avl_add(avl, box(329), box(894)); + avl = gpr_avl_add(avl, box(326), box(895)); + avl = remove_int(avl, 746); + avl = remove_int(avl, 99); + avl = gpr_avl_add(avl, box(464), box(898)); + avl = gpr_avl_add(avl, box(141), box(899)); + avl = remove_int(avl, 383); + avl = gpr_avl_add(avl, box(414), box(901)); + avl = gpr_avl_add(avl, box(777), box(902)); + avl = remove_int(avl, 972); + avl = remove_int(avl, 841); + avl = remove_int(avl, 100); + avl = gpr_avl_add(avl, box(828), box(906)); + avl = remove_int(avl, 785); + avl = gpr_avl_add(avl, box(1008), box(908)); + avl = gpr_avl_add(avl, box(46), box(909)); + avl = remove_int(avl, 399); + avl = gpr_avl_add(avl, box(178), box(911)); + avl = gpr_avl_add(avl, box(573), box(912)); + avl = remove_int(avl, 299); + avl = gpr_avl_add(avl, box(690), box(914)); + avl = gpr_avl_add(avl, box(692), box(915)); + avl = remove_int(avl, 404); + avl = remove_int(avl, 16); + avl = remove_int(avl, 746); + avl = remove_int(avl, 486); + avl = remove_int(avl, 119); + avl = gpr_avl_add(avl, box(167), box(921)); + avl = remove_int(avl, 328); + avl = gpr_avl_add(avl, box(89), box(923)); + avl = remove_int(avl, 867); + avl = remove_int(avl, 626); + avl = remove_int(avl, 507); + avl = gpr_avl_add(avl, box(365), box(927)); + avl = gpr_avl_add(avl, box(58), box(928)); + avl = gpr_avl_add(avl, box(70), box(929)); + avl = remove_int(avl, 81); + avl = remove_int(avl, 797); + avl = gpr_avl_add(avl, box(846), box(932)); + avl = remove_int(avl, 642); + avl = gpr_avl_add(avl, box(777), box(934)); + avl = remove_int(avl, 107); + avl = gpr_avl_add(avl, box(691), box(936)); + avl = gpr_avl_add(avl, box(820), box(937)); + avl = gpr_avl_add(avl, box(202), box(938)); + avl = gpr_avl_add(avl, box(308), box(939)); + avl = gpr_avl_add(avl, box(20), box(940)); + avl = remove_int(avl, 289); + avl = gpr_avl_add(avl, box(714), box(942)); + avl = gpr_avl_add(avl, box(584), box(943)); + avl = remove_int(avl, 294); + avl = gpr_avl_add(avl, box(496), box(945)); + avl = gpr_avl_add(avl, box(394), box(946)); + avl = gpr_avl_add(avl, box(860), box(947)); + avl = gpr_avl_add(avl, box(58), box(948)); + avl = remove_int(avl, 784); + avl = remove_int(avl, 584); + avl = remove_int(avl, 708); + avl = gpr_avl_add(avl, box(142), box(952)); + avl = gpr_avl_add(avl, box(247), box(953)); + avl = gpr_avl_add(avl, box(389), box(954)); + avl = remove_int(avl, 390); + avl = gpr_avl_add(avl, box(465), box(956)); + avl = gpr_avl_add(avl, box(936), box(957)); + avl = gpr_avl_add(avl, box(309), box(958)); + avl = remove_int(avl, 928); + avl = remove_int(avl, 128); + avl = remove_int(avl, 979); + avl = remove_int(avl, 670); + avl = remove_int(avl, 738); + avl = remove_int(avl, 271); + avl = remove_int(avl, 540); + avl = gpr_avl_add(avl, box(365), box(966)); + avl = remove_int(avl, 82); + avl = gpr_avl_add(avl, box(728), box(968)); + avl = remove_int(avl, 852); + avl = gpr_avl_add(avl, box(884), box(970)); + avl = gpr_avl_add(avl, box(502), box(971)); + avl = remove_int(avl, 898); + avl = remove_int(avl, 481); + avl = gpr_avl_add(avl, box(911), box(974)); + avl = remove_int(avl, 787); + avl = remove_int(avl, 785); + avl = remove_int(avl, 537); + avl = remove_int(avl, 535); + avl = remove_int(avl, 136); + avl = remove_int(avl, 749); + avl = remove_int(avl, 637); + avl = remove_int(avl, 900); + avl = gpr_avl_add(avl, box(598), box(983)); + avl = remove_int(avl, 25); + avl = remove_int(avl, 697); + avl = gpr_avl_add(avl, box(645), box(986)); + avl = gpr_avl_add(avl, box(211), box(987)); + avl = gpr_avl_add(avl, box(589), box(988)); + avl = remove_int(avl, 702); + avl = gpr_avl_add(avl, box(53), box(990)); + avl = remove_int(avl, 492); + avl = remove_int(avl, 185); + avl = remove_int(avl, 246); + avl = remove_int(avl, 257); + avl = remove_int(avl, 502); + avl = remove_int(avl, 34); + avl = gpr_avl_add(avl, box(74), box(997)); + avl = gpr_avl_add(avl, box(834), box(998)); + avl = gpr_avl_add(avl, box(514), box(999)); + avl = gpr_avl_add(avl, box(75), box(1000)); + avl = remove_int(avl, 745); + avl = gpr_avl_add(avl, box(362), box(1002)); + avl = remove_int(avl, 215); + avl = gpr_avl_add(avl, box(624), box(1004)); + avl = remove_int(avl, 404); + avl = remove_int(avl, 359); + avl = remove_int(avl, 491); + avl = gpr_avl_add(avl, box(903), box(1008)); + avl = gpr_avl_add(avl, box(240), box(1009)); + avl = remove_int(avl, 95); + avl = gpr_avl_add(avl, box(119), box(1011)); + avl = gpr_avl_add(avl, box(857), box(1012)); + avl = remove_int(avl, 39); + avl = remove_int(avl, 866); + avl = gpr_avl_add(avl, box(503), box(1015)); + avl = gpr_avl_add(avl, box(740), box(1016)); + avl = remove_int(avl, 637); + avl = remove_int(avl, 156); + avl = remove_int(avl, 6); + avl = remove_int(avl, 745); + avl = remove_int(avl, 433); + avl = remove_int(avl, 283); + avl = gpr_avl_add(avl, box(625), box(1023)); + avl = remove_int(avl, 638); + avl = gpr_avl_add(avl, box(299), box(1025)); + avl = gpr_avl_add(avl, box(584), box(1026)); + avl = remove_int(avl, 863); + avl = gpr_avl_add(avl, box(612), box(1028)); + avl = gpr_avl_add(avl, box(62), box(1029)); + avl = gpr_avl_add(avl, box(432), box(1030)); + avl = remove_int(avl, 371); + avl = remove_int(avl, 790); + avl = remove_int(avl, 227); + avl = remove_int(avl, 836); + avl = gpr_avl_add(avl, box(703), box(1035)); + avl = gpr_avl_add(avl, box(644), box(1036)); + avl = remove_int(avl, 638); + avl = gpr_avl_add(avl, box(13), box(1038)); + avl = remove_int(avl, 66); + avl = remove_int(avl, 82); + avl = gpr_avl_add(avl, box(362), box(1041)); + avl = gpr_avl_add(avl, box(783), box(1042)); + avl = remove_int(avl, 60); + avl = gpr_avl_add(avl, box(80), box(1044)); + avl = gpr_avl_add(avl, box(825), box(1045)); + avl = gpr_avl_add(avl, box(688), box(1046)); + avl = gpr_avl_add(avl, box(662), box(1047)); + avl = remove_int(avl, 156); + avl = remove_int(avl, 376); + avl = remove_int(avl, 99); + avl = gpr_avl_add(avl, box(526), box(1051)); + avl = gpr_avl_add(avl, box(168), box(1052)); + avl = remove_int(avl, 646); + avl = remove_int(avl, 380); + avl = remove_int(avl, 833); + avl = gpr_avl_add(avl, box(53), box(1056)); + avl = remove_int(avl, 105); + avl = gpr_avl_add(avl, box(373), box(1058)); + avl = gpr_avl_add(avl, box(184), box(1059)); + avl = remove_int(avl, 288); + avl = gpr_avl_add(avl, box(966), box(1061)); + avl = remove_int(avl, 158); + avl = gpr_avl_add(avl, box(406), box(1063)); + avl = remove_int(avl, 470); + avl = gpr_avl_add(avl, box(283), box(1065)); + avl = gpr_avl_add(avl, box(838), box(1066)); + avl = gpr_avl_add(avl, box(288), box(1067)); + avl = gpr_avl_add(avl, box(950), box(1068)); + avl = gpr_avl_add(avl, box(163), box(1069)); + avl = remove_int(avl, 623); + avl = remove_int(avl, 769); + avl = gpr_avl_add(avl, box(144), box(1072)); + avl = gpr_avl_add(avl, box(489), box(1073)); + avl = remove_int(avl, 15); + avl = gpr_avl_add(avl, box(971), box(1075)); + avl = remove_int(avl, 660); + avl = gpr_avl_add(avl, box(255), box(1077)); + avl = remove_int(avl, 494); + avl = gpr_avl_add(avl, box(109), box(1079)); + avl = gpr_avl_add(avl, box(420), box(1080)); + avl = gpr_avl_add(avl, box(509), box(1081)); + avl = remove_int(avl, 178); + avl = gpr_avl_add(avl, box(216), box(1083)); + avl = gpr_avl_add(avl, box(707), box(1084)); + avl = gpr_avl_add(avl, box(411), box(1085)); + avl = gpr_avl_add(avl, box(352), box(1086)); + avl = remove_int(avl, 983); + avl = gpr_avl_add(avl, box(6), box(1088)); + avl = gpr_avl_add(avl, box(1014), box(1089)); + avl = remove_int(avl, 98); + avl = remove_int(avl, 325); + avl = gpr_avl_add(avl, box(851), box(1092)); + avl = remove_int(avl, 553); + avl = gpr_avl_add(avl, box(218), box(1094)); + avl = gpr_avl_add(avl, box(261), box(1095)); + avl = remove_int(avl, 31); + avl = gpr_avl_add(avl, box(872), box(1097)); + avl = remove_int(avl, 543); + avl = remove_int(avl, 314); + avl = remove_int(avl, 443); + avl = gpr_avl_add(avl, box(533), box(1101)); + avl = remove_int(avl, 881); + avl = remove_int(avl, 269); + avl = remove_int(avl, 940); + avl = remove_int(avl, 909); + avl = remove_int(avl, 197); + avl = remove_int(avl, 773); + avl = remove_int(avl, 790); + avl = remove_int(avl, 345); + avl = gpr_avl_add(avl, box(965), box(1110)); + avl = remove_int(avl, 622); + avl = gpr_avl_add(avl, box(352), box(1112)); + avl = remove_int(avl, 182); + avl = gpr_avl_add(avl, box(534), box(1114)); + avl = gpr_avl_add(avl, box(97), box(1115)); + avl = gpr_avl_add(avl, box(198), box(1116)); + avl = remove_int(avl, 750); + avl = gpr_avl_add(avl, box(98), box(1118)); + avl = remove_int(avl, 943); + avl = gpr_avl_add(avl, box(254), box(1120)); + avl = gpr_avl_add(avl, box(30), box(1121)); + avl = remove_int(avl, 14); + avl = remove_int(avl, 475); + avl = remove_int(avl, 82); + avl = gpr_avl_add(avl, box(789), box(1125)); + avl = gpr_avl_add(avl, box(402), box(1126)); + avl = remove_int(avl, 1019); + avl = gpr_avl_add(avl, box(858), box(1128)); + avl = gpr_avl_add(avl, box(625), box(1129)); + avl = remove_int(avl, 675); + avl = remove_int(avl, 323); + avl = gpr_avl_add(avl, box(329), box(1132)); + avl = remove_int(avl, 929); + avl = remove_int(avl, 44); + avl = gpr_avl_add(avl, box(443), box(1135)); + avl = gpr_avl_add(avl, box(653), box(1136)); + avl = gpr_avl_add(avl, box(750), box(1137)); + avl = gpr_avl_add(avl, box(252), box(1138)); + avl = gpr_avl_add(avl, box(449), box(1139)); + avl = remove_int(avl, 1022); + avl = remove_int(avl, 357); + avl = remove_int(avl, 602); + avl = remove_int(avl, 131); + avl = gpr_avl_add(avl, box(531), box(1144)); + avl = remove_int(avl, 806); + avl = gpr_avl_add(avl, box(455), box(1146)); + avl = remove_int(avl, 31); + avl = gpr_avl_add(avl, box(154), box(1148)); + avl = gpr_avl_add(avl, box(189), box(1149)); + avl = remove_int(avl, 786); + avl = gpr_avl_add(avl, box(496), box(1151)); + avl = gpr_avl_add(avl, box(81), box(1152)); + avl = gpr_avl_add(avl, box(59), box(1153)); + avl = remove_int(avl, 424); + avl = remove_int(avl, 668); + avl = gpr_avl_add(avl, box(723), box(1156)); + avl = gpr_avl_add(avl, box(822), box(1157)); + avl = gpr_avl_add(avl, box(354), box(1158)); + avl = remove_int(avl, 738); + avl = gpr_avl_add(avl, box(686), box(1160)); + avl = gpr_avl_add(avl, box(43), box(1161)); + avl = gpr_avl_add(avl, box(625), box(1162)); + avl = gpr_avl_add(avl, box(902), box(1163)); + avl = gpr_avl_add(avl, box(12), box(1164)); + avl = gpr_avl_add(avl, box(977), box(1165)); + avl = gpr_avl_add(avl, box(699), box(1166)); + avl = gpr_avl_add(avl, box(189), box(1167)); + avl = remove_int(avl, 672); + avl = remove_int(avl, 90); + avl = remove_int(avl, 757); + avl = remove_int(avl, 494); + avl = gpr_avl_add(avl, box(759), box(1172)); + avl = remove_int(avl, 758); + avl = remove_int(avl, 222); + avl = gpr_avl_add(avl, box(975), box(1175)); + avl = remove_int(avl, 993); + avl = gpr_avl_add(avl, box(2), box(1177)); + avl = gpr_avl_add(avl, box(70), box(1178)); + avl = remove_int(avl, 350); + avl = remove_int(avl, 972); + avl = remove_int(avl, 880); + avl = gpr_avl_add(avl, box(753), box(1182)); + avl = remove_int(avl, 404); + avl = gpr_avl_add(avl, box(294), box(1184)); + avl = remove_int(avl, 474); + avl = gpr_avl_add(avl, box(228), box(1186)); + avl = gpr_avl_add(avl, box(484), box(1187)); + avl = remove_int(avl, 238); + avl = remove_int(avl, 53); + avl = remove_int(avl, 691); + avl = gpr_avl_add(avl, box(345), box(1191)); + avl = remove_int(avl, 0); + avl = gpr_avl_add(avl, box(230), box(1193)); + avl = remove_int(avl, 227); + avl = remove_int(avl, 152); + avl = gpr_avl_add(avl, box(884), box(1196)); + avl = remove_int(avl, 823); + avl = remove_int(avl, 53); + avl = gpr_avl_add(avl, box(1015), box(1199)); + avl = gpr_avl_add(avl, box(697), box(1200)); + avl = gpr_avl_add(avl, box(376), box(1201)); + avl = remove_int(avl, 411); + avl = gpr_avl_add(avl, box(888), box(1203)); + avl = remove_int(avl, 55); + avl = gpr_avl_add(avl, box(85), box(1205)); + avl = remove_int(avl, 947); + avl = remove_int(avl, 382); + avl = remove_int(avl, 777); + avl = gpr_avl_add(avl, box(1017), box(1209)); + avl = gpr_avl_add(avl, box(169), box(1210)); + avl = gpr_avl_add(avl, box(156), box(1211)); + avl = remove_int(avl, 153); + avl = remove_int(avl, 642); + avl = remove_int(avl, 158); + avl = gpr_avl_add(avl, box(554), box(1215)); + avl = gpr_avl_add(avl, box(76), box(1216)); + avl = gpr_avl_add(avl, box(756), box(1217)); + avl = remove_int(avl, 767); + avl = remove_int(avl, 112); + avl = remove_int(avl, 539); + avl = remove_int(avl, 544); + avl = remove_int(avl, 628); + avl = remove_int(avl, 385); + avl = remove_int(avl, 514); + avl = remove_int(avl, 362); + avl = gpr_avl_add(avl, box(523), box(1226)); + avl = gpr_avl_add(avl, box(712), box(1227)); + avl = gpr_avl_add(avl, box(474), box(1228)); + avl = gpr_avl_add(avl, box(882), box(1229)); + avl = gpr_avl_add(avl, box(965), box(1230)); + avl = remove_int(avl, 464); + avl = gpr_avl_add(avl, box(319), box(1232)); + avl = gpr_avl_add(avl, box(504), box(1233)); + avl = remove_int(avl, 818); + avl = gpr_avl_add(avl, box(884), box(1235)); + avl = gpr_avl_add(avl, box(813), box(1236)); + avl = gpr_avl_add(avl, box(795), box(1237)); + avl = remove_int(avl, 306); + avl = gpr_avl_add(avl, box(799), box(1239)); + avl = remove_int(avl, 534); + avl = gpr_avl_add(avl, box(480), box(1241)); + avl = gpr_avl_add(avl, box(656), box(1242)); + avl = gpr_avl_add(avl, box(709), box(1243)); + avl = gpr_avl_add(avl, box(500), box(1244)); + avl = remove_int(avl, 740); + avl = gpr_avl_add(avl, box(980), box(1246)); + avl = gpr_avl_add(avl, box(458), box(1247)); + avl = remove_int(avl, 377); + avl = remove_int(avl, 338); + avl = gpr_avl_add(avl, box(554), box(1250)); + avl = gpr_avl_add(avl, box(504), box(1251)); + avl = gpr_avl_add(avl, box(603), box(1252)); + avl = gpr_avl_add(avl, box(761), box(1253)); + avl = remove_int(avl, 431); + avl = gpr_avl_add(avl, box(707), box(1255)); + avl = gpr_avl_add(avl, box(673), box(1256)); + avl = remove_int(avl, 998); + avl = remove_int(avl, 332); + avl = remove_int(avl, 413); + avl = remove_int(avl, 227); + avl = remove_int(avl, 249); + avl = remove_int(avl, 309); + avl = remove_int(avl, 459); + avl = gpr_avl_add(avl, box(645), box(1264)); + avl = remove_int(avl, 858); + avl = remove_int(avl, 997); + avl = gpr_avl_add(avl, box(519), box(1267)); + avl = remove_int(avl, 614); + avl = remove_int(avl, 462); + avl = remove_int(avl, 792); + avl = gpr_avl_add(avl, box(987), box(1271)); + avl = gpr_avl_add(avl, box(309), box(1272)); + avl = remove_int(avl, 747); + avl = gpr_avl_add(avl, box(621), box(1274)); + avl = gpr_avl_add(avl, box(450), box(1275)); + avl = remove_int(avl, 265); + avl = remove_int(avl, 8); + avl = remove_int(avl, 383); + avl = gpr_avl_add(avl, box(238), box(1279)); + avl = remove_int(avl, 241); + avl = gpr_avl_add(avl, box(180), box(1281)); + avl = gpr_avl_add(avl, box(411), box(1282)); + avl = gpr_avl_add(avl, box(791), box(1283)); + avl = gpr_avl_add(avl, box(955), box(1284)); + avl = remove_int(avl, 24); + avl = remove_int(avl, 375); + avl = gpr_avl_add(avl, box(140), box(1287)); + avl = remove_int(avl, 949); + avl = gpr_avl_add(avl, box(301), box(1289)); + avl = gpr_avl_add(avl, box(0), box(1290)); + avl = remove_int(avl, 371); + avl = remove_int(avl, 427); + avl = remove_int(avl, 841); + avl = remove_int(avl, 847); + avl = gpr_avl_add(avl, box(814), box(1295)); + avl = gpr_avl_add(avl, box(127), box(1296)); + avl = gpr_avl_add(avl, box(279), box(1297)); + avl = remove_int(avl, 669); + avl = remove_int(avl, 541); + avl = remove_int(avl, 275); + avl = remove_int(avl, 299); + avl = remove_int(avl, 552); + avl = gpr_avl_add(avl, box(310), box(1303)); + avl = gpr_avl_add(avl, box(304), box(1304)); + avl = gpr_avl_add(avl, box(1), box(1305)); + avl = gpr_avl_add(avl, box(339), box(1306)); + avl = remove_int(avl, 570); + avl = remove_int(avl, 752); + avl = remove_int(avl, 552); + avl = remove_int(avl, 442); + avl = remove_int(avl, 639); + avl = gpr_avl_add(avl, box(313), box(1312)); + avl = remove_int(avl, 85); + avl = gpr_avl_add(avl, box(964), box(1314)); + avl = gpr_avl_add(avl, box(559), box(1315)); + avl = remove_int(avl, 167); + avl = gpr_avl_add(avl, box(866), box(1317)); + avl = remove_int(avl, 275); + avl = gpr_avl_add(avl, box(173), box(1319)); + avl = gpr_avl_add(avl, box(765), box(1320)); + avl = remove_int(avl, 883); + avl = gpr_avl_add(avl, box(547), box(1322)); + avl = gpr_avl_add(avl, box(847), box(1323)); + avl = remove_int(avl, 817); + avl = remove_int(avl, 850); + avl = remove_int(avl, 718); + avl = gpr_avl_add(avl, box(806), box(1327)); + avl = gpr_avl_add(avl, box(360), box(1328)); + avl = remove_int(avl, 991); + avl = gpr_avl_add(avl, box(493), box(1330)); + avl = remove_int(avl, 516); + avl = gpr_avl_add(avl, box(361), box(1332)); + avl = remove_int(avl, 355); + avl = gpr_avl_add(avl, box(512), box(1334)); + avl = gpr_avl_add(avl, box(191), box(1335)); + avl = remove_int(avl, 703); + avl = gpr_avl_add(avl, box(333), box(1337)); + avl = remove_int(avl, 481); + avl = gpr_avl_add(avl, box(501), box(1339)); + avl = remove_int(avl, 532); + avl = remove_int(avl, 510); + avl = gpr_avl_add(avl, box(793), box(1342)); + avl = gpr_avl_add(avl, box(234), box(1343)); + avl = remove_int(avl, 159); + avl = remove_int(avl, 429); + avl = remove_int(avl, 728); + avl = remove_int(avl, 288); + avl = gpr_avl_add(avl, box(281), box(1348)); + avl = gpr_avl_add(avl, box(702), box(1349)); + avl = gpr_avl_add(avl, box(149), box(1350)); + avl = remove_int(avl, 22); + avl = remove_int(avl, 944); + avl = remove_int(avl, 55); + avl = remove_int(avl, 512); + avl = remove_int(avl, 676); + avl = remove_int(avl, 884); + avl = gpr_avl_add(avl, box(246), box(1357)); + avl = gpr_avl_add(avl, box(455), box(1358)); + avl = remove_int(avl, 782); + avl = remove_int(avl, 682); + avl = gpr_avl_add(avl, box(243), box(1361)); + avl = gpr_avl_add(avl, box(109), box(1362)); + avl = gpr_avl_add(avl, box(452), box(1363)); + avl = remove_int(avl, 151); + avl = gpr_avl_add(avl, box(159), box(1365)); + avl = remove_int(avl, 1023); + avl = gpr_avl_add(avl, box(129), box(1367)); + avl = gpr_avl_add(avl, box(537), box(1368)); + avl = remove_int(avl, 321); + avl = gpr_avl_add(avl, box(740), box(1370)); + avl = remove_int(avl, 45); + avl = remove_int(avl, 136); + avl = gpr_avl_add(avl, box(229), box(1373)); + avl = remove_int(avl, 772); + avl = gpr_avl_add(avl, box(181), box(1375)); + avl = remove_int(avl, 175); + avl = gpr_avl_add(avl, box(817), box(1377)); + avl = remove_int(avl, 956); + avl = gpr_avl_add(avl, box(675), box(1379)); + avl = gpr_avl_add(avl, box(375), box(1380)); + avl = remove_int(avl, 384); + avl = gpr_avl_add(avl, box(1016), box(1382)); + avl = remove_int(avl, 295); + avl = remove_int(avl, 697); + avl = remove_int(avl, 554); + avl = remove_int(avl, 590); + avl = remove_int(avl, 1014); + avl = gpr_avl_add(avl, box(890), box(1388)); + avl = gpr_avl_add(avl, box(293), box(1389)); + avl = remove_int(avl, 207); + avl = remove_int(avl, 46); + avl = gpr_avl_add(avl, box(899), box(1392)); + avl = gpr_avl_add(avl, box(666), box(1393)); + avl = gpr_avl_add(avl, box(85), box(1394)); + avl = gpr_avl_add(avl, box(914), box(1395)); + avl = gpr_avl_add(avl, box(128), box(1396)); + avl = gpr_avl_add(avl, box(835), box(1397)); + avl = gpr_avl_add(avl, box(787), box(1398)); + avl = gpr_avl_add(avl, box(649), box(1399)); + avl = gpr_avl_add(avl, box(723), box(1400)); + avl = remove_int(avl, 874); + avl = gpr_avl_add(avl, box(778), box(1402)); + avl = gpr_avl_add(avl, box(1015), box(1403)); + avl = gpr_avl_add(avl, box(59), box(1404)); + avl = gpr_avl_add(avl, box(259), box(1405)); + avl = gpr_avl_add(avl, box(758), box(1406)); + avl = remove_int(avl, 648); + avl = gpr_avl_add(avl, box(145), box(1408)); + avl = gpr_avl_add(avl, box(440), box(1409)); + avl = remove_int(avl, 608); + avl = remove_int(avl, 690); + avl = gpr_avl_add(avl, box(605), box(1412)); + avl = remove_int(avl, 856); + avl = remove_int(avl, 608); + avl = gpr_avl_add(avl, box(829), box(1415)); + avl = gpr_avl_add(avl, box(660), box(1416)); + avl = remove_int(avl, 596); + avl = gpr_avl_add(avl, box(519), box(1418)); + avl = gpr_avl_add(avl, box(35), box(1419)); + avl = gpr_avl_add(avl, box(871), box(1420)); + avl = remove_int(avl, 845); + avl = gpr_avl_add(avl, box(600), box(1422)); + avl = gpr_avl_add(avl, box(215), box(1423)); + avl = remove_int(avl, 761); + avl = gpr_avl_add(avl, box(975), box(1425)); + avl = remove_int(avl, 987); + avl = gpr_avl_add(avl, box(58), box(1427)); + avl = remove_int(avl, 119); + avl = gpr_avl_add(avl, box(937), box(1429)); + avl = gpr_avl_add(avl, box(372), box(1430)); + avl = gpr_avl_add(avl, box(11), box(1431)); + avl = gpr_avl_add(avl, box(398), box(1432)); + avl = gpr_avl_add(avl, box(423), box(1433)); + avl = remove_int(avl, 171); + avl = gpr_avl_add(avl, box(473), box(1435)); + avl = remove_int(avl, 752); + avl = remove_int(avl, 625); + avl = remove_int(avl, 764); + avl = remove_int(avl, 49); + avl = gpr_avl_add(avl, box(472), box(1440)); + avl = remove_int(avl, 847); + avl = remove_int(avl, 642); + avl = remove_int(avl, 1004); + avl = remove_int(avl, 795); + avl = remove_int(avl, 465); + avl = gpr_avl_add(avl, box(636), box(1446)); + avl = remove_int(avl, 152); + avl = gpr_avl_add(avl, box(61), box(1448)); + avl = remove_int(avl, 929); + avl = remove_int(avl, 9); + avl = gpr_avl_add(avl, box(251), box(1451)); + avl = gpr_avl_add(avl, box(672), box(1452)); + avl = gpr_avl_add(avl, box(66), box(1453)); + avl = remove_int(avl, 693); + avl = remove_int(avl, 914); + avl = remove_int(avl, 116); + avl = remove_int(avl, 577); + avl = gpr_avl_add(avl, box(618), box(1458)); + avl = gpr_avl_add(avl, box(495), box(1459)); + avl = remove_int(avl, 450); + avl = gpr_avl_add(avl, box(533), box(1461)); + avl = gpr_avl_add(avl, box(414), box(1462)); + avl = remove_int(avl, 74); + avl = remove_int(avl, 236); + avl = gpr_avl_add(avl, box(707), box(1465)); + avl = gpr_avl_add(avl, box(357), box(1466)); + avl = gpr_avl_add(avl, box(1007), box(1467)); + avl = gpr_avl_add(avl, box(811), box(1468)); + avl = gpr_avl_add(avl, box(418), box(1469)); + avl = gpr_avl_add(avl, box(164), box(1470)); + avl = gpr_avl_add(avl, box(622), box(1471)); + avl = remove_int(avl, 22); + avl = remove_int(avl, 14); + avl = remove_int(avl, 732); + avl = remove_int(avl, 7); + avl = remove_int(avl, 447); + avl = gpr_avl_add(avl, box(221), box(1477)); + avl = gpr_avl_add(avl, box(202), box(1478)); + avl = gpr_avl_add(avl, box(312), box(1479)); + avl = remove_int(avl, 274); + avl = gpr_avl_add(avl, box(684), box(1481)); + avl = gpr_avl_add(avl, box(954), box(1482)); + avl = gpr_avl_add(avl, box(637), box(1483)); + avl = remove_int(avl, 716); + avl = gpr_avl_add(avl, box(198), box(1485)); + avl = remove_int(avl, 340); + avl = remove_int(avl, 137); + avl = remove_int(avl, 995); + avl = remove_int(avl, 1004); + avl = gpr_avl_add(avl, box(661), box(1490)); + avl = gpr_avl_add(avl, box(862), box(1491)); + avl = remove_int(avl, 527); + avl = gpr_avl_add(avl, box(945), box(1493)); + avl = remove_int(avl, 355); + avl = remove_int(avl, 144); + avl = gpr_avl_add(avl, box(229), box(1496)); + avl = gpr_avl_add(avl, box(237), box(1497)); + avl = remove_int(avl, 471); + avl = remove_int(avl, 901); + avl = gpr_avl_add(avl, box(905), box(1500)); + avl = remove_int(avl, 19); + avl = remove_int(avl, 896); + avl = remove_int(avl, 585); + avl = remove_int(avl, 308); + avl = gpr_avl_add(avl, box(547), box(1505)); + avl = gpr_avl_add(avl, box(552), box(1506)); + avl = gpr_avl_add(avl, box(30), box(1507)); + avl = gpr_avl_add(avl, box(445), box(1508)); + avl = remove_int(avl, 785); + avl = remove_int(avl, 185); + avl = gpr_avl_add(avl, box(405), box(1511)); + avl = gpr_avl_add(avl, box(733), box(1512)); + avl = gpr_avl_add(avl, box(573), box(1513)); + avl = gpr_avl_add(avl, box(492), box(1514)); + avl = gpr_avl_add(avl, box(343), box(1515)); + avl = gpr_avl_add(avl, box(527), box(1516)); + avl = gpr_avl_add(avl, box(596), box(1517)); + avl = gpr_avl_add(avl, box(519), box(1518)); + avl = remove_int(avl, 243); + avl = remove_int(avl, 722); + avl = gpr_avl_add(avl, box(772), box(1521)); + avl = remove_int(avl, 152); + avl = remove_int(avl, 305); + avl = gpr_avl_add(avl, box(754), box(1524)); + avl = gpr_avl_add(avl, box(373), box(1525)); + avl = remove_int(avl, 995); + avl = gpr_avl_add(avl, box(329), box(1527)); + avl = remove_int(avl, 397); + avl = gpr_avl_add(avl, box(884), box(1529)); + avl = remove_int(avl, 329); + avl = remove_int(avl, 240); + avl = gpr_avl_add(avl, box(566), box(1532)); + avl = gpr_avl_add(avl, box(232), box(1533)); + avl = remove_int(avl, 993); + avl = gpr_avl_add(avl, box(888), box(1535)); + avl = remove_int(avl, 242); + avl = gpr_avl_add(avl, box(941), box(1537)); + avl = remove_int(avl, 415); + avl = gpr_avl_add(avl, box(992), box(1539)); + avl = remove_int(avl, 289); + avl = gpr_avl_add(avl, box(60), box(1541)); + avl = gpr_avl_add(avl, box(97), box(1542)); + avl = remove_int(avl, 965); + avl = remove_int(avl, 267); + avl = remove_int(avl, 360); + avl = gpr_avl_add(avl, box(5), box(1546)); + avl = remove_int(avl, 429); + avl = gpr_avl_add(avl, box(412), box(1548)); + avl = remove_int(avl, 632); + avl = remove_int(avl, 113); + avl = gpr_avl_add(avl, box(48), box(1551)); + avl = gpr_avl_add(avl, box(108), box(1552)); + avl = gpr_avl_add(avl, box(750), box(1553)); + avl = remove_int(avl, 188); + avl = gpr_avl_add(avl, box(668), box(1555)); + avl = remove_int(avl, 37); + avl = remove_int(avl, 737); + avl = gpr_avl_add(avl, box(93), box(1558)); + avl = gpr_avl_add(avl, box(628), box(1559)); + avl = gpr_avl_add(avl, box(480), box(1560)); + avl = remove_int(avl, 958); + avl = remove_int(avl, 565); + avl = remove_int(avl, 32); + avl = remove_int(avl, 1); + avl = remove_int(avl, 335); + avl = gpr_avl_add(avl, box(136), box(1566)); + avl = gpr_avl_add(avl, box(469), box(1567)); + avl = remove_int(avl, 349); + avl = gpr_avl_add(avl, box(768), box(1569)); + avl = gpr_avl_add(avl, box(915), box(1570)); + avl = remove_int(avl, 1014); + avl = gpr_avl_add(avl, box(117), box(1572)); + avl = remove_int(avl, 62); + avl = gpr_avl_add(avl, box(382), box(1574)); + avl = remove_int(avl, 571); + avl = gpr_avl_add(avl, box(655), box(1576)); + avl = gpr_avl_add(avl, box(323), box(1577)); + avl = remove_int(avl, 869); + avl = remove_int(avl, 151); + avl = gpr_avl_add(avl, box(1019), box(1580)); + avl = gpr_avl_add(avl, box(984), box(1581)); + avl = gpr_avl_add(avl, box(870), box(1582)); + avl = gpr_avl_add(avl, box(376), box(1583)); + avl = remove_int(avl, 625); + avl = gpr_avl_add(avl, box(733), box(1585)); + avl = remove_int(avl, 532); + avl = remove_int(avl, 444); + avl = gpr_avl_add(avl, box(428), box(1588)); + avl = gpr_avl_add(avl, box(860), box(1589)); + avl = gpr_avl_add(avl, box(173), box(1590)); + avl = remove_int(avl, 649); + avl = remove_int(avl, 913); + avl = remove_int(avl, 1); + avl = remove_int(avl, 304); + avl = gpr_avl_add(avl, box(604), box(1595)); + avl = gpr_avl_add(avl, box(639), box(1596)); + avl = remove_int(avl, 431); + avl = gpr_avl_add(avl, box(993), box(1598)); + avl = remove_int(avl, 681); + avl = remove_int(avl, 927); + avl = gpr_avl_add(avl, box(87), box(1601)); + avl = gpr_avl_add(avl, box(91), box(1602)); + avl = remove_int(avl, 61); + avl = remove_int(avl, 14); + avl = remove_int(avl, 305); + avl = remove_int(avl, 304); + avl = remove_int(avl, 1016); + avl = gpr_avl_add(avl, box(903), box(1608)); + avl = gpr_avl_add(avl, box(951), box(1609)); + avl = gpr_avl_add(avl, box(146), box(1610)); + avl = gpr_avl_add(avl, box(482), box(1611)); + avl = gpr_avl_add(avl, box(71), box(1612)); + avl = remove_int(avl, 246); + avl = remove_int(avl, 696); + avl = gpr_avl_add(avl, box(636), box(1615)); + avl = gpr_avl_add(avl, box(295), box(1616)); + avl = remove_int(avl, 11); + avl = remove_int(avl, 231); + avl = gpr_avl_add(avl, box(905), box(1619)); + avl = gpr_avl_add(avl, box(993), box(1620)); + avl = gpr_avl_add(avl, box(433), box(1621)); + avl = gpr_avl_add(avl, box(117), box(1622)); + avl = gpr_avl_add(avl, box(467), box(1623)); + avl = remove_int(avl, 419); + avl = gpr_avl_add(avl, box(179), box(1625)); + avl = remove_int(avl, 926); + avl = remove_int(avl, 326); + avl = gpr_avl_add(avl, box(551), box(1628)); + avl = remove_int(avl, 14); + avl = remove_int(avl, 476); + avl = remove_int(avl, 823); + avl = gpr_avl_add(avl, box(350), box(1632)); + avl = gpr_avl_add(avl, box(133), box(1633)); + avl = remove_int(avl, 906); + avl = gpr_avl_add(avl, box(827), box(1635)); + avl = gpr_avl_add(avl, box(201), box(1636)); + avl = remove_int(avl, 124); + avl = remove_int(avl, 662); + avl = gpr_avl_add(avl, box(314), box(1639)); + avl = gpr_avl_add(avl, box(986), box(1640)); + avl = gpr_avl_add(avl, box(622), box(1641)); + avl = remove_int(avl, 130); + avl = gpr_avl_add(avl, box(861), box(1643)); + avl = remove_int(avl, 497); + avl = remove_int(avl, 905); + avl = gpr_avl_add(avl, box(502), box(1646)); + avl = remove_int(avl, 721); + avl = gpr_avl_add(avl, box(514), box(1648)); + avl = gpr_avl_add(avl, box(410), box(1649)); + avl = remove_int(avl, 869); + avl = remove_int(avl, 247); + avl = gpr_avl_add(avl, box(450), box(1652)); + avl = remove_int(avl, 364); + avl = gpr_avl_add(avl, box(963), box(1654)); + avl = gpr_avl_add(avl, box(146), box(1655)); + avl = remove_int(avl, 147); + avl = remove_int(avl, 789); + avl = gpr_avl_add(avl, box(693), box(1658)); + avl = gpr_avl_add(avl, box(959), box(1659)); + avl = remove_int(avl, 478); + avl = gpr_avl_add(avl, box(116), box(1661)); + avl = gpr_avl_add(avl, box(520), box(1662)); + avl = gpr_avl_add(avl, box(809), box(1663)); + avl = gpr_avl_add(avl, box(667), box(1664)); + avl = gpr_avl_add(avl, box(406), box(1665)); + avl = remove_int(avl, 409); + avl = gpr_avl_add(avl, box(558), box(1667)); + avl = gpr_avl_add(avl, box(0), box(1668)); + avl = gpr_avl_add(avl, box(948), box(1669)); + avl = gpr_avl_add(avl, box(576), box(1670)); + avl = remove_int(avl, 864); + avl = remove_int(avl, 840); + avl = remove_int(avl, 1001); + avl = gpr_avl_add(avl, box(232), box(1674)); + avl = remove_int(avl, 676); + avl = remove_int(avl, 752); + avl = remove_int(avl, 667); + avl = remove_int(avl, 605); + avl = gpr_avl_add(avl, box(258), box(1679)); + avl = gpr_avl_add(avl, box(648), box(1680)); + avl = gpr_avl_add(avl, box(761), box(1681)); + avl = remove_int(avl, 293); + avl = remove_int(avl, 893); + avl = gpr_avl_add(avl, box(194), box(1684)); + avl = remove_int(avl, 233); + avl = gpr_avl_add(avl, box(888), box(1686)); + avl = remove_int(avl, 470); + avl = remove_int(avl, 703); + avl = remove_int(avl, 190); + avl = remove_int(avl, 359); + avl = gpr_avl_add(avl, box(621), box(1691)); + avl = remove_int(avl, 634); + avl = remove_int(avl, 335); + avl = gpr_avl_add(avl, box(718), box(1694)); + avl = gpr_avl_add(avl, box(463), box(1695)); + avl = gpr_avl_add(avl, box(233), box(1696)); + avl = remove_int(avl, 376); + avl = remove_int(avl, 496); + avl = remove_int(avl, 819); + avl = remove_int(avl, 38); + avl = remove_int(avl, 436); + avl = remove_int(avl, 102); + avl = gpr_avl_add(avl, box(607), box(1703)); + avl = remove_int(avl, 329); + avl = gpr_avl_add(avl, box(716), box(1705)); + avl = remove_int(avl, 639); + avl = remove_int(avl, 775); + avl = remove_int(avl, 578); + avl = remove_int(avl, 464); + avl = remove_int(avl, 679); + avl = remove_int(avl, 615); + avl = remove_int(avl, 104); + avl = gpr_avl_add(avl, box(414), box(1713)); + avl = gpr_avl_add(avl, box(212), box(1714)); + avl = gpr_avl_add(avl, box(266), box(1715)); + avl = gpr_avl_add(avl, box(238), box(1716)); + avl = remove_int(avl, 153); + avl = gpr_avl_add(avl, box(585), box(1718)); + avl = remove_int(avl, 121); + avl = gpr_avl_add(avl, box(534), box(1720)); + avl = remove_int(avl, 579); + avl = gpr_avl_add(avl, box(127), box(1722)); + avl = gpr_avl_add(avl, box(399), box(1723)); + avl = remove_int(avl, 417); + avl = gpr_avl_add(avl, box(978), box(1725)); + avl = gpr_avl_add(avl, box(768), box(1726)); + avl = remove_int(avl, 985); + avl = gpr_avl_add(avl, box(536), box(1728)); + avl = gpr_avl_add(avl, box(449), box(1729)); + avl = gpr_avl_add(avl, box(586), box(1730)); + avl = remove_int(avl, 998); + avl = remove_int(avl, 394); + avl = remove_int(avl, 141); + avl = gpr_avl_add(avl, box(889), box(1734)); + avl = gpr_avl_add(avl, box(871), box(1735)); + avl = gpr_avl_add(avl, box(76), box(1736)); + avl = gpr_avl_add(avl, box(549), box(1737)); + avl = gpr_avl_add(avl, box(757), box(1738)); + avl = remove_int(avl, 908); + avl = gpr_avl_add(avl, box(789), box(1740)); + avl = remove_int(avl, 224); + avl = gpr_avl_add(avl, box(407), box(1742)); + avl = gpr_avl_add(avl, box(381), box(1743)); + avl = gpr_avl_add(avl, box(561), box(1744)); + avl = gpr_avl_add(avl, box(667), box(1745)); + avl = gpr_avl_add(avl, box(522), box(1746)); + avl = gpr_avl_add(avl, box(948), box(1747)); + avl = remove_int(avl, 770); + avl = gpr_avl_add(avl, box(872), box(1749)); + avl = gpr_avl_add(avl, box(327), box(1750)); + avl = remove_int(avl, 10); + avl = gpr_avl_add(avl, box(122), box(1752)); + avl = remove_int(avl, 606); + avl = gpr_avl_add(avl, box(485), box(1754)); + avl = remove_int(avl, 6); + avl = gpr_avl_add(avl, box(329), box(1756)); + avl = gpr_avl_add(avl, box(783), box(1757)); + avl = remove_int(avl, 416); + avl = gpr_avl_add(avl, box(656), box(1759)); + avl = gpr_avl_add(avl, box(971), box(1760)); + avl = gpr_avl_add(avl, box(77), box(1761)); + avl = gpr_avl_add(avl, box(942), box(1762)); + avl = remove_int(avl, 361); + avl = gpr_avl_add(avl, box(66), box(1764)); + avl = gpr_avl_add(avl, box(299), box(1765)); + avl = gpr_avl_add(avl, box(929), box(1766)); + avl = gpr_avl_add(avl, box(797), box(1767)); + avl = remove_int(avl, 869); + avl = remove_int(avl, 907); + avl = gpr_avl_add(avl, box(870), box(1770)); + avl = remove_int(avl, 580); + avl = remove_int(avl, 120); + avl = gpr_avl_add(avl, box(913), box(1773)); + avl = remove_int(avl, 480); + avl = gpr_avl_add(avl, box(489), box(1775)); + avl = remove_int(avl, 845); + avl = gpr_avl_add(avl, box(896), box(1777)); + avl = remove_int(avl, 567); + avl = remove_int(avl, 427); + avl = gpr_avl_add(avl, box(443), box(1780)); + avl = gpr_avl_add(avl, box(3), box(1781)); + avl = remove_int(avl, 12); + avl = gpr_avl_add(avl, box(376), box(1783)); + avl = gpr_avl_add(avl, box(155), box(1784)); + avl = gpr_avl_add(avl, box(188), box(1785)); + avl = gpr_avl_add(avl, box(149), box(1786)); + avl = gpr_avl_add(avl, box(178), box(1787)); + avl = remove_int(avl, 84); + avl = gpr_avl_add(avl, box(805), box(1789)); + avl = gpr_avl_add(avl, box(612), box(1790)); + avl = remove_int(avl, 991); + avl = gpr_avl_add(avl, box(837), box(1792)); + avl = remove_int(avl, 173); + avl = remove_int(avl, 72); + avl = gpr_avl_add(avl, box(1014), box(1795)); + avl = remove_int(avl, 303); + avl = gpr_avl_add(avl, box(865), box(1797)); + avl = gpr_avl_add(avl, box(793), box(1798)); + avl = remove_int(avl, 173); + avl = remove_int(avl, 477); + avl = gpr_avl_add(avl, box(950), box(1801)); + avl = gpr_avl_add(avl, box(105), box(1802)); + avl = gpr_avl_add(avl, box(895), box(1803)); + avl = gpr_avl_add(avl, box(171), box(1804)); + avl = gpr_avl_add(avl, box(753), box(1805)); + avl = gpr_avl_add(avl, box(946), box(1806)); + avl = remove_int(avl, 194); + avl = remove_int(avl, 559); + avl = remove_int(avl, 116); + avl = gpr_avl_add(avl, box(968), box(1810)); + avl = remove_int(avl, 124); + avl = remove_int(avl, 99); + avl = gpr_avl_add(avl, box(563), box(1813)); + avl = remove_int(avl, 182); + avl = gpr_avl_add(avl, box(816), box(1815)); + avl = remove_int(avl, 73); + avl = remove_int(avl, 261); + avl = gpr_avl_add(avl, box(847), box(1818)); + avl = gpr_avl_add(avl, box(368), box(1819)); + avl = gpr_avl_add(avl, box(808), box(1820)); + avl = gpr_avl_add(avl, box(779), box(1821)); + avl = remove_int(avl, 818); + avl = gpr_avl_add(avl, box(466), box(1823)); + avl = remove_int(avl, 316); + avl = gpr_avl_add(avl, box(986), box(1825)); + avl = gpr_avl_add(avl, box(688), box(1826)); + avl = gpr_avl_add(avl, box(509), box(1827)); + avl = gpr_avl_add(avl, box(51), box(1828)); + avl = remove_int(avl, 655); + avl = remove_int(avl, 785); + avl = remove_int(avl, 893); + avl = gpr_avl_add(avl, box(167), box(1832)); + avl = remove_int(avl, 13); + avl = remove_int(avl, 263); + avl = gpr_avl_add(avl, box(1009), box(1835)); + avl = remove_int(avl, 480); + avl = remove_int(avl, 778); + avl = remove_int(avl, 713); + avl = remove_int(avl, 628); + avl = gpr_avl_add(avl, box(803), box(1840)); + avl = remove_int(avl, 267); + avl = gpr_avl_add(avl, box(676), box(1842)); + avl = gpr_avl_add(avl, box(231), box(1843)); + avl = gpr_avl_add(avl, box(824), box(1844)); + avl = remove_int(avl, 961); + avl = gpr_avl_add(avl, box(311), box(1846)); + avl = gpr_avl_add(avl, box(420), box(1847)); + avl = gpr_avl_add(avl, box(960), box(1848)); + avl = gpr_avl_add(avl, box(468), box(1849)); + avl = gpr_avl_add(avl, box(815), box(1850)); + avl = remove_int(avl, 247); + avl = remove_int(avl, 194); + avl = gpr_avl_add(avl, box(546), box(1853)); + avl = remove_int(avl, 222); + avl = remove_int(avl, 914); + avl = remove_int(avl, 741); + avl = gpr_avl_add(avl, box(470), box(1857)); + avl = gpr_avl_add(avl, box(933), box(1858)); + avl = gpr_avl_add(avl, box(97), box(1859)); + avl = remove_int(avl, 564); + avl = remove_int(avl, 295); + avl = gpr_avl_add(avl, box(864), box(1862)); + avl = remove_int(avl, 329); + avl = gpr_avl_add(avl, box(124), box(1864)); + avl = gpr_avl_add(avl, box(1000), box(1865)); + avl = gpr_avl_add(avl, box(228), box(1866)); + avl = gpr_avl_add(avl, box(187), box(1867)); + avl = remove_int(avl, 224); + avl = remove_int(avl, 306); + avl = remove_int(avl, 884); + avl = gpr_avl_add(avl, box(449), box(1871)); + avl = gpr_avl_add(avl, box(353), box(1872)); + avl = gpr_avl_add(avl, box(994), box(1873)); + avl = gpr_avl_add(avl, box(596), box(1874)); + avl = gpr_avl_add(avl, box(996), box(1875)); + avl = gpr_avl_add(avl, box(101), box(1876)); + avl = gpr_avl_add(avl, box(1012), box(1877)); + avl = gpr_avl_add(avl, box(982), box(1878)); + avl = gpr_avl_add(avl, box(742), box(1879)); + avl = remove_int(avl, 92); + avl = remove_int(avl, 1022); + avl = gpr_avl_add(avl, box(941), box(1882)); + avl = remove_int(avl, 742); + avl = remove_int(avl, 919); + avl = gpr_avl_add(avl, box(588), box(1885)); + avl = remove_int(avl, 221); + avl = gpr_avl_add(avl, box(356), box(1887)); + avl = gpr_avl_add(avl, box(932), box(1888)); + avl = remove_int(avl, 837); + avl = gpr_avl_add(avl, box(394), box(1890)); + avl = gpr_avl_add(avl, box(642), box(1891)); + avl = gpr_avl_add(avl, box(52), box(1892)); + avl = gpr_avl_add(avl, box(437), box(1893)); + avl = gpr_avl_add(avl, box(948), box(1894)); + avl = gpr_avl_add(avl, box(93), box(1895)); + avl = remove_int(avl, 873); + avl = remove_int(avl, 336); + avl = remove_int(avl, 277); + avl = remove_int(avl, 932); + avl = gpr_avl_add(avl, box(80), box(1900)); + avl = gpr_avl_add(avl, box(952), box(1901)); + avl = gpr_avl_add(avl, box(510), box(1902)); + avl = remove_int(avl, 876); + avl = remove_int(avl, 612); + avl = gpr_avl_add(avl, box(923), box(1905)); + avl = gpr_avl_add(avl, box(475), box(1906)); + avl = remove_int(avl, 478); + avl = remove_int(avl, 148); + avl = gpr_avl_add(avl, box(538), box(1909)); + avl = remove_int(avl, 47); + avl = gpr_avl_add(avl, box(89), box(1911)); + avl = remove_int(avl, 723); + avl = gpr_avl_add(avl, box(687), box(1913)); + avl = gpr_avl_add(avl, box(480), box(1914)); + avl = gpr_avl_add(avl, box(149), box(1915)); + avl = remove_int(avl, 68); + avl = remove_int(avl, 862); + avl = remove_int(avl, 363); + avl = gpr_avl_add(avl, box(996), box(1919)); + avl = remove_int(avl, 380); + avl = gpr_avl_add(avl, box(957), box(1921)); + avl = remove_int(avl, 413); + avl = gpr_avl_add(avl, box(360), box(1923)); + avl = gpr_avl_add(avl, box(304), box(1924)); + avl = gpr_avl_add(avl, box(634), box(1925)); + avl = gpr_avl_add(avl, box(506), box(1926)); + avl = remove_int(avl, 248); + avl = gpr_avl_add(avl, box(124), box(1928)); + avl = gpr_avl_add(avl, box(181), box(1929)); + avl = remove_int(avl, 507); + avl = gpr_avl_add(avl, box(141), box(1931)); + avl = remove_int(avl, 409); + avl = remove_int(avl, 129); + avl = remove_int(avl, 694); + avl = remove_int(avl, 723); + avl = gpr_avl_add(avl, box(998), box(1936)); + avl = gpr_avl_add(avl, box(906), box(1937)); + avl = gpr_avl_add(avl, box(44), box(1938)); + avl = remove_int(avl, 949); + avl = remove_int(avl, 117); + avl = gpr_avl_add(avl, box(700), box(1941)); + avl = gpr_avl_add(avl, box(258), box(1942)); + avl = remove_int(avl, 828); + avl = gpr_avl_add(avl, box(860), box(1944)); + avl = gpr_avl_add(avl, box(987), box(1945)); + avl = gpr_avl_add(avl, box(316), box(1946)); + avl = gpr_avl_add(avl, box(919), box(1947)); + avl = remove_int(avl, 84); + avl = gpr_avl_add(avl, box(473), box(1949)); + avl = remove_int(avl, 127); + avl = remove_int(avl, 829); + avl = remove_int(avl, 829); + avl = gpr_avl_add(avl, box(488), box(1953)); + avl = gpr_avl_add(avl, box(954), box(1954)); + avl = remove_int(avl, 198); + avl = remove_int(avl, 972); + avl = remove_int(avl, 670); + avl = gpr_avl_add(avl, box(822), box(1958)); + avl = remove_int(avl, 589); + avl = remove_int(avl, 459); + avl = gpr_avl_add(avl, box(1003), box(1961)); + avl = gpr_avl_add(avl, box(657), box(1962)); + avl = gpr_avl_add(avl, box(477), box(1963)); + avl = gpr_avl_add(avl, box(923), box(1964)); + avl = remove_int(avl, 496); + avl = remove_int(avl, 99); + avl = gpr_avl_add(avl, box(127), box(1967)); + avl = gpr_avl_add(avl, box(1013), box(1968)); + avl = gpr_avl_add(avl, box(778), box(1969)); + avl = remove_int(avl, 5); + avl = remove_int(avl, 990); + avl = remove_int(avl, 850); + avl = remove_int(avl, 160); + avl = remove_int(avl, 86); + avl = gpr_avl_add(avl, box(283), box(1975)); + avl = remove_int(avl, 278); + avl = remove_int(avl, 297); + avl = remove_int(avl, 137); + avl = remove_int(avl, 653); + avl = gpr_avl_add(avl, box(702), box(1980)); + avl = remove_int(avl, 63); + avl = remove_int(avl, 427); + avl = remove_int(avl, 706); + avl = remove_int(avl, 806); + avl = gpr_avl_add(avl, box(335), box(1985)); + avl = gpr_avl_add(avl, box(412), box(1986)); + avl = remove_int(avl, 766); + avl = remove_int(avl, 937); + avl = remove_int(avl, 886); + avl = remove_int(avl, 652); + avl = gpr_avl_add(avl, box(545), box(1991)); + avl = gpr_avl_add(avl, box(408), box(1992)); + avl = gpr_avl_add(avl, box(841), box(1993)); + avl = remove_int(avl, 593); + avl = gpr_avl_add(avl, box(582), box(1995)); + avl = gpr_avl_add(avl, box(597), box(1996)); + avl = remove_int(avl, 49); + avl = remove_int(avl, 835); + avl = gpr_avl_add(avl, box(417), box(1999)); + avl = gpr_avl_add(avl, box(191), box(2000)); + avl = remove_int(avl, 406); + avl = gpr_avl_add(avl, box(30), box(2002)); + avl = remove_int(avl, 841); + avl = remove_int(avl, 50); + avl = gpr_avl_add(avl, box(967), box(2005)); + avl = gpr_avl_add(avl, box(849), box(2006)); + avl = remove_int(avl, 608); + avl = gpr_avl_add(avl, box(306), box(2008)); + avl = remove_int(avl, 779); + avl = gpr_avl_add(avl, box(897), box(2010)); + avl = gpr_avl_add(avl, box(147), box(2011)); + avl = remove_int(avl, 982); + avl = gpr_avl_add(avl, box(470), box(2013)); + avl = remove_int(avl, 951); + avl = gpr_avl_add(avl, box(388), box(2015)); + avl = remove_int(avl, 616); + avl = remove_int(avl, 721); + avl = remove_int(avl, 942); + avl = remove_int(avl, 589); + avl = gpr_avl_add(avl, box(218), box(2020)); + avl = remove_int(avl, 671); + avl = gpr_avl_add(avl, box(1020), box(2022)); + avl = remove_int(avl, 277); + avl = gpr_avl_add(avl, box(681), box(2024)); + avl = gpr_avl_add(avl, box(179), box(2025)); + avl = gpr_avl_add(avl, box(370), box(2026)); + avl = gpr_avl_add(avl, box(0), box(2027)); + avl = remove_int(avl, 523); + avl = gpr_avl_add(avl, box(99), box(2029)); + avl = gpr_avl_add(avl, box(334), box(2030)); + avl = gpr_avl_add(avl, box(569), box(2031)); + avl = gpr_avl_add(avl, box(257), box(2032)); + avl = remove_int(avl, 572); + avl = gpr_avl_add(avl, box(805), box(2034)); + avl = gpr_avl_add(avl, box(143), box(2035)); + avl = gpr_avl_add(avl, box(670), box(2036)); + avl = remove_int(avl, 42); + avl = gpr_avl_add(avl, box(46), box(2038)); + avl = remove_int(avl, 970); + avl = gpr_avl_add(avl, box(353), box(2040)); + avl = remove_int(avl, 258); + avl = gpr_avl_add(avl, box(451), box(2042)); + avl = gpr_avl_add(avl, box(28), box(2043)); + avl = gpr_avl_add(avl, box(729), box(2044)); + avl = gpr_avl_add(avl, box(401), box(2045)); + avl = gpr_avl_add(avl, box(614), box(2046)); + avl = remove_int(avl, 990); + avl = remove_int(avl, 212); + avl = remove_int(avl, 22); + avl = remove_int(avl, 677); + avl = gpr_avl_add(avl, box(1016), box(2051)); + avl = gpr_avl_add(avl, box(980), box(2052)); + avl = gpr_avl_add(avl, box(990), box(2053)); + avl = gpr_avl_add(avl, box(355), box(2054)); + avl = remove_int(avl, 730); + avl = remove_int(avl, 37); + avl = gpr_avl_add(avl, box(407), box(2057)); + avl = gpr_avl_add(avl, box(222), box(2058)); + avl = gpr_avl_add(avl, box(439), box(2059)); + avl = gpr_avl_add(avl, box(563), box(2060)); + avl = remove_int(avl, 992); + avl = remove_int(avl, 786); + avl = gpr_avl_add(avl, box(1), box(2063)); + avl = gpr_avl_add(avl, box(473), box(2064)); + avl = gpr_avl_add(avl, box(992), box(2065)); + avl = remove_int(avl, 190); + avl = remove_int(avl, 450); + avl = remove_int(avl, 1020); + avl = remove_int(avl, 149); + avl = gpr_avl_add(avl, box(329), box(2070)); + avl = gpr_avl_add(avl, box(35), box(2071)); + avl = remove_int(avl, 843); + avl = gpr_avl_add(avl, box(855), box(2073)); + avl = remove_int(avl, 878); + avl = gpr_avl_add(avl, box(993), box(2075)); + avl = gpr_avl_add(avl, box(87), box(2076)); + avl = gpr_avl_add(avl, box(572), box(2077)); + avl = remove_int(avl, 896); + avl = gpr_avl_add(avl, box(849), box(2079)); + avl = remove_int(avl, 597); + avl = gpr_avl_add(avl, box(472), box(2081)); + avl = remove_int(avl, 778); + avl = remove_int(avl, 934); + avl = remove_int(avl, 314); + avl = gpr_avl_add(avl, box(101), box(2085)); + avl = remove_int(avl, 938); + avl = remove_int(avl, 1010); + avl = gpr_avl_add(avl, box(579), box(2088)); + avl = remove_int(avl, 798); + avl = remove_int(avl, 88); + avl = gpr_avl_add(avl, box(851), box(2091)); + avl = remove_int(avl, 705); + avl = gpr_avl_add(avl, box(26), box(2093)); + avl = remove_int(avl, 973); + avl = gpr_avl_add(avl, box(923), box(2095)); + avl = remove_int(avl, 668); + avl = gpr_avl_add(avl, box(310), box(2097)); + avl = gpr_avl_add(avl, box(269), box(2098)); + avl = remove_int(avl, 173); + avl = gpr_avl_add(avl, box(279), box(2100)); + avl = remove_int(avl, 203); + avl = gpr_avl_add(avl, box(411), box(2102)); + avl = remove_int(avl, 950); + avl = gpr_avl_add(avl, box(6), box(2104)); + avl = remove_int(avl, 400); + avl = remove_int(avl, 468); + avl = remove_int(avl, 271); + avl = gpr_avl_add(avl, box(627), box(2108)); + avl = remove_int(avl, 727); + avl = remove_int(avl, 148); + avl = remove_int(avl, 98); + avl = remove_int(avl, 997); + avl = remove_int(avl, 215); + avl = remove_int(avl, 628); + avl = remove_int(avl, 826); + avl = remove_int(avl, 664); + avl = gpr_avl_add(avl, box(76), box(2117)); + avl = remove_int(avl, 194); + avl = remove_int(avl, 18); + avl = gpr_avl_add(avl, box(727), box(2120)); + avl = remove_int(avl, 295); + avl = gpr_avl_add(avl, box(645), box(2122)); + avl = remove_int(avl, 321); + avl = remove_int(avl, 863); + avl = gpr_avl_add(avl, box(824), box(2125)); + avl = gpr_avl_add(avl, box(651), box(2126)); + avl = gpr_avl_add(avl, box(804), box(2127)); + avl = remove_int(avl, 307); + avl = gpr_avl_add(avl, box(867), box(2129)); + avl = remove_int(avl, 384); + avl = gpr_avl_add(avl, box(819), box(2131)); + avl = remove_int(avl, 674); + avl = gpr_avl_add(avl, box(76), box(2133)); + avl = remove_int(avl, 898); + avl = gpr_avl_add(avl, box(45), box(2135)); + avl = gpr_avl_add(avl, box(512), box(2136)); + avl = remove_int(avl, 773); + avl = remove_int(avl, 907); + avl = remove_int(avl, 382); + avl = remove_int(avl, 95); + avl = remove_int(avl, 734); + avl = remove_int(avl, 81); + avl = gpr_avl_add(avl, box(348), box(2143)); + avl = remove_int(avl, 509); + avl = remove_int(avl, 301); + avl = gpr_avl_add(avl, box(861), box(2146)); + avl = gpr_avl_add(avl, box(918), box(2147)); + avl = remove_int(avl, 992); + avl = gpr_avl_add(avl, box(356), box(2149)); + avl = remove_int(avl, 64); + avl = remove_int(avl, 444); + avl = remove_int(avl, 741); + avl = gpr_avl_add(avl, box(710), box(2153)); + avl = gpr_avl_add(avl, box(264), box(2154)); + avl = remove_int(avl, 347); + avl = remove_int(avl, 250); + avl = gpr_avl_add(avl, box(82), box(2157)); + avl = gpr_avl_add(avl, box(571), box(2158)); + avl = remove_int(avl, 721); + avl = remove_int(avl, 622); + avl = gpr_avl_add(avl, box(950), box(2161)); + avl = gpr_avl_add(avl, box(94), box(2162)); + avl = remove_int(avl, 970); + avl = gpr_avl_add(avl, box(815), box(2164)); + avl = remove_int(avl, 930); + avl = remove_int(avl, 703); + avl = gpr_avl_add(avl, box(432), box(2167)); + avl = remove_int(avl, 544); + avl = gpr_avl_add(avl, box(21), box(2169)); + avl = gpr_avl_add(avl, box(186), box(2170)); + avl = remove_int(avl, 143); + avl = gpr_avl_add(avl, box(425), box(2172)); + avl = remove_int(avl, 769); + avl = gpr_avl_add(avl, box(656), box(2174)); + avl = remove_int(avl, 29); + avl = gpr_avl_add(avl, box(464), box(2176)); + avl = remove_int(avl, 713); + avl = gpr_avl_add(avl, box(800), box(2178)); + avl = remove_int(avl, 621); + avl = gpr_avl_add(avl, box(962), box(2180)); + avl = remove_int(avl, 448); + avl = gpr_avl_add(avl, box(878), box(2182)); + avl = remove_int(avl, 39); + avl = remove_int(avl, 999); + avl = gpr_avl_add(avl, box(182), box(2185)); + avl = gpr_avl_add(avl, box(429), box(2186)); + avl = gpr_avl_add(avl, box(598), box(2187)); + avl = remove_int(avl, 551); + avl = gpr_avl_add(avl, box(827), box(2189)); + avl = gpr_avl_add(avl, box(809), box(2190)); + avl = remove_int(avl, 438); + avl = remove_int(avl, 811); + avl = gpr_avl_add(avl, box(808), box(2193)); + avl = gpr_avl_add(avl, box(788), box(2194)); + avl = remove_int(avl, 156); + avl = gpr_avl_add(avl, box(933), box(2196)); + avl = gpr_avl_add(avl, box(344), box(2197)); + avl = remove_int(avl, 460); + avl = gpr_avl_add(avl, box(161), box(2199)); + avl = gpr_avl_add(avl, box(444), box(2200)); + avl = remove_int(avl, 597); + avl = remove_int(avl, 668); + avl = gpr_avl_add(avl, box(703), box(2203)); + avl = remove_int(avl, 515); + avl = gpr_avl_add(avl, box(380), box(2205)); + avl = gpr_avl_add(avl, box(338), box(2206)); + avl = remove_int(avl, 550); + avl = remove_int(avl, 946); + avl = remove_int(avl, 714); + avl = remove_int(avl, 739); + avl = gpr_avl_add(avl, box(413), box(2211)); + avl = remove_int(avl, 450); + avl = gpr_avl_add(avl, box(411), box(2213)); + avl = gpr_avl_add(avl, box(117), box(2214)); + avl = gpr_avl_add(avl, box(322), box(2215)); + avl = gpr_avl_add(avl, box(915), box(2216)); + avl = gpr_avl_add(avl, box(410), box(2217)); + avl = gpr_avl_add(avl, box(66), box(2218)); + avl = remove_int(avl, 756); + avl = remove_int(avl, 596); + avl = gpr_avl_add(avl, box(882), box(2221)); + avl = gpr_avl_add(avl, box(930), box(2222)); + avl = gpr_avl_add(avl, box(36), box(2223)); + avl = remove_int(avl, 742); + avl = gpr_avl_add(avl, box(539), box(2225)); + avl = gpr_avl_add(avl, box(596), box(2226)); + avl = remove_int(avl, 82); + avl = remove_int(avl, 686); + avl = remove_int(avl, 933); + avl = remove_int(avl, 42); + avl = remove_int(avl, 340); + avl = gpr_avl_add(avl, box(126), box(2232)); + avl = gpr_avl_add(avl, box(493), box(2233)); + avl = gpr_avl_add(avl, box(839), box(2234)); + avl = remove_int(avl, 774); + avl = gpr_avl_add(avl, box(337), box(2236)); + avl = remove_int(avl, 322); + avl = gpr_avl_add(avl, box(16), box(2238)); + avl = remove_int(avl, 73); + avl = remove_int(avl, 85); + avl = remove_int(avl, 191); + avl = remove_int(avl, 541); + avl = gpr_avl_add(avl, box(704), box(2243)); + avl = remove_int(avl, 767); + avl = remove_int(avl, 1006); + avl = remove_int(avl, 844); + avl = remove_int(avl, 742); + avl = gpr_avl_add(avl, box(48), box(2248)); + avl = gpr_avl_add(avl, box(138), box(2249)); + avl = gpr_avl_add(avl, box(437), box(2250)); + avl = gpr_avl_add(avl, box(275), box(2251)); + avl = remove_int(avl, 520); + avl = gpr_avl_add(avl, box(1019), box(2253)); + avl = remove_int(avl, 955); + avl = gpr_avl_add(avl, box(270), box(2255)); + avl = remove_int(avl, 680); + avl = remove_int(avl, 698); + avl = gpr_avl_add(avl, box(735), box(2258)); + avl = gpr_avl_add(avl, box(400), box(2259)); + avl = remove_int(avl, 991); + avl = gpr_avl_add(avl, box(263), box(2261)); + avl = remove_int(avl, 704); + avl = gpr_avl_add(avl, box(757), box(2263)); + avl = remove_int(avl, 194); + avl = remove_int(avl, 616); + avl = remove_int(avl, 784); + avl = gpr_avl_add(avl, box(382), box(2267)); + avl = gpr_avl_add(avl, box(464), box(2268)); + avl = gpr_avl_add(avl, box(817), box(2269)); + avl = remove_int(avl, 445); + avl = gpr_avl_add(avl, box(412), box(2271)); + avl = remove_int(avl, 525); + avl = gpr_avl_add(avl, box(299), box(2273)); + avl = gpr_avl_add(avl, box(464), box(2274)); + avl = gpr_avl_add(avl, box(715), box(2275)); + avl = remove_int(avl, 58); + avl = remove_int(avl, 218); + avl = gpr_avl_add(avl, box(961), box(2278)); + avl = gpr_avl_add(avl, box(491), box(2279)); + avl = remove_int(avl, 846); + avl = gpr_avl_add(avl, box(762), box(2281)); + avl = remove_int(avl, 974); + avl = remove_int(avl, 887); + avl = gpr_avl_add(avl, box(498), box(2284)); + avl = remove_int(avl, 810); + avl = remove_int(avl, 743); + avl = remove_int(avl, 22); + avl = remove_int(avl, 284); + avl = gpr_avl_add(avl, box(482), box(2289)); + avl = gpr_avl_add(avl, box(1021), box(2290)); + avl = remove_int(avl, 155); + avl = remove_int(avl, 128); + avl = gpr_avl_add(avl, box(819), box(2293)); + avl = gpr_avl_add(avl, box(324), box(2294)); + avl = remove_int(avl, 196); + avl = remove_int(avl, 370); + avl = remove_int(avl, 753); + avl = remove_int(avl, 56); + avl = remove_int(avl, 735); + avl = gpr_avl_add(avl, box(272), box(2300)); + avl = gpr_avl_add(avl, box(474), box(2301)); + avl = gpr_avl_add(avl, box(719), box(2302)); + avl = gpr_avl_add(avl, box(236), box(2303)); + avl = remove_int(avl, 818); + avl = gpr_avl_add(avl, box(727), box(2305)); + avl = remove_int(avl, 892); + avl = remove_int(avl, 871); + avl = remove_int(avl, 231); + avl = gpr_avl_add(avl, box(62), box(2309)); + avl = gpr_avl_add(avl, box(953), box(2310)); + avl = remove_int(avl, 701); + avl = gpr_avl_add(avl, box(193), box(2312)); + avl = remove_int(avl, 619); + avl = remove_int(avl, 22); + avl = remove_int(avl, 804); + avl = remove_int(avl, 851); + avl = gpr_avl_add(avl, box(286), box(2317)); + avl = gpr_avl_add(avl, box(751), box(2318)); + avl = remove_int(avl, 525); + avl = gpr_avl_add(avl, box(217), box(2320)); + avl = remove_int(avl, 336); + avl = gpr_avl_add(avl, box(86), box(2322)); + avl = gpr_avl_add(avl, box(81), box(2323)); + avl = gpr_avl_add(avl, box(850), box(2324)); + avl = remove_int(avl, 872); + avl = gpr_avl_add(avl, box(402), box(2326)); + avl = gpr_avl_add(avl, box(54), box(2327)); + avl = gpr_avl_add(avl, box(980), box(2328)); + avl = gpr_avl_add(avl, box(845), box(2329)); + avl = remove_int(avl, 1004); + avl = remove_int(avl, 273); + avl = remove_int(avl, 879); + avl = gpr_avl_add(avl, box(354), box(2333)); + avl = gpr_avl_add(avl, box(58), box(2334)); + avl = gpr_avl_add(avl, box(127), box(2335)); + avl = remove_int(avl, 84); + avl = gpr_avl_add(avl, box(360), box(2337)); + avl = remove_int(avl, 648); + avl = remove_int(avl, 488); + avl = remove_int(avl, 585); + avl = remove_int(avl, 230); + avl = gpr_avl_add(avl, box(887), box(2342)); + avl = remove_int(avl, 558); + avl = remove_int(avl, 958); + avl = gpr_avl_add(avl, box(822), box(2345)); + avl = remove_int(avl, 1004); + avl = remove_int(avl, 747); + avl = gpr_avl_add(avl, box(631), box(2348)); + avl = gpr_avl_add(avl, box(442), box(2349)); + avl = remove_int(avl, 957); + avl = remove_int(avl, 964); + avl = gpr_avl_add(avl, box(10), box(2352)); + avl = remove_int(avl, 189); + avl = gpr_avl_add(avl, box(742), box(2354)); + avl = remove_int(avl, 108); + avl = gpr_avl_add(avl, box(1014), box(2356)); + avl = remove_int(avl, 266); + avl = remove_int(avl, 623); + avl = remove_int(avl, 697); + avl = gpr_avl_add(avl, box(180), box(2360)); + avl = remove_int(avl, 472); + avl = gpr_avl_add(avl, box(567), box(2362)); + avl = remove_int(avl, 1020); + avl = remove_int(avl, 273); + avl = gpr_avl_add(avl, box(864), box(2365)); + avl = gpr_avl_add(avl, box(1009), box(2366)); + avl = remove_int(avl, 224); + avl = remove_int(avl, 81); + avl = gpr_avl_add(avl, box(653), box(2369)); + avl = remove_int(avl, 67); + avl = remove_int(avl, 102); + avl = remove_int(avl, 76); + avl = remove_int(avl, 935); + avl = remove_int(avl, 169); + avl = remove_int(avl, 232); + avl = remove_int(avl, 79); + avl = gpr_avl_add(avl, box(509), box(2377)); + avl = remove_int(avl, 900); + avl = remove_int(avl, 822); + avl = remove_int(avl, 945); + avl = remove_int(avl, 356); + avl = gpr_avl_add(avl, box(443), box(2382)); + avl = gpr_avl_add(avl, box(925), box(2383)); + avl = remove_int(avl, 994); + avl = remove_int(avl, 324); + avl = gpr_avl_add(avl, box(291), box(2386)); + avl = remove_int(avl, 94); + avl = remove_int(avl, 795); + avl = remove_int(avl, 42); + avl = gpr_avl_add(avl, box(613), box(2390)); + avl = remove_int(avl, 289); + avl = gpr_avl_add(avl, box(980), box(2392)); + avl = remove_int(avl, 316); + avl = gpr_avl_add(avl, box(281), box(2394)); + avl = gpr_avl_add(avl, box(1006), box(2395)); + avl = remove_int(avl, 776); + avl = gpr_avl_add(avl, box(108), box(2397)); + avl = gpr_avl_add(avl, box(918), box(2398)); + avl = remove_int(avl, 721); + avl = remove_int(avl, 563); + avl = gpr_avl_add(avl, box(925), box(2401)); + avl = remove_int(avl, 448); + avl = remove_int(avl, 198); + avl = remove_int(avl, 1); + avl = gpr_avl_add(avl, box(160), box(2405)); + avl = remove_int(avl, 515); + avl = gpr_avl_add(avl, box(284), box(2407)); + avl = gpr_avl_add(avl, box(225), box(2408)); + avl = remove_int(avl, 304); + avl = gpr_avl_add(avl, box(714), box(2410)); + avl = gpr_avl_add(avl, box(708), box(2411)); + avl = gpr_avl_add(avl, box(624), box(2412)); + avl = remove_int(avl, 662); + avl = remove_int(avl, 825); + avl = remove_int(avl, 383); + avl = remove_int(avl, 381); + avl = gpr_avl_add(avl, box(194), box(2417)); + avl = remove_int(avl, 280); + avl = remove_int(avl, 25); + avl = remove_int(avl, 633); + avl = gpr_avl_add(avl, box(897), box(2421)); + avl = remove_int(avl, 636); + avl = remove_int(avl, 596); + avl = remove_int(avl, 757); + avl = remove_int(avl, 343); + avl = remove_int(avl, 162); + avl = remove_int(avl, 913); + avl = remove_int(avl, 843); + avl = remove_int(avl, 280); + avl = remove_int(avl, 911); + avl = gpr_avl_add(avl, box(1008), box(2431)); + avl = remove_int(avl, 948); + avl = remove_int(avl, 74); + avl = remove_int(avl, 571); + avl = gpr_avl_add(avl, box(486), box(2435)); + avl = gpr_avl_add(avl, box(285), box(2436)); + avl = remove_int(avl, 304); + avl = remove_int(avl, 516); + avl = gpr_avl_add(avl, box(758), box(2439)); + avl = gpr_avl_add(avl, box(776), box(2440)); + avl = remove_int(avl, 696); + avl = gpr_avl_add(avl, box(104), box(2442)); + avl = gpr_avl_add(avl, box(700), box(2443)); + avl = gpr_avl_add(avl, box(114), box(2444)); + avl = gpr_avl_add(avl, box(567), box(2445)); + avl = remove_int(avl, 620); + avl = gpr_avl_add(avl, box(270), box(2447)); + avl = remove_int(avl, 730); + avl = gpr_avl_add(avl, box(749), box(2449)); + avl = gpr_avl_add(avl, box(443), box(2450)); + avl = remove_int(avl, 457); + avl = gpr_avl_add(avl, box(571), box(2452)); + avl = gpr_avl_add(avl, box(626), box(2453)); + avl = remove_int(avl, 638); + avl = remove_int(avl, 313); + + gpr_avl_unref(avl); +} + +static void test_stress(void) { + int added[1024]; + int i, j; + int deletions = 0; + gpr_avl avl; + + gpr_log(GPR_DEBUG, "test_stress"); + + srand((unsigned)time(NULL)); + avl = gpr_avl_create(&int_int_vtable); + + memset(added, 0, sizeof(added)); + + for (i = 1; deletions < 1000; i++) { + int idx = rand() % (int)GPR_ARRAY_SIZE(added); + GPR_ASSERT(i); + if (rand() < RAND_MAX / 2) { + added[idx] = i; + fprintf(stderr, "avl = gpr_avl_add(avl, box(%d), box(%d)); /* d=%d */\n", + idx, i, deletions); + avl = gpr_avl_add(avl, box(idx), box(i)); + } else { + deletions += (added[idx] != 0); + added[idx] = 0; + fprintf(stderr, "avl = remove_int(avl, %d); /* d=%d */\n", idx, + deletions); + avl = remove_int(avl, idx); + } + for (j = 0; j < (int)GPR_ARRAY_SIZE(added); j++) { + if (added[j] != 0) { + check_get(avl, j, added[j]); + } else { + check_negget(avl, j); + } + } + } + + gpr_avl_unref(avl); +} + +int main(int argc, char *argv[]) { + grpc_test_init(argc, argv); + + test_get(); + test_ll(); + test_lr(); + test_rr(); + test_rl(); + test_unbalanced(); + test_replace(); + test_remove(); + test_badcase1(); + test_badcase2(); + test_badcase3(); + test_stress(); + + return 0; +} diff --git a/test/core/surface/byte_buffer_reader_test.c b/test/core/surface/byte_buffer_reader_test.c index 560e0ac7b2..6b41698717 100644 --- a/test/core/surface/byte_buffer_reader_test.c +++ b/test/core/surface/byte_buffer_reader_test.c @@ -184,6 +184,39 @@ static void test_byte_buffer_from_reader(void) { grpc_byte_buffer_destroy(buffer_from_reader); } +static void test_readall(void) { + char *lotsa_as[512]; + char *lotsa_bs[1024]; + gpr_slice slices[2]; + grpc_byte_buffer *buffer; + grpc_byte_buffer_reader reader; + gpr_slice slice_out; + + LOG_TEST("test_readall"); + + memset(lotsa_as, 'a', 512); + memset(lotsa_bs, 'b', 1024); + /* use slices large enough to overflow inlining */ + slices[0] = gpr_slice_malloc(512); + memcpy(GPR_SLICE_START_PTR(slices[0]), lotsa_as, 512); + slices[1] = gpr_slice_malloc(1024); + memcpy(GPR_SLICE_START_PTR(slices[1]), lotsa_bs, 1024); + + buffer = grpc_raw_byte_buffer_create(slices, 2); + gpr_slice_unref(slices[0]); + gpr_slice_unref(slices[1]); + + grpc_byte_buffer_reader_init(&reader, buffer); + slice_out = grpc_byte_buffer_reader_readall(&reader); + + GPR_ASSERT(GPR_SLICE_LENGTH(slice_out) == 512 + 1024); + GPR_ASSERT(memcmp(GPR_SLICE_START_PTR(slice_out), lotsa_as, 512) == 0); + GPR_ASSERT(memcmp(&(GPR_SLICE_START_PTR(slice_out)[512]), lotsa_bs, 1024) == + 0); + gpr_slice_unref(slice_out); + grpc_byte_buffer_destroy(buffer); +} + int main(int argc, char **argv) { grpc_test_init(argc, argv); test_read_one_slice(); @@ -192,6 +225,6 @@ int main(int argc, char **argv) { test_read_gzip_compressed_slice(); test_read_deflate_compressed_slice(); test_byte_buffer_from_reader(); - + test_readall(); return 0; } diff --git a/test/core/transport/chttp2/hpack_encoder_test.c b/test/core/transport/chttp2/hpack_encoder_test.c new file mode 100644 index 0000000000..4a9d143640 --- /dev/null +++ b/test/core/transport/chttp2/hpack_encoder_test.c @@ -0,0 +1,201 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include "src/core/transport/chttp2/hpack_encoder.h" + +#include <stdio.h> + +#include "src/core/support/string.h" +#include "src/core/transport/chttp2/hpack_parser.h" +#include "src/core/transport/metadata.h" +#include <grpc/support/alloc.h> +#include <grpc/support/log.h> +#include <grpc/support/string_util.h> +#include "test/core/util/parse_hexstring.h" +#include "test/core/util/slice_splitter.h" +#include "test/core/util/test_config.h" + +#define TEST(x) run_test(x, #x) + +grpc_chttp2_hpack_compressor g_compressor; +int g_failure = 0; + +void **to_delete = NULL; +size_t num_to_delete = 0; +size_t cap_to_delete = 0; + +/* verify that the output generated by encoding the stream matches the + hexstring passed in */ +static void verify(size_t window_available, int eof, size_t expect_window_used, + const char *expected, size_t nheaders, ...) { + gpr_slice_buffer output; + gpr_slice merged; + gpr_slice expect = parse_hexstring(expected); + size_t i; + va_list l; + grpc_linked_mdelem *e = gpr_malloc(sizeof(*e) * nheaders); + grpc_metadata_batch b; + + grpc_metadata_batch_init(&b); + + va_start(l, nheaders); + for (i = 0; i < nheaders; i++) { + char *key = va_arg(l, char *); + char *value = va_arg(l, char *); + if (i) { + e[i - 1].next = &e[i]; + e[i].prev = &e[i - 1]; + } + e[i].md = grpc_mdelem_from_strings(key, value); + } + e[0].prev = NULL; + e[nheaders - 1].next = NULL; + va_end(l); + + b.list.head = &e[0]; + b.list.tail = &e[nheaders - 1]; + + if (cap_to_delete == num_to_delete) { + cap_to_delete = GPR_MAX(2 * cap_to_delete, 1000); + to_delete = gpr_realloc(to_delete, sizeof(*to_delete) * cap_to_delete); + } + to_delete[num_to_delete++] = e; + + gpr_slice_buffer_init(&output); + + grpc_chttp2_encode_header(&g_compressor, 0xdeadbeef, &b, eof, &output); + merged = grpc_slice_merge(output.slices, output.count); + gpr_slice_buffer_destroy(&output); + grpc_metadata_batch_destroy(&b); + + if (0 != gpr_slice_cmp(merged, expect)) { + char *expect_str = gpr_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII); + char *got_str = gpr_dump_slice(merged, GPR_DUMP_HEX | GPR_DUMP_ASCII); + gpr_log(GPR_ERROR, "mismatched output for %s", expected); + gpr_log(GPR_ERROR, "EXPECT: %s", expect_str); + gpr_log(GPR_ERROR, "GOT: %s", got_str); + gpr_free(expect_str); + gpr_free(got_str); + g_failure = 1; + } + + gpr_slice_unref(merged); + gpr_slice_unref(expect); +} + +static void test_basic_headers(void) { + int i; + + verify(0, 0, 0, "000005 0104 deadbeef 40 0161 0161", 1, "a", "a"); + verify(0, 0, 0, "000001 0104 deadbeef be", 1, "a", "a"); + verify(0, 0, 0, "000001 0104 deadbeef be", 1, "a", "a"); + verify(0, 0, 0, "000006 0104 deadbeef be 40 0162 0163", 2, "a", "a", "b", + "c"); + verify(0, 0, 0, "000002 0104 deadbeef bf be", 2, "a", "a", "b", "c"); + verify(0, 0, 0, "000004 0104 deadbeef 7f 00 0164", 1, "a", "d"); + + /* flush out what's there to make a few values look very popular */ + for (i = 0; i < 350; i++) { + verify(0, 0, 0, "000003 0104 deadbeef c0 bf be", 3, "a", "a", "b", "c", "a", + "d"); + } + + verify(0, 0, 0, "000006 0104 deadbeef c0 00 016b 0176", 2, "a", "a", "k", + "v"); + /* this could be 000004 0104 deadbeef 0f 30 0176 also */ + verify(0, 0, 0, "000004 0104 deadbeef 0f 2f 0176", 1, "a", "v"); +} + +static void encode_int_to_str(int i, char *p) { + p[0] = (char)('a' + i % 26); + i /= 26; + GPR_ASSERT(i < 26); + p[1] = (char)('a' + i); + p[2] = 0; +} + +static void test_decode_table_overflow(void) { + int i; + char key[3], value[3]; + char *expect; + + for (i = 0; i < 114; i++) { + encode_int_to_str(i, key); + encode_int_to_str(i + 1, value); + + if (i + 61 >= 127) { + gpr_asprintf(&expect, + "000009 0104 deadbeef ff%02x 40 02%02x%02x 02%02x%02x", + i + 61 - 127, key[0], key[1], value[0], value[1]); + } else if (i > 0) { + gpr_asprintf(&expect, + "000008 0104 deadbeef %02x 40 02%02x%02x 02%02x%02x", + 0x80 + 61 + i, key[0], key[1], value[0], value[1]); + } else { + gpr_asprintf(&expect, "000007 0104 deadbeef 40 02%02x%02x 02%02x%02x", + key[0], key[1], value[0], value[1]); + } + + if (i > 0) { + verify(0, 0, 0, expect, 2, "aa", "ba", key, value); + } else { + verify(0, 0, 0, expect, 1, key, value); + } + gpr_free(expect); + } + + /* if the above passes, then we must have just knocked this pair out of the + decoder stack, and so we'll be forced to re-encode it */ + verify(0, 0, 0, "000007 0104 deadbeef 40 026161 026261", 1, "aa", "ba"); +} + +static void run_test(void (*test)(), const char *name) { + gpr_log(GPR_INFO, "RUN TEST: %s", name); + grpc_chttp2_hpack_compressor_init(&g_compressor); + test(); + grpc_chttp2_hpack_compressor_destroy(&g_compressor); +} + +int main(int argc, char **argv) { + size_t i; + grpc_test_only_set_metadata_hash_seed(0); + grpc_test_init(argc, argv); + grpc_init(); + TEST(test_basic_headers); + TEST(test_decode_table_overflow); + grpc_shutdown(); + for (i = 0; i < num_to_delete; i++) { + gpr_free(to_delete[i]); + } + return g_failure; +} diff --git a/test/core/transport/chttp2/hpack_parser_test.c b/test/core/transport/chttp2/hpack_parser_test.c index 3a313375a4..4456e197af 100644 --- a/test/core/transport/chttp2/hpack_parser_test.c +++ b/test/core/transport/chttp2/hpack_parser_test.c @@ -35,6 +35,7 @@ #include <stdarg.h> +#include <grpc/grpc.h> #include <grpc/support/alloc.h> #include <grpc/support/log.h> #include <grpc/support/slice.h> @@ -90,9 +91,8 @@ static void test_vector(grpc_chttp2_hpack_parser *parser, static void test_vectors(grpc_slice_split_mode mode) { grpc_chttp2_hpack_parser parser; - grpc_mdctx *mdctx = grpc_mdctx_create(); - grpc_chttp2_hpack_parser_init(&parser, mdctx); + grpc_chttp2_hpack_parser_init(&parser); /* D.2.1 */ test_vector(&parser, mode, "400a 6375 7374 6f6d 2d6b 6579 0d63 7573" @@ -110,7 +110,7 @@ static void test_vectors(grpc_slice_split_mode mode) { test_vector(&parser, mode, "82", ":method", "GET", NULL); grpc_chttp2_hpack_parser_destroy(&parser); - grpc_chttp2_hpack_parser_init(&parser, mdctx); + grpc_chttp2_hpack_parser_init(&parser); /* D.3.1 */ test_vector(&parser, mode, "8286 8441 0f77 7777 2e65 7861 6d70 6c65" @@ -130,7 +130,7 @@ static void test_vectors(grpc_slice_split_mode mode) { NULL); grpc_chttp2_hpack_parser_destroy(&parser); - grpc_chttp2_hpack_parser_init(&parser, mdctx); + grpc_chttp2_hpack_parser_init(&parser); /* D.4.1 */ test_vector(&parser, mode, "8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4" @@ -150,8 +150,9 @@ static void test_vectors(grpc_slice_split_mode mode) { NULL); grpc_chttp2_hpack_parser_destroy(&parser); - grpc_chttp2_hpack_parser_init(&parser, mdctx); - parser.table.max_bytes = 256; + grpc_chttp2_hpack_parser_init(&parser); + grpc_chttp2_hptbl_set_max_bytes(&parser.table, 256); + grpc_chttp2_hptbl_set_current_table_size(&parser.table, 256); /* D.5.1 */ test_vector(&parser, mode, "4803 3330 3258 0770 7269 7661 7465 611d" @@ -183,8 +184,9 @@ static void test_vectors(grpc_slice_split_mode mode) { "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1", NULL); grpc_chttp2_hpack_parser_destroy(&parser); - grpc_chttp2_hpack_parser_init(&parser, mdctx); - parser.table.max_bytes = 256; + grpc_chttp2_hpack_parser_init(&parser); + grpc_chttp2_hptbl_set_max_bytes(&parser.table, 256); + grpc_chttp2_hptbl_set_current_table_size(&parser.table, 256); /* D.6.1 */ test_vector(&parser, mode, "4882 6402 5885 aec3 771a 4b61 96d0 7abe" @@ -212,12 +214,13 @@ static void test_vectors(grpc_slice_split_mode mode) { "set-cookie", "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1", NULL); grpc_chttp2_hpack_parser_destroy(&parser); - grpc_mdctx_unref(mdctx); } int main(int argc, char **argv) { grpc_test_init(argc, argv); + grpc_init(); test_vectors(GRPC_SLICE_SPLIT_MERGE_ALL); test_vectors(GRPC_SLICE_SPLIT_ONE_BYTE); + grpc_shutdown(); return 0; } diff --git a/test/core/transport/chttp2/hpack_table_test.c b/test/core/transport/chttp2/hpack_table_test.c index aa3e273a6c..50496a305d 100644 --- a/test/core/transport/chttp2/hpack_table_test.c +++ b/test/core/transport/chttp2/hpack_table_test.c @@ -36,10 +36,12 @@ #include <string.h> #include <stdio.h> -#include "src/core/support/string.h" #include <grpc/support/alloc.h> #include <grpc/support/log.h> #include <grpc/support/string_util.h> +#include <grpc/grpc.h> + +#include "src/core/support/string.h" #include "test/core/util/test_config.h" #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x) @@ -58,10 +60,8 @@ static void assert_index(const grpc_chttp2_hptbl *tbl, gpr_uint32 idx, static void test_static_lookup(void) { grpc_chttp2_hptbl tbl; - grpc_mdctx *mdctx; - mdctx = grpc_mdctx_create(); - grpc_chttp2_hptbl_init(&tbl, mdctx); + grpc_chttp2_hptbl_init(&tbl); LOG_TEST("test_static_lookup"); assert_index(&tbl, 1, ":authority", ""); @@ -127,7 +127,6 @@ static void test_static_lookup(void) { assert_index(&tbl, 61, "www-authenticate", ""); grpc_chttp2_hptbl_destroy(&tbl); - grpc_mdctx_unref(mdctx); } static void test_many_additions(void) { @@ -135,17 +134,18 @@ static void test_many_additions(void) { int i; char *key; char *value; - grpc_mdctx *mdctx; LOG_TEST("test_many_additions"); - mdctx = grpc_mdctx_create(); - grpc_chttp2_hptbl_init(&tbl, mdctx); + grpc_chttp2_hptbl_init(&tbl); for (i = 0; i < 1000000; i++) { + grpc_mdelem *elem; gpr_asprintf(&key, "K:%d", i); gpr_asprintf(&value, "VALUE:%d", i); - grpc_chttp2_hptbl_add(&tbl, grpc_mdelem_from_strings(mdctx, key, value)); + elem = grpc_mdelem_from_strings(key, value); + GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem)); + GRPC_MDELEM_UNREF(elem); assert_index(&tbl, 1 + GRPC_CHTTP2_LAST_STATIC_ENTRY, key, value); gpr_free(key); gpr_free(value); @@ -159,13 +159,12 @@ static void test_many_additions(void) { } grpc_chttp2_hptbl_destroy(&tbl); - grpc_mdctx_unref(mdctx); } static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl *tbl, const char *key, const char *value) { - grpc_mdelem *md = grpc_mdelem_from_strings(tbl->mdctx, key, value); + grpc_mdelem *md = grpc_mdelem_from_strings(key, value); grpc_chttp2_hptbl_find_result r = grpc_chttp2_hptbl_find(tbl, md); GRPC_MDELEM_UNREF(md); return r; @@ -173,18 +172,23 @@ static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl *tbl, static void test_find(void) { grpc_chttp2_hptbl tbl; - int i; + gpr_uint32 i; char buffer[32]; - grpc_mdctx *mdctx; + grpc_mdelem *elem; grpc_chttp2_hptbl_find_result r; LOG_TEST("test_find"); - mdctx = grpc_mdctx_create(); - grpc_chttp2_hptbl_init(&tbl, mdctx); - grpc_chttp2_hptbl_add(&tbl, grpc_mdelem_from_strings(mdctx, "abc", "xyz")); - grpc_chttp2_hptbl_add(&tbl, grpc_mdelem_from_strings(mdctx, "abc", "123")); - grpc_chttp2_hptbl_add(&tbl, grpc_mdelem_from_strings(mdctx, "x", "1")); + grpc_chttp2_hptbl_init(&tbl); + elem = grpc_mdelem_from_strings("abc", "xyz"); + GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem)); + GRPC_MDELEM_UNREF(elem); + elem = grpc_mdelem_from_strings("abc", "123"); + GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem)); + GRPC_MDELEM_UNREF(elem); + elem = grpc_mdelem_from_strings("x", "1"); + GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem)); + GRPC_MDELEM_UNREF(elem); r = find_simple(&tbl, "abc", "123"); GPR_ASSERT(r.index == 2 + GRPC_CHTTP2_LAST_STATIC_ENTRY); @@ -233,8 +237,9 @@ static void test_find(void) { /* overflow the string buffer, check find still works */ for (i = 0; i < 10000; i++) { gpr_ltoa(i, buffer); - grpc_chttp2_hptbl_add(&tbl, - grpc_mdelem_from_strings(mdctx, "test", buffer)); + elem = grpc_mdelem_from_strings("test", buffer); + GPR_ASSERT(grpc_chttp2_hptbl_add(&tbl, elem)); + GRPC_MDELEM_UNREF(elem); } r = find_simple(&tbl, "abc", "123"); @@ -250,7 +255,7 @@ static void test_find(void) { GPR_ASSERT(r.has_value == 1); for (i = 0; i < tbl.num_ents; i++) { - int expect = 9999 - i; + gpr_uint32 expect = 9999 - i; gpr_ltoa(expect, buffer); r = find_simple(&tbl, "test", buffer); @@ -263,13 +268,14 @@ static void test_find(void) { GPR_ASSERT(r.has_value == 0); grpc_chttp2_hptbl_destroy(&tbl); - grpc_mdctx_unref(mdctx); } int main(int argc, char **argv) { grpc_test_init(argc, argv); + grpc_init(); test_static_lookup(); test_many_additions(); test_find(); + grpc_shutdown(); return 0; } diff --git a/test/core/transport/chttp2/stream_encoder_test.c b/test/core/transport/chttp2/stream_encoder_test.c deleted file mode 100644 index 71db98c69e..0000000000 --- a/test/core/transport/chttp2/stream_encoder_test.c +++ /dev/null @@ -1,359 +0,0 @@ -/* - * - * Copyright 2015, Google Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following disclaimer - * in the documentation and/or other materials provided with the - * distribution. - * * Neither the name of Google Inc. nor the names of its - * contributors may be used to endorse or promote products derived from - * this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#include "src/core/transport/chttp2/stream_encoder.h" - -#include <stdio.h> - -#include "src/core/support/string.h" -#include "src/core/transport/chttp2/hpack_parser.h" -#include <grpc/support/alloc.h> -#include <grpc/support/log.h> -#include <grpc/support/string_util.h> -#include "test/core/util/parse_hexstring.h" -#include "test/core/util/slice_splitter.h" -#include "test/core/util/test_config.h" - -#define TEST(x) run_test(x, #x) - -grpc_mdctx *g_mdctx; -grpc_chttp2_hpack_compressor g_compressor; -int g_failure = 0; -grpc_stream_op_buffer g_sopb; - -void **to_delete = NULL; -size_t num_to_delete = 0; -size_t cap_to_delete = 0; - -static gpr_slice create_test_slice(size_t length) { - gpr_slice slice = gpr_slice_malloc(length); - size_t i; - for (i = 0; i < length; i++) { - GPR_SLICE_START_PTR(slice)[i] = (gpr_uint8)i; - } - return slice; -} - -/* verify that the output generated by encoding the stream matches the - hexstring passed in */ -static void verify_sopb(size_t window_available, int eof, - size_t expect_window_used, const char *expected) { - gpr_slice_buffer output; - grpc_stream_op_buffer encops; - gpr_slice merged; - gpr_slice expect = parse_hexstring(expected); - gpr_slice_buffer_init(&output); - grpc_sopb_init(&encops); - GPR_ASSERT(expect_window_used == - grpc_chttp2_preencode(g_sopb.ops, &g_sopb.nops, - (gpr_uint32)window_available, &encops)); - grpc_chttp2_encode(encops.ops, encops.nops, eof, 0xdeadbeef, &g_compressor, - &output); - encops.nops = 0; - merged = grpc_slice_merge(output.slices, output.count); - gpr_slice_buffer_destroy(&output); - grpc_sopb_destroy(&encops); - - if (0 != gpr_slice_cmp(merged, expect)) { - char *expect_str = gpr_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII); - char *got_str = gpr_dump_slice(merged, GPR_DUMP_HEX | GPR_DUMP_ASCII); - gpr_log(GPR_ERROR, "mismatched output for %s", expected); - gpr_log(GPR_ERROR, "EXPECT: %s", expect_str); - gpr_log(GPR_ERROR, "GOT: %s", got_str); - gpr_free(expect_str); - gpr_free(got_str); - g_failure = 1; - } - - gpr_slice_unref(merged); - gpr_slice_unref(expect); -} - -static void test_small_data_framing(void) { - grpc_sopb_add_no_op(&g_sopb); - verify_sopb(10, 0, 0, ""); - - grpc_sopb_add_slice(&g_sopb, create_test_slice(3)); - verify_sopb(10, 0, 3, "000003 0000 deadbeef 000102"); - - grpc_sopb_add_slice(&g_sopb, create_test_slice(4)); - verify_sopb(10, 0, 4, "000004 0000 deadbeef 00010203"); - - grpc_sopb_add_slice(&g_sopb, create_test_slice(3)); - grpc_sopb_add_slice(&g_sopb, create_test_slice(4)); - verify_sopb(10, 0, 7, "000007 0000 deadbeef 000102 00010203"); - - grpc_sopb_add_slice(&g_sopb, create_test_slice(0)); - grpc_sopb_add_slice(&g_sopb, create_test_slice(0)); - grpc_sopb_add_slice(&g_sopb, create_test_slice(0)); - grpc_sopb_add_slice(&g_sopb, create_test_slice(0)); - grpc_sopb_add_slice(&g_sopb, create_test_slice(3)); - verify_sopb(10, 0, 3, "000003 0000 deadbeef 000102"); - - verify_sopb(10, 1, 0, "000000 0001 deadbeef"); - - grpc_sopb_add_begin_message(&g_sopb, 255, 0); - verify_sopb(10, 0, 5, "000005 0000 deadbeef 00000000ff"); -} - -static void add_sopb_headers(size_t n, ...) { - size_t i; - grpc_metadata_batch b; - va_list l; - grpc_linked_mdelem *e = gpr_malloc(sizeof(*e) * n); - - grpc_metadata_batch_init(&b); - - va_start(l, n); - for (i = 0; i < n; i++) { - char *key = va_arg(l, char *); - char *value = va_arg(l, char *); - if (i) { - e[i - 1].next = &e[i]; - e[i].prev = &e[i - 1]; - } - e[i].md = grpc_mdelem_from_strings(g_mdctx, key, value); - } - e[0].prev = NULL; - e[n - 1].next = NULL; - va_end(l); - - b.list.head = &e[0]; - b.list.tail = &e[n - 1]; - - if (cap_to_delete == num_to_delete) { - cap_to_delete = GPR_MAX(2 * cap_to_delete, 1000); - to_delete = gpr_realloc(to_delete, sizeof(*to_delete) * cap_to_delete); - } - to_delete[num_to_delete++] = e; - - grpc_sopb_add_metadata(&g_sopb, b); -} - -static void test_basic_headers(void) { - int i; - - add_sopb_headers(1, "a", "a"); - verify_sopb(0, 0, 0, "000005 0104 deadbeef 40 0161 0161"); - - add_sopb_headers(1, "a", "a"); - verify_sopb(0, 0, 0, "000001 0104 deadbeef be"); - - add_sopb_headers(1, "a", "a"); - verify_sopb(0, 0, 0, "000001 0104 deadbeef be"); - - add_sopb_headers(2, "a", "a", "b", "c"); - verify_sopb(0, 0, 0, "000006 0104 deadbeef be 40 0162 0163"); - - add_sopb_headers(2, "a", "a", "b", "c"); - verify_sopb(0, 0, 0, "000002 0104 deadbeef bf be"); - - add_sopb_headers(1, "a", "d"); - verify_sopb(0, 0, 0, "000004 0104 deadbeef 7f 00 0164"); - - /* flush out what's there to make a few values look very popular */ - for (i = 0; i < 350; i++) { - add_sopb_headers(3, "a", "a", "b", "c", "a", "d"); - verify_sopb(0, 0, 0, "000003 0104 deadbeef c0 bf be"); - } - - add_sopb_headers(2, "a", "a", "k", "v"); - verify_sopb(0, 0, 0, "000006 0104 deadbeef c0 00 016b 0176"); - - add_sopb_headers(1, "a", "v"); - /* this could be 000004 0104 deadbeef 0f 30 0176 also */ - verify_sopb(0, 0, 0, "000004 0104 deadbeef 0f 2f 0176"); -} - -static void encode_int_to_str(int i, char *p) { - p[0] = (char)('a' + i % 26); - i /= 26; - GPR_ASSERT(i < 26); - p[1] = (char)('a' + i); - p[2] = 0; -} - -static void test_decode_table_overflow(void) { - int i; - char key[3], value[3]; - char *expect; - - for (i = 0; i < 114; i++) { - if (i > 0) { - add_sopb_headers(1, "aa", "ba"); - } - - encode_int_to_str(i, key); - encode_int_to_str(i + 1, value); - - if (i + 61 >= 127) { - gpr_asprintf(&expect, - "000002 0104 deadbeef ff%02x 000007 0104 deadbeef 40 " - "02%02x%02x 02%02x%02x", - i + 61 - 127, key[0], key[1], value[0], value[1]); - } else if (i > 0) { - gpr_asprintf(&expect, - "000001 0104 deadbeef %02x 000007 0104 deadbeef 40 " - "02%02x%02x 02%02x%02x", - 0x80 + 61 + i, key[0], key[1], value[0], value[1]); - } else { - gpr_asprintf(&expect, "000007 0104 deadbeef 40 02%02x%02x 02%02x%02x", - key[0], key[1], value[0], value[1]); - } - - add_sopb_headers(1, key, value); - verify_sopb(0, 0, 0, expect); - gpr_free(expect); - } - - /* if the above passes, then we must have just knocked this pair out of the - decoder stack, and so we'll be forced to re-encode it */ - add_sopb_headers(1, "aa", "ba"); - verify_sopb(0, 0, 0, "000007 0104 deadbeef 40 026161 026261"); -} - -static void randstr(char *p, int bufsz) { - int i; - int len = 1 + rand() % bufsz; - for (i = 0; i < len; i++) { - p[i] = (char)('a' + rand() % 26); - } - p[len] = 0; -} - -typedef struct { - char key[300]; - char value[300]; - int got_hdr; -} test_decode_random_header_state; - -static void chk_hdr(void *p, grpc_mdelem *el) { - test_decode_random_header_state *st = p; - GPR_ASSERT(0 == gpr_slice_str_cmp(el->key->slice, st->key)); - GPR_ASSERT(0 == gpr_slice_str_cmp(el->value->slice, st->value)); - st->got_hdr = 1; - GRPC_MDELEM_UNREF(el); -} - -static void test_decode_random_headers_inner(int max_len) { - int i; - test_decode_random_header_state st; - gpr_slice_buffer output; - gpr_slice merged; - grpc_stream_op_buffer encops; - grpc_chttp2_hpack_parser parser; - - grpc_chttp2_hpack_parser_init(&parser, g_mdctx); - grpc_sopb_init(&encops); - - gpr_log(GPR_INFO, "max_len = %d", max_len); - - for (i = 0; i < 10000; i++) { - randstr(st.key, max_len); - randstr(st.value, max_len); - - add_sopb_headers(1, st.key, st.value); - gpr_slice_buffer_init(&output); - GPR_ASSERT(0 == - grpc_chttp2_preencode(g_sopb.ops, &g_sopb.nops, 0, &encops)); - grpc_chttp2_encode(encops.ops, encops.nops, 0, 0xdeadbeef, &g_compressor, - &output); - encops.nops = 0; - merged = grpc_slice_merge(output.slices, output.count); - gpr_slice_buffer_destroy(&output); - - st.got_hdr = 0; - parser.on_header = chk_hdr; - parser.on_header_user_data = &st; - grpc_chttp2_hpack_parser_parse(&parser, GPR_SLICE_START_PTR(merged) + 9, - GPR_SLICE_END_PTR(merged)); - GPR_ASSERT(st.got_hdr); - - gpr_slice_unref(merged); - } - - grpc_chttp2_hpack_parser_destroy(&parser); - grpc_sopb_destroy(&encops); -} - -#define DECL_TEST_DECODE_RANDOM_HEADERS(n) \ - static void test_decode_random_headers_##n(void) { \ - test_decode_random_headers_inner(n); \ - } \ - int keeps_formatting_correct_##n - -DECL_TEST_DECODE_RANDOM_HEADERS(1); -DECL_TEST_DECODE_RANDOM_HEADERS(2); -DECL_TEST_DECODE_RANDOM_HEADERS(3); -DECL_TEST_DECODE_RANDOM_HEADERS(5); -DECL_TEST_DECODE_RANDOM_HEADERS(8); -DECL_TEST_DECODE_RANDOM_HEADERS(13); -DECL_TEST_DECODE_RANDOM_HEADERS(21); -DECL_TEST_DECODE_RANDOM_HEADERS(34); -DECL_TEST_DECODE_RANDOM_HEADERS(55); -DECL_TEST_DECODE_RANDOM_HEADERS(89); -DECL_TEST_DECODE_RANDOM_HEADERS(144); - -static void run_test(void (*test)(), const char *name) { - gpr_log(GPR_INFO, "RUN TEST: %s", name); - g_mdctx = grpc_mdctx_create_with_seed(0); - grpc_chttp2_hpack_compressor_init(&g_compressor, g_mdctx); - grpc_sopb_init(&g_sopb); - test(); - grpc_chttp2_hpack_compressor_destroy(&g_compressor); - grpc_mdctx_unref(g_mdctx); - grpc_sopb_destroy(&g_sopb); -} - -int main(int argc, char **argv) { - size_t i; - grpc_test_init(argc, argv); - TEST(test_small_data_framing); - TEST(test_basic_headers); - TEST(test_decode_table_overflow); - TEST(test_decode_random_headers_1); - TEST(test_decode_random_headers_2); - TEST(test_decode_random_headers_3); - TEST(test_decode_random_headers_5); - TEST(test_decode_random_headers_8); - TEST(test_decode_random_headers_13); - TEST(test_decode_random_headers_21); - TEST(test_decode_random_headers_34); - TEST(test_decode_random_headers_55); - TEST(test_decode_random_headers_89); - TEST(test_decode_random_headers_144); - for (i = 0; i < num_to_delete; i++) { - gpr_free(to_delete[i]); - } - return g_failure; -} diff --git a/test/core/transport/metadata_test.c b/test/core/transport/metadata_test.c index 080e86cb63..9c1eae9552 100644 --- a/test/core/transport/metadata_test.c +++ b/test/core/transport/metadata_test.c @@ -35,11 +35,13 @@ #include <stdio.h> -#include "src/core/support/string.h" -#include "src/core/transport/chttp2/bin_encoder.h" +#include <grpc/grpc.h> #include <grpc/support/alloc.h> #include <grpc/support/log.h> #include <grpc/support/string_util.h> + +#include "src/core/support/string.h" +#include "src/core/transport/chttp2/bin_encoder.h" #include "test/core/util/test_config.h" #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x) @@ -48,44 +50,39 @@ #define MANY 10000 static void test_no_op(void) { - grpc_mdctx *ctx; - LOG_TEST("test_no_op"); - - ctx = grpc_mdctx_create(); - grpc_mdctx_unref(ctx); + grpc_init(); + grpc_shutdown(); } static void test_create_string(void) { - grpc_mdctx *ctx; grpc_mdstr *s1, *s2, *s3; LOG_TEST("test_create_string"); - ctx = grpc_mdctx_create(); - s1 = grpc_mdstr_from_string(ctx, "hello"); - s2 = grpc_mdstr_from_string(ctx, "hello"); - s3 = grpc_mdstr_from_string(ctx, "very much not hello"); + grpc_init(); + s1 = grpc_mdstr_from_string("hello"); + s2 = grpc_mdstr_from_string("hello"); + s3 = grpc_mdstr_from_string("very much not hello"); GPR_ASSERT(s1 == s2); GPR_ASSERT(s3 != s1); GPR_ASSERT(gpr_slice_str_cmp(s1->slice, "hello") == 0); GPR_ASSERT(gpr_slice_str_cmp(s3->slice, "very much not hello") == 0); GRPC_MDSTR_UNREF(s1); GRPC_MDSTR_UNREF(s2); - grpc_mdctx_unref(ctx); GRPC_MDSTR_UNREF(s3); + grpc_shutdown(); } static void test_create_metadata(void) { - grpc_mdctx *ctx; grpc_mdelem *m1, *m2, *m3; LOG_TEST("test_create_metadata"); - ctx = grpc_mdctx_create(); - m1 = grpc_mdelem_from_strings(ctx, "a", "b"); - m2 = grpc_mdelem_from_strings(ctx, "a", "b"); - m3 = grpc_mdelem_from_strings(ctx, "a", "c"); + grpc_init(); + m1 = grpc_mdelem_from_strings("a", "b"); + m2 = grpc_mdelem_from_strings("a", "b"); + m3 = grpc_mdelem_from_strings("a", "c"); GPR_ASSERT(m1 == m2); GPR_ASSERT(m3 != m1); GPR_ASSERT(m3->key == m1->key); @@ -96,32 +93,25 @@ static void test_create_metadata(void) { GRPC_MDELEM_UNREF(m1); GRPC_MDELEM_UNREF(m2); GRPC_MDELEM_UNREF(m3); - grpc_mdctx_unref(ctx); + grpc_shutdown(); } static void test_create_many_ephemeral_metadata(void) { - grpc_mdctx *ctx; char buffer[GPR_LTOA_MIN_BUFSIZE]; long i; - size_t mdtab_capacity_before; LOG_TEST("test_create_many_ephemeral_metadata"); - ctx = grpc_mdctx_create(); - mdtab_capacity_before = grpc_mdctx_get_mdtab_capacity_test_only(ctx); + grpc_init(); /* add, and immediately delete a bunch of different elements */ for (i = 0; i < MANY; i++) { gpr_ltoa(i, buffer); - GRPC_MDELEM_UNREF(grpc_mdelem_from_strings(ctx, "a", buffer)); + GRPC_MDELEM_UNREF(grpc_mdelem_from_strings("a", buffer)); } - /* capacity should not grow */ - GPR_ASSERT(mdtab_capacity_before == - grpc_mdctx_get_mdtab_capacity_test_only(ctx)); - grpc_mdctx_unref(ctx); + grpc_shutdown(); } static void test_create_many_persistant_metadata(void) { - grpc_mdctx *ctx; char buffer[GPR_LTOA_MIN_BUFSIZE]; long i; grpc_mdelem **created = gpr_malloc(sizeof(grpc_mdelem *) * MANY); @@ -129,16 +119,16 @@ static void test_create_many_persistant_metadata(void) { LOG_TEST("test_create_many_persistant_metadata"); - ctx = grpc_mdctx_create(); + grpc_init(); /* add phase */ for (i = 0; i < MANY; i++) { gpr_ltoa(i, buffer); - created[i] = grpc_mdelem_from_strings(ctx, "a", buffer); + created[i] = grpc_mdelem_from_strings("a", buffer); } /* verify phase */ for (i = 0; i < MANY; i++) { gpr_ltoa(i, buffer); - md = grpc_mdelem_from_strings(ctx, "a", buffer); + md = grpc_mdelem_from_strings("a", buffer); GPR_ASSERT(md == created[i]); GRPC_MDELEM_UNREF(md); } @@ -146,37 +136,22 @@ static void test_create_many_persistant_metadata(void) { for (i = 0; i < MANY; i++) { GRPC_MDELEM_UNREF(created[i]); } - grpc_mdctx_unref(ctx); + grpc_shutdown(); gpr_free(created); } static void test_spin_creating_the_same_thing(void) { - grpc_mdctx *ctx; - LOG_TEST("test_spin_creating_the_same_thing"); - ctx = grpc_mdctx_create(); - GPR_ASSERT(grpc_mdctx_get_mdtab_count_test_only(ctx) == 0); - GPR_ASSERT(grpc_mdctx_get_mdtab_free_test_only(ctx) == 0); - - GRPC_MDELEM_UNREF(grpc_mdelem_from_strings(ctx, "a", "b")); - GPR_ASSERT(grpc_mdctx_get_mdtab_count_test_only(ctx) == 1); - GPR_ASSERT(grpc_mdctx_get_mdtab_free_test_only(ctx) == 1); - - GRPC_MDELEM_UNREF(grpc_mdelem_from_strings(ctx, "a", "b")); - GPR_ASSERT(grpc_mdctx_get_mdtab_count_test_only(ctx) == 1); - GPR_ASSERT(grpc_mdctx_get_mdtab_free_test_only(ctx) == 1); - - GRPC_MDELEM_UNREF(grpc_mdelem_from_strings(ctx, "a", "b")); - GPR_ASSERT(grpc_mdctx_get_mdtab_count_test_only(ctx) == 1); - GPR_ASSERT(grpc_mdctx_get_mdtab_free_test_only(ctx) == 1); - - grpc_mdctx_unref(ctx); + grpc_init(); + GRPC_MDELEM_UNREF(grpc_mdelem_from_strings("a", "b")); + GRPC_MDELEM_UNREF(grpc_mdelem_from_strings("a", "b")); + GRPC_MDELEM_UNREF(grpc_mdelem_from_strings("a", "b")); + grpc_shutdown(); } static void test_things_stick_around(void) { - grpc_mdctx *ctx; size_t i, j; char *buffer; size_t nstrs = 1000; @@ -186,11 +161,11 @@ static void test_things_stick_around(void) { LOG_TEST("test_things_stick_around"); - ctx = grpc_mdctx_create(); + grpc_init(); for (i = 0; i < nstrs; i++) { gpr_asprintf(&buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%dx", i); - strs[i] = grpc_mdstr_from_string(ctx, buffer); + strs[i] = grpc_mdstr_from_string(buffer); shuf[i] = i; gpr_free(buffer); } @@ -212,60 +187,58 @@ static void test_things_stick_around(void) { GRPC_MDSTR_UNREF(strs[shuf[i]]); for (j = i + 1; j < nstrs; j++) { gpr_asprintf(&buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%dx", shuf[j]); - test = grpc_mdstr_from_string(ctx, buffer); + test = grpc_mdstr_from_string(buffer); GPR_ASSERT(test == strs[shuf[j]]); GRPC_MDSTR_UNREF(test); gpr_free(buffer); } } - grpc_mdctx_unref(ctx); + grpc_shutdown(); gpr_free(strs); gpr_free(shuf); } static void test_slices_work(void) { /* ensure no memory leaks when switching representation from mdstr to slice */ - grpc_mdctx *ctx; grpc_mdstr *str; gpr_slice slice; LOG_TEST("test_slices_work"); - ctx = grpc_mdctx_create(); + grpc_init(); str = grpc_mdstr_from_string( - ctx, "123456789012345678901234567890123456789012345678901234567890"); + "123456789012345678901234567890123456789012345678901234567890"); slice = gpr_slice_ref(str->slice); GRPC_MDSTR_UNREF(str); gpr_slice_unref(slice); str = grpc_mdstr_from_string( - ctx, "123456789012345678901234567890123456789012345678901234567890"); + "123456789012345678901234567890123456789012345678901234567890"); slice = gpr_slice_ref(str->slice); gpr_slice_unref(slice); GRPC_MDSTR_UNREF(str); - grpc_mdctx_unref(ctx); + grpc_shutdown(); } static void test_base64_and_huffman_works(void) { - grpc_mdctx *ctx; grpc_mdstr *str; gpr_slice slice1; gpr_slice slice2; LOG_TEST("test_base64_and_huffman_works"); - ctx = grpc_mdctx_create(); - str = grpc_mdstr_from_string(ctx, "abcdefg"); + grpc_init(); + str = grpc_mdstr_from_string("abcdefg"); slice1 = grpc_mdstr_as_base64_encoded_and_huffman_compressed(str); slice2 = grpc_chttp2_base64_encode_and_huffman_compress(str->slice); GPR_ASSERT(0 == gpr_slice_cmp(slice1, slice2)); gpr_slice_unref(slice2); GRPC_MDSTR_UNREF(str); - grpc_mdctx_unref(ctx); + grpc_shutdown(); } int main(int argc, char **argv) { diff --git a/test/core/transport/stream_op_test.c b/test/core/transport/stream_op_test.c deleted file mode 100644 index 546080deb9..0000000000 --- a/test/core/transport/stream_op_test.c +++ /dev/null @@ -1,116 +0,0 @@ -/* - * - * Copyright 2015, Google Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following disclaimer - * in the documentation and/or other materials provided with the - * distribution. - * * Neither the name of Google Inc. nor the names of its - * contributors may be used to endorse or promote products derived from - * this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - */ - -#include "src/core/transport/stream_op.h" - -#include <string.h> - -#include <grpc/support/log.h> -#include "test/core/util/test_config.h" - -static void assert_slices_equal(gpr_slice a, gpr_slice b) { - GPR_ASSERT(a.refcount == b.refcount); - if (a.refcount) { - GPR_ASSERT(a.data.refcounted.bytes == b.data.refcounted.bytes); - GPR_ASSERT(a.data.refcounted.length == b.data.refcounted.length); - } else { - GPR_ASSERT(a.data.inlined.length == b.data.inlined.length); - GPR_ASSERT(0 == memcmp(a.data.inlined.bytes, b.data.inlined.bytes, - a.data.inlined.length)); - } -} - -int main(int argc, char **argv) { - /* some basic test data */ - gpr_slice test_slice_1 = gpr_slice_malloc(1); - gpr_slice test_slice_2 = gpr_slice_malloc(2); - gpr_slice test_slice_3 = gpr_slice_malloc(3); - gpr_slice test_slice_4 = gpr_slice_malloc(4); - unsigned i; - - grpc_stream_op_buffer buf; - grpc_stream_op_buffer buf2; - - grpc_test_init(argc, argv); - /* initialize one of our buffers */ - grpc_sopb_init(&buf); - /* it should start out empty */ - GPR_ASSERT(buf.nops == 0); - - /* add some data to the buffer */ - grpc_sopb_add_begin_message(&buf, 1, 2); - grpc_sopb_add_slice(&buf, test_slice_1); - grpc_sopb_add_slice(&buf, test_slice_2); - grpc_sopb_add_slice(&buf, test_slice_3); - grpc_sopb_add_slice(&buf, test_slice_4); - grpc_sopb_add_no_op(&buf); - - /* verify that the data went in ok */ - GPR_ASSERT(buf.nops == 6); - GPR_ASSERT(buf.ops[0].type == GRPC_OP_BEGIN_MESSAGE); - GPR_ASSERT(buf.ops[0].data.begin_message.length == 1); - GPR_ASSERT(buf.ops[0].data.begin_message.flags == 2); - GPR_ASSERT(buf.ops[1].type == GRPC_OP_SLICE); - assert_slices_equal(buf.ops[1].data.slice, test_slice_1); - GPR_ASSERT(buf.ops[2].type == GRPC_OP_SLICE); - assert_slices_equal(buf.ops[2].data.slice, test_slice_2); - GPR_ASSERT(buf.ops[3].type == GRPC_OP_SLICE); - assert_slices_equal(buf.ops[3].data.slice, test_slice_3); - GPR_ASSERT(buf.ops[4].type == GRPC_OP_SLICE); - assert_slices_equal(buf.ops[4].data.slice, test_slice_4); - GPR_ASSERT(buf.ops[5].type == GRPC_NO_OP); - - /* initialize the second buffer */ - grpc_sopb_init(&buf2); - /* add a no-op, and then the original buffer */ - grpc_sopb_add_no_op(&buf2); - grpc_sopb_append(&buf2, buf.ops, buf.nops); - /* should be one element bigger than the original */ - GPR_ASSERT(buf2.nops == buf.nops + 1); - GPR_ASSERT(buf2.ops[0].type == GRPC_NO_OP); - /* and the tail should be the same */ - for (i = 0; i < buf.nops; i++) { - GPR_ASSERT(buf2.ops[i + 1].type == buf.ops[i].type); - } - - /* destroy the buffers */ - grpc_sopb_destroy(&buf); - grpc_sopb_destroy(&buf2); - - gpr_slice_unref(test_slice_1); - gpr_slice_unref(test_slice_2); - gpr_slice_unref(test_slice_3); - gpr_slice_unref(test_slice_4); - - return 0; -} diff --git a/test/core/util/reconnect_server.c b/test/core/util/reconnect_server.c index ee481ef674..28e521221b 100644 --- a/test/core/util/reconnect_server.c +++ b/test/core/util/reconnect_server.c @@ -44,6 +44,7 @@ #include "src/core/iomgr/sockaddr.h" #include "src/core/iomgr/tcp_server.h" #include "test/core/util/port.h" +#include "test/core/util/test_tcp_server.h" static void pretty_print_backoffs(reconnect_server *server) { gpr_timespec diff; @@ -102,47 +103,18 @@ static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp) { } void reconnect_server_init(reconnect_server *server) { - grpc_init(); - server->tcp_server = NULL; - grpc_pollset_init(&server->pollset); - server->pollsets[0] = &server->pollset; + test_tcp_server_init(&server->tcp_server, on_connect, server); server->head = NULL; server->tail = NULL; server->peer = NULL; } void reconnect_server_start(reconnect_server *server, int port) { - struct sockaddr_in addr; - int port_added; - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - - addr.sin_family = AF_INET; - addr.sin_port = htons((gpr_uint16)port); - memset(&addr.sin_addr, 0, sizeof(addr.sin_addr)); - - server->tcp_server = grpc_tcp_server_create(); - port_added = - grpc_tcp_server_add_port(server->tcp_server, &addr, sizeof(addr)); - GPR_ASSERT(port_added == port); - - grpc_tcp_server_start(&exec_ctx, server->tcp_server, server->pollsets, 1, - on_connect, server); - gpr_log(GPR_INFO, "reconnect tcp server listening on 0.0.0.0:%d", port); - - grpc_exec_ctx_finish(&exec_ctx); + test_tcp_server_start(&server->tcp_server, port); } void reconnect_server_poll(reconnect_server *server, int seconds) { - grpc_pollset_worker worker; - gpr_timespec deadline = - gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), - gpr_time_from_seconds(seconds, GPR_TIMESPAN)); - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - gpr_mu_lock(GRPC_POLLSET_MU(&server->pollset)); - grpc_pollset_work(&exec_ctx, &server->pollset, &worker, - gpr_now(GPR_CLOCK_MONOTONIC), deadline); - gpr_mu_unlock(GRPC_POLLSET_MU(&server->pollset)); - grpc_exec_ctx_finish(&exec_ctx); + test_tcp_server_poll(&server->tcp_server, seconds); } void reconnect_server_clear_timestamps(reconnect_server *server) { @@ -157,18 +129,7 @@ void reconnect_server_clear_timestamps(reconnect_server *server) { server->peer = NULL; } -static void do_nothing(grpc_exec_ctx *exec_ctx, void *ignored, int success) {} - void reconnect_server_destroy(reconnect_server *server) { - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_closure do_nothing_closure[2]; - grpc_closure_init(&do_nothing_closure[0], do_nothing, NULL); - grpc_closure_init(&do_nothing_closure[1], do_nothing, NULL); - grpc_tcp_server_destroy(&exec_ctx, server->tcp_server, - &do_nothing_closure[0]); reconnect_server_clear_timestamps(server); - grpc_pollset_shutdown(&exec_ctx, &server->pollset, &do_nothing_closure[1]); - grpc_exec_ctx_finish(&exec_ctx); - grpc_pollset_destroy(&server->pollset); - grpc_shutdown(); + test_tcp_server_destroy(&server->tcp_server); } diff --git a/test/core/util/reconnect_server.h b/test/core/util/reconnect_server.h index 8a278e0c7a..e2e6a02461 100644 --- a/test/core/util/reconnect_server.h +++ b/test/core/util/reconnect_server.h @@ -36,7 +36,7 @@ #include <grpc/support/sync.h> #include <grpc/support/time.h> -#include "src/core/iomgr/tcp_server.h" +#include "test/core/util/test_tcp_server.h" #ifdef __cplusplus extern "C" { @@ -48,9 +48,7 @@ typedef struct timestamp_list { } timestamp_list; typedef struct reconnect_server { - grpc_tcp_server *tcp_server; - grpc_pollset pollset; - grpc_pollset *pollsets[1]; + test_tcp_server tcp_server; timestamp_list *head; timestamp_list *tail; char *peer; diff --git a/test/core/util/test_tcp_server.c b/test/core/util/test_tcp_server.c new file mode 100644 index 0000000000..c700d3637f --- /dev/null +++ b/test/core/util/test_tcp_server.c @@ -0,0 +1,120 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include "test/core/util/test_tcp_server.h" + +#include <grpc/grpc.h> +#include <grpc/support/alloc.h> +#include <grpc/support/host_port.h> +#include <grpc/support/log.h> +#include <grpc/support/sync.h> +#include <grpc/support/time.h> +#include <string.h> +#include "src/core/iomgr/endpoint.h" +#include "src/core/iomgr/sockaddr.h" +#include "src/core/iomgr/tcp_server.h" +#include "test/core/util/port.h" + +void test_tcp_server_init(test_tcp_server *server, + grpc_tcp_server_cb on_connect, void *user_data) { + grpc_init(); + server->tcp_server = NULL; + server->shutdown = 0; + grpc_pollset_init(&server->pollset); + server->pollsets[0] = &server->pollset; + server->on_connect = on_connect; + server->cb_data = user_data; +} + +void test_tcp_server_start(test_tcp_server *server, int port) { + struct sockaddr_in addr; + grpc_tcp_listener *listener; + int port_added; + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + + addr.sin_family = AF_INET; + addr.sin_port = htons((gpr_uint16)port); + memset(&addr.sin_addr, 0, sizeof(addr.sin_addr)); + + server->tcp_server = grpc_tcp_server_create(); + listener = grpc_tcp_server_add_port(server->tcp_server, &addr, sizeof(addr)); + port_added = grpc_tcp_listener_get_port(listener); + GPR_ASSERT(port_added == port); + + grpc_tcp_server_start(&exec_ctx, server->tcp_server, server->pollsets, 1, + server->on_connect, server->cb_data); + gpr_log(GPR_INFO, "test tcp server listening on 0.0.0.0:%d", port); + + grpc_exec_ctx_finish(&exec_ctx); +} + +void test_tcp_server_poll(test_tcp_server *server, int seconds) { + grpc_pollset_worker worker; + gpr_timespec deadline = + gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), + gpr_time_from_seconds(seconds, GPR_TIMESPAN)); + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + gpr_mu_lock(GRPC_POLLSET_MU(&server->pollset)); + grpc_pollset_work(&exec_ctx, &server->pollset, &worker, + gpr_now(GPR_CLOCK_MONOTONIC), deadline); + gpr_mu_unlock(GRPC_POLLSET_MU(&server->pollset)); + grpc_exec_ctx_finish(&exec_ctx); +} + +static void on_server_destroyed(grpc_exec_ctx *exec_ctx, void *data, + int success) { + test_tcp_server *server = data; + server->shutdown = 1; +} + +static void do_nothing(grpc_exec_ctx *exec_ctx, void *arg, int success) {} + +void test_tcp_server_destroy(test_tcp_server *server) { + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + gpr_timespec shutdown_deadline; + grpc_closure server_shutdown_cb; + grpc_closure do_nothing_cb; + grpc_closure_init(&server_shutdown_cb, on_server_destroyed, server); + grpc_closure_init(&do_nothing_cb, do_nothing, NULL); + grpc_tcp_server_destroy(&exec_ctx, server->tcp_server, &server_shutdown_cb); + shutdown_deadline = gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), + gpr_time_from_seconds(5, GPR_TIMESPAN)); + while (!server->shutdown && + gpr_time_cmp(gpr_now(GPR_CLOCK_MONOTONIC), shutdown_deadline) < 0) { + test_tcp_server_poll(server, 1); + } + grpc_pollset_shutdown(&exec_ctx, &server->pollset, &do_nothing_cb); + grpc_exec_ctx_finish(&exec_ctx); + grpc_pollset_destroy(&server->pollset); + grpc_shutdown(); +} diff --git a/test/core/util/test_tcp_server.h b/test/core/util/test_tcp_server.h new file mode 100644 index 0000000000..deb65eef11 --- /dev/null +++ b/test/core/util/test_tcp_server.h @@ -0,0 +1,55 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#ifndef GRPC_TEST_CORE_UTIL_TEST_TCP_SERVER_H +#define GRPC_TEST_CORE_UTIL_TEST_TCP_SERVER_H + +#include <grpc/support/sync.h> +#include "src/core/iomgr/tcp_server.h" + +typedef struct test_tcp_server { + grpc_tcp_server *tcp_server; + int shutdown; + grpc_pollset pollset; + grpc_pollset *pollsets[1]; + grpc_tcp_server_cb on_connect; + void *cb_data; +} test_tcp_server; + +void test_tcp_server_init(test_tcp_server *server, + grpc_tcp_server_cb on_connect, void *user_data); +void test_tcp_server_start(test_tcp_server *server, int port); +void test_tcp_server_poll(test_tcp_server *server, int seconds); +void test_tcp_server_destroy(test_tcp_server *server); + +#endif /* GRPC_TEST_CORE_UTIL_TEST_TCP_SERVER_H */ diff --git a/test/cpp/client/credentials_test.cc b/test/cpp/client/credentials_test.cc index 743ad065d1..418a54439a 100644 --- a/test/cpp/client/credentials_test.cc +++ b/test/cpp/client/credentials_test.cc @@ -46,8 +46,8 @@ class CredentialsTest : public ::testing::Test { }; TEST_F(CredentialsTest, InvalidGoogleRefreshToken) { - std::shared_ptr<Credentials> bad1 = GoogleRefreshTokenCredentials(""); - EXPECT_EQ(static_cast<Credentials*>(nullptr), bad1.get()); + std::shared_ptr<CallCredentials> bad1 = GoogleRefreshTokenCredentials(""); + EXPECT_EQ(static_cast<CallCredentials*>(nullptr), bad1.get()); } } // namespace testing diff --git a/test/cpp/client/channel_arguments_test.cc b/test/cpp/common/channel_arguments_test.cc index 3d75e7b0e6..e010d375cf 100644 --- a/test/cpp/client/channel_arguments_test.cc +++ b/test/cpp/common/channel_arguments_test.cc @@ -115,6 +115,22 @@ TEST_F(ChannelArgumentsTest, SetString) { } } +TEST_F(ChannelArgumentsTest, SetPointer) { + grpc_channel_args args; + ChannelArguments channel_args; + // Empty arguments. + SetChannelArgs(channel_args, &args); + EXPECT_EQ(static_cast<size_t>(0), args.num_args); + + grpc::string key("key0"); + channel_args.SetPointer(key, &key); + SetChannelArgs(channel_args, &args); + EXPECT_EQ(static_cast<size_t>(1), args.num_args); + EXPECT_EQ(GRPC_ARG_POINTER, args.args[0].type); + EXPECT_STREQ("key0", args.args[0].key); + EXPECT_EQ(&key, args.args[0].value.pointer.p); +} + } // namespace testing } // namespace grpc diff --git a/test/cpp/end2end/async_end2end_test.cc b/test/cpp/end2end/async_end2end_test.cc index cfb6c21edc..74290c36d2 100644 --- a/test/cpp/end2end/async_end2end_test.cc +++ b/test/cpp/end2end/async_end2end_test.cc @@ -199,7 +199,7 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<bool> { void ResetStub() { std::shared_ptr<Channel> channel = - CreateChannel(server_address_.str(), InsecureCredentials()); + CreateChannel(server_address_.str(), InsecureChannelCredentials()); stub_ = grpc::cpp::test::util::TestService::NewStub(channel); } @@ -749,7 +749,7 @@ TEST_P(AsyncEnd2endTest, ServerCheckDone) { TEST_P(AsyncEnd2endTest, UnimplementedRpc) { std::shared_ptr<Channel> channel = - CreateChannel(server_address_.str(), InsecureCredentials()); + CreateChannel(server_address_.str(), InsecureChannelCredentials()); std::unique_ptr<grpc::cpp::test::util::UnimplementedService::Stub> stub; stub = grpc::cpp::test::util::UnimplementedService::NewStub(channel); EchoRequest send_request; diff --git a/test/cpp/end2end/client_crash_test.cc b/test/cpp/end2end/client_crash_test.cc index 058e696166..116785bbf2 100644 --- a/test/cpp/end2end/client_crash_test.cc +++ b/test/cpp/end2end/client_crash_test.cc @@ -74,7 +74,7 @@ class CrashTest : public ::testing::Test { })); GPR_ASSERT(server_); return grpc::cpp::test::util::TestService::NewStub( - CreateChannel(addr, InsecureCredentials())); + CreateChannel(addr, InsecureChannelCredentials())); } void KillServer() { server_.reset(); } diff --git a/test/cpp/end2end/end2end_test.cc b/test/cpp/end2end/end2end_test.cc index 89a556c587..dd02c4ac16 100644 --- a/test/cpp/end2end/end2end_test.cc +++ b/test/cpp/end2end/end2end_test.cc @@ -119,10 +119,13 @@ class TestMetadataCredentialsPlugin : public MetadataCredentialsPlugin { bool IsBlocking() const GRPC_OVERRIDE { return is_blocking_; } - Status GetMetadata(grpc::string_ref service_url, + Status GetMetadata(grpc::string_ref service_url, grpc::string_ref method_name, + const grpc::AuthContext& channel_auth_context, std::multimap<grpc::string, grpc::string>* metadata) GRPC_OVERRIDE { EXPECT_GT(service_url.length(), 0UL); + EXPECT_GT(method_name.length(), 0UL); + EXPECT_TRUE(channel_auth_context.IsPeerAuthenticated()); EXPECT_TRUE(metadata != nullptr); if (is_successful_) { metadata->insert(std::make_pair(kMetadataKey, metadata_value_)); @@ -146,13 +149,13 @@ class TestAuthMetadataProcessor : public AuthMetadataProcessor { TestAuthMetadataProcessor(bool is_blocking) : is_blocking_(is_blocking) {} - std::shared_ptr<Credentials> GetCompatibleClientCreds() { + std::shared_ptr<CallCredentials> GetCompatibleClientCreds() { return MetadataCredentialsFromPlugin( std::unique_ptr<MetadataCredentialsPlugin>( new TestMetadataCredentialsPlugin(kGoodGuy, is_blocking_, true))); } - std::shared_ptr<Credentials> GetIncompatibleClientCreds() { + std::shared_ptr<CallCredentials> GetIncompatibleClientCreds() { return MetadataCredentialsFromPlugin( std::unique_ptr<MetadataCredentialsPlugin>( new TestMetadataCredentialsPlugin("Mr Hyde", is_blocking_, true))); @@ -407,7 +410,7 @@ class End2endTest : public ::testing::TestWithParam<TestScenario> { } EXPECT_TRUE(is_server_started_); ChannelArguments args; - auto channel_creds = InsecureCredentials(); + auto channel_creds = InsecureChannelCredentials(); if (GetParam().use_tls) { SslCredentialsOptions ssl_opts = {test_root_cert, "", ""}; args.SetSslTargetNameOverride("foo.test.google.fr"); @@ -429,7 +432,7 @@ class End2endTest : public ::testing::TestWithParam<TestScenario> { builder.RegisterService(proxy_service_.get()); proxy_server_ = builder.BuildAndStart(); - channel_ = CreateChannel(proxyaddr.str(), InsecureCredentials()); + channel_ = CreateChannel(proxyaddr.str(), InsecureChannelCredentials()); } stub_ = grpc::cpp::test::util::TestService::NewStub(channel_); @@ -575,6 +578,18 @@ void CancelRpc(ClientContext* context, int delay_us, TestServiceImpl* service) { context->TryCancel(); } +TEST_P(End2endTest, CancelRpcBeforeStart) { + ResetStub(); + EchoRequest request; + EchoResponse response; + ClientContext context; + request.set_message("hello"); + context.TryCancel(); + Status s = stub_->Echo(&context, request, &response); + EXPECT_EQ("", response.message()); + EXPECT_EQ(grpc::StatusCode::CANCELLED, s.error_code()); +} + // Client cancels request stream after sending two messages TEST_P(End2endTest, ClientCancelsRequestStream) { ResetStub(); @@ -751,7 +766,8 @@ TEST_P(End2endTest, ChannelStateTimeout) { std::ostringstream server_address; server_address << "127.0.0.1:" << port; // Channel to non-existing server - auto channel = CreateChannel(server_address.str(), InsecureCredentials()); + auto channel = + CreateChannel(server_address.str(), InsecureChannelCredentials()); // Start IDLE EXPECT_EQ(GRPC_CHANNEL_IDLE, channel->GetState(true)); @@ -971,33 +987,6 @@ TEST_P(SecureEnd2endTest, SimpleRpcWithHost) { EXPECT_TRUE(s.ok()); } -// rpc and stream should fail on bad credentials. -TEST_P(SecureEnd2endTest, BadCredentials) { - std::shared_ptr<Credentials> bad_creds = GoogleRefreshTokenCredentials(""); - EXPECT_EQ(static_cast<Credentials*>(nullptr), bad_creds.get()); - std::shared_ptr<Channel> channel = - CreateChannel(server_address_.str(), bad_creds); - std::unique_ptr<grpc::cpp::test::util::TestService::Stub> stub( - grpc::cpp::test::util::TestService::NewStub(channel)); - EchoRequest request; - EchoResponse response; - ClientContext context; - request.set_message("Hello"); - - Status s = stub->Echo(&context, request, &response); - EXPECT_EQ("", response.message()); - EXPECT_FALSE(s.ok()); - EXPECT_EQ(StatusCode::INVALID_ARGUMENT, s.error_code()); - EXPECT_EQ("Invalid credentials.", s.error_message()); - - ClientContext context2; - auto stream = stub->BidiStream(&context2); - s = stream->Finish(); - EXPECT_FALSE(s.ok()); - EXPECT_EQ(StatusCode::INVALID_ARGUMENT, s.error_code()); - EXPECT_EQ("Invalid credentials.", s.error_message()); -} - bool MetadataContains( const std::multimap<grpc::string_ref, grpc::string_ref>& metadata, const grpc::string& key, const grpc::string& value) { @@ -1055,7 +1044,7 @@ TEST_P(SecureEnd2endTest, SetPerCallCredentials) { EchoRequest request; EchoResponse response; ClientContext context; - std::shared_ptr<Credentials> creds = + std::shared_ptr<CallCredentials> creds = GoogleIAMCredentials("fake_token", "fake_selector"); context.set_credentials(creds); request.set_message("Hello"); @@ -1072,30 +1061,15 @@ TEST_P(SecureEnd2endTest, SetPerCallCredentials) { "fake_selector")); } -TEST_P(SecureEnd2endTest, InsecurePerCallCredentials) { - ResetStub(); - EchoRequest request; - EchoResponse response; - ClientContext context; - std::shared_ptr<Credentials> creds = InsecureCredentials(); - context.set_credentials(creds); - request.set_message("Hello"); - request.mutable_param()->set_echo_metadata(true); - - Status s = stub_->Echo(&context, request, &response); - EXPECT_EQ(StatusCode::CANCELLED, s.error_code()); - EXPECT_EQ("Failed to set credentials to rpc.", s.error_message()); -} - TEST_P(SecureEnd2endTest, OverridePerCallCredentials) { ResetStub(); EchoRequest request; EchoResponse response; ClientContext context; - std::shared_ptr<Credentials> creds1 = + std::shared_ptr<CallCredentials> creds1 = GoogleIAMCredentials("fake_token1", "fake_selector1"); context.set_credentials(creds1); - std::shared_ptr<Credentials> creds2 = + std::shared_ptr<CallCredentials> creds2 = GoogleIAMCredentials("fake_token2", "fake_selector2"); context.set_credentials(creds2); request.set_message("Hello"); @@ -1217,14 +1191,14 @@ TEST_P(SecureEnd2endTest, ClientAuthContext) { } INSTANTIATE_TEST_CASE_P(End2end, End2endTest, - ::testing::Values(TestScenario(false, true), - TestScenario(false, false))); + ::testing::Values(TestScenario(false, false), + TestScenario(false, true))); INSTANTIATE_TEST_CASE_P(ProxyEnd2end, ProxyEnd2endTest, - ::testing::Values(TestScenario(true, true), - TestScenario(true, false), + ::testing::Values(TestScenario(false, false), TestScenario(false, true), - TestScenario(false, false))); + TestScenario(true, false), + TestScenario(true, true))); INSTANTIATE_TEST_CASE_P(SecureEnd2end, SecureEnd2endTest, ::testing::Values(TestScenario(false, true))); diff --git a/test/cpp/end2end/generic_end2end_test.cc b/test/cpp/end2end/generic_end2end_test.cc index 6a46916728..082119d6d5 100644 --- a/test/cpp/end2end/generic_end2end_test.cc +++ b/test/cpp/end2end/generic_end2end_test.cc @@ -120,7 +120,7 @@ class GenericEnd2endTest : public ::testing::Test { void ResetStub() { std::shared_ptr<Channel> channel = - CreateChannel(server_address_.str(), InsecureCredentials()); + CreateChannel(server_address_.str(), InsecureChannelCredentials()); generic_stub_.reset(new GenericStub(channel)); } diff --git a/test/cpp/end2end/mock_test.cc b/test/cpp/end2end/mock_test.cc index 80057d893e..bd34cfba67 100644 --- a/test/cpp/end2end/mock_test.cc +++ b/test/cpp/end2end/mock_test.cc @@ -244,7 +244,7 @@ class MockTest : public ::testing::Test { void ResetStub() { std::shared_ptr<Channel> channel = - CreateChannel(server_address_.str(), InsecureCredentials()); + CreateChannel(server_address_.str(), InsecureChannelCredentials()); stub_ = grpc::cpp::test::util::TestService::NewStub(channel); } diff --git a/test/cpp/end2end/server_crash_test_client.cc b/test/cpp/end2end/server_crash_test_client.cc index 17869362c2..2baefcbf42 100644 --- a/test/cpp/end2end/server_crash_test_client.cc +++ b/test/cpp/end2end/server_crash_test_client.cc @@ -58,7 +58,7 @@ using namespace gflags; int main(int argc, char** argv) { ParseCommandLineFlags(&argc, &argv, true); auto stub = grpc::cpp::test::util::TestService::NewStub( - grpc::CreateChannel(FLAGS_address, grpc::InsecureCredentials())); + grpc::CreateChannel(FLAGS_address, grpc::InsecureChannelCredentials())); EchoRequest request; EchoResponse response; diff --git a/test/cpp/end2end/shutdown_test.cc b/test/cpp/end2end/shutdown_test.cc index 0549bb8b5f..b1b18b2a7f 100644 --- a/test/cpp/end2end/shutdown_test.cc +++ b/test/cpp/end2end/shutdown_test.cc @@ -93,7 +93,7 @@ class ShutdownTest : public ::testing::Test { void ResetStub() { string target = "dns:localhost:" + to_string(port_); - channel_ = CreateChannel(target, InsecureCredentials()); + channel_ = CreateChannel(target, InsecureChannelCredentials()); stub_ = grpc::cpp::test::util::TestService::NewStub(channel_); } diff --git a/test/cpp/end2end/streaming_throughput_test.cc b/test/cpp/end2end/streaming_throughput_test.cc index d4ab1486cc..b7e103a1ae 100644 --- a/test/cpp/end2end/streaming_throughput_test.cc +++ b/test/cpp/end2end/streaming_throughput_test.cc @@ -160,7 +160,7 @@ class End2endTest : public ::testing::Test { void ResetStub() { std::shared_ptr<Channel> channel = - CreateChannel(server_address_.str(), InsecureCredentials()); + CreateChannel(server_address_.str(), InsecureChannelCredentials()); stub_ = grpc::cpp::test::util::TestService::NewStub(channel); } diff --git a/test/cpp/end2end/thread_stress_test.cc b/test/cpp/end2end/thread_stress_test.cc index 75a07d89c5..fb82b96135 100644 --- a/test/cpp/end2end/thread_stress_test.cc +++ b/test/cpp/end2end/thread_stress_test.cc @@ -190,7 +190,7 @@ class End2endTest : public ::testing::Test { void ResetStub() { std::shared_ptr<Channel> channel = - CreateChannel(server_address_.str(), InsecureCredentials()); + CreateChannel(server_address_.str(), InsecureChannelCredentials()); stub_ = grpc::cpp::test::util::TestService::NewStub(channel); } diff --git a/test/cpp/end2end/zookeeper_test.cc b/test/cpp/end2end/zookeeper_test.cc index d4c7f0489f..e88c0f9c68 100644 --- a/test/cpp/end2end/zookeeper_test.cc +++ b/test/cpp/end2end/zookeeper_test.cc @@ -157,7 +157,7 @@ class ZookeeperTest : public ::testing::Test { void ResetStub() { string target = "zookeeper://" + zookeeper_address_ + "/test"; - channel_ = CreateChannel(target, InsecureCredentials()); + channel_ = CreateChannel(target, InsecureChannelCredentials()); stub_ = std::move(grpc::cpp::test::util::TestService::NewStub(channel_)); } diff --git a/test/cpp/interop/client_helper.cc b/test/cpp/interop/client_helper.cc index 61b46d25aa..5caf0f2d1d 100644 --- a/test/cpp/interop/client_helper.cc +++ b/test/cpp/interop/client_helper.cc @@ -76,11 +76,11 @@ grpc::string GetServiceAccountJsonKey() { } grpc::string GetOauth2AccessToken() { - std::shared_ptr<Credentials> creds = GoogleComputeEngineCredentials(); - SecureCredentials* secure_creds = - dynamic_cast<SecureCredentials*>(creds.get()); + std::shared_ptr<CallCredentials> creds = GoogleComputeEngineCredentials(); + SecureCallCredentials* secure_creds = + dynamic_cast<SecureCallCredentials*>(creds.get()); GPR_ASSERT(secure_creds != nullptr); - grpc_credentials* c_creds = secure_creds->GetRawCreds(); + grpc_call_credentials* c_creds = secure_creds->GetRawCreds(); char* token = grpc_test_fetch_oauth2_token_with_credentials(c_creds); GPR_ASSERT(token != nullptr); gpr_log(GPR_INFO, "Get raw oauth2 access token: %s", token); @@ -98,13 +98,13 @@ std::shared_ptr<Channel> CreateChannelForTestCase( FLAGS_server_port); if (test_case == "compute_engine_creds") { - std::shared_ptr<Credentials> creds; + std::shared_ptr<CallCredentials> creds; GPR_ASSERT(FLAGS_use_tls); creds = GoogleComputeEngineCredentials(); return CreateTestChannel(host_port, FLAGS_server_host_override, FLAGS_use_tls, !FLAGS_use_test_ca, creds); } else if (test_case == "jwt_token_creds") { - std::shared_ptr<Credentials> creds; + std::shared_ptr<CallCredentials> creds; GPR_ASSERT(FLAGS_use_tls); grpc::string json_key = GetServiceAccountJsonKey(); std::chrono::seconds token_lifetime = std::chrono::hours(1); @@ -114,7 +114,7 @@ std::shared_ptr<Channel> CreateChannelForTestCase( FLAGS_use_tls, !FLAGS_use_test_ca, creds); } else if (test_case == "oauth2_auth_token") { grpc::string raw_token = GetOauth2AccessToken(); - std::shared_ptr<Credentials> creds = AccessTokenCredentials(raw_token); + std::shared_ptr<CallCredentials> creds = AccessTokenCredentials(raw_token); return CreateTestChannel(host_port, FLAGS_server_host_override, FLAGS_use_tls, !FLAGS_use_test_ca, creds); } else { diff --git a/test/cpp/interop/interop_client.cc b/test/cpp/interop/interop_client.cc index 96502e5879..6340007fa4 100644 --- a/test/cpp/interop/interop_client.cc +++ b/test/cpp/interop/interop_client.cc @@ -46,7 +46,7 @@ #include <grpc++/client_context.h> #include <grpc++/security/credentials.h> -#include "src/core/transport/stream_op.h" +#include "src/core/transport/byte_stream.h" #include "test/cpp/interop/client_helper.h" #include "test/proto/test.grpc.pb.h" #include "test/proto/empty.grpc.pb.h" @@ -244,7 +244,7 @@ void InteropClient::DoPerRpcCreds(const grpc::string& json_key) { ClientContext context; std::chrono::seconds token_lifetime = std::chrono::hours(1); - std::shared_ptr<Credentials> creds = + std::shared_ptr<CallCredentials> creds = ServiceAccountJWTAccessCredentials(json_key, token_lifetime.count()); context.set_credentials(creds); diff --git a/test/cpp/interop/metrics_client.cc b/test/cpp/interop/metrics_client.cc new file mode 100644 index 0000000000..1bd2a2fd78 --- /dev/null +++ b/test/cpp/interop/metrics_client.cc @@ -0,0 +1,103 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *is % allowed in string + */ + +#include <memory> +#include <string> + +#include <gflags/gflags.h> +#include <grpc++/grpc++.h> + +#include "test/cpp/util/metrics_server.h" +#include "test/cpp/util/test_config.h" +#include "test/proto/metrics.grpc.pb.h" +#include "test/proto/metrics.pb.h" + +DEFINE_string(metrics_server_address, "", + "The metrics server addresses in the fomrat <hostname>:<port>"); + +using grpc::testing::EmptyMessage; +using grpc::testing::GaugeResponse; +using grpc::testing::MetricsService; +using grpc::testing::MetricsServiceImpl; + +void PrintMetrics(grpc::string& server_address) { + gpr_log(GPR_INFO, "creating a channel to %s", server_address.c_str()); + std::shared_ptr<grpc::Channel> channel( + grpc::CreateChannel(server_address, grpc::InsecureChannelCredentials())); + + std::unique_ptr<MetricsService::Stub> stub(MetricsService::NewStub(channel)); + + grpc::ClientContext context; + EmptyMessage message; + + std::unique_ptr<grpc::ClientReader<GaugeResponse>> reader( + stub->GetAllGauges(&context, message)); + + GaugeResponse gauge_response; + long overall_qps = 0; + int idx = 0; + while (reader->Read(&gauge_response)) { + if (gauge_response.value_case() == GaugeResponse::kLongValue) { + gpr_log(GPR_INFO, "Gauge: %d (%s: %ld)", ++idx, + gauge_response.name().c_str(), gauge_response.long_value()); + overall_qps += gauge_response.long_value(); + } else { + gpr_log(GPR_INFO, "Gauge %s is not a long value", + gauge_response.name().c_str()); + } + } + + gpr_log(GPR_INFO, "OVERALL: %ld", overall_qps); + + const grpc::Status status = reader->Finish(); + if (!status.ok()) { + gpr_log(GPR_ERROR, "Error in getting metrics from the client"); + } +} + +int main(int argc, char** argv) { + grpc::testing::InitTest(&argc, &argv, true); + + // Make sure server_addresses flag is not empty + if (FLAGS_metrics_server_address.empty()) { + gpr_log( + GPR_ERROR, + "Cannot connect to the Metrics server. Please pass the address of the" + "metrics server to connect to via the 'metrics_server_address' flag"); + return 1; + } + + PrintMetrics(FLAGS_metrics_server_address); + + return 0; +} diff --git a/test/cpp/interop/reconnect_interop_server.cc b/test/cpp/interop/reconnect_interop_server.cc index f52417bae0..92b5bf4dfa 100644 --- a/test/cpp/interop/reconnect_interop_server.cc +++ b/test/cpp/interop/reconnect_interop_server.cc @@ -75,12 +75,15 @@ static bool got_sigint = false; class ReconnectServiceImpl : public ReconnectService::Service { public: explicit ReconnectServiceImpl(int retry_port) - : retry_port_(retry_port), serving_(false), shutdown_(false) { + : retry_port_(retry_port), + serving_(false), + server_started_(false), + shutdown_(false) { reconnect_server_init(&tcp_server_); } ~ReconnectServiceImpl() { - if (tcp_server_.tcp_server) { + if (server_started_) { reconnect_server_destroy(&tcp_server_); } } @@ -88,6 +91,7 @@ class ReconnectServiceImpl : public ReconnectService::Service { void Poll(int seconds) { reconnect_server_poll(&tcp_server_, seconds); } Status Start(ServerContext* context, const Empty* request, Empty* response) { + bool start_server = true; std::unique_lock<std::mutex> lock(mu_); while (serving_ && !shutdown_) { cv_.wait(lock); @@ -96,9 +100,14 @@ class ReconnectServiceImpl : public ReconnectService::Service { return Status(grpc::StatusCode::UNAVAILABLE, "shutting down"); } serving_ = true; + if (server_started_) { + start_server = false; + } else { + server_started_ = true; + } lock.unlock(); - if (!tcp_server_.tcp_server) { + if (start_server) { reconnect_server_start(&tcp_server_, retry_port_); } else { reconnect_server_clear_timestamps(&tcp_server_); @@ -152,6 +161,7 @@ class ReconnectServiceImpl : public ReconnectService::Service { int retry_port_; reconnect_server tcp_server_; bool serving_; + bool server_started_; bool shutdown_; std::mutex mu_; std::condition_variable cv_; diff --git a/test/cpp/interop/stress_interop_client.cc b/test/cpp/interop/stress_interop_client.cc index f8c55cf795..5d2951e3ed 100644 --- a/test/cpp/interop/stress_interop_client.cc +++ b/test/cpp/interop/stress_interop_client.cc @@ -40,6 +40,7 @@ #include <grpc++/create_channel.h> #include "test/cpp/interop/interop_client.h" +#include "test/cpp/util/metrics_server.h" namespace grpc { namespace testing { @@ -81,21 +82,19 @@ TestCaseType WeightedRandomTestSelector::GetNextTest() const { StressTestInteropClient::StressTestInteropClient( int test_id, const grpc::string& server_address, + std::shared_ptr<Channel> channel, const WeightedRandomTestSelector& test_selector, long test_duration_secs, - long sleep_duration_ms) + long sleep_duration_ms, long metrics_collection_interval_secs) : test_id_(test_id), server_address_(server_address), + channel_(channel), + interop_client_(new InteropClient(channel, false)), test_selector_(test_selector), test_duration_secs_(test_duration_secs), - sleep_duration_ms_(sleep_duration_ms) { - // TODO(sreek): This will change once we add support for other tests - // that won't work with InsecureCredentials() - std::shared_ptr<Channel> channel( - CreateChannel(server_address, InsecureCredentials())); - interop_client_.reset(new InteropClient(channel, false)); -} + sleep_duration_ms_(sleep_duration_ms), + metrics_collection_interval_secs_(metrics_collection_interval_secs) {} -void StressTestInteropClient::MainLoop() { +void StressTestInteropClient::MainLoop(std::shared_ptr<Gauge> qps_gauge) { gpr_log(GPR_INFO, "Running test %d. ServerAddr: %s", test_id_, server_address_.c_str()); @@ -104,21 +103,38 @@ void StressTestInteropClient::MainLoop() { gpr_time_from_seconds(test_duration_secs_, GPR_TIMESPAN)); gpr_timespec current_time = gpr_now(GPR_CLOCK_REALTIME); + gpr_timespec next_stat_collection_time = current_time; + gpr_timespec collection_interval = + gpr_time_from_seconds(metrics_collection_interval_secs_, GPR_TIMESPAN); + long num_calls_per_interval = 0; + while (test_duration_secs_ < 0 || - gpr_time_cmp(current_time, test_end_time) < 0) { + gpr_time_cmp(gpr_now(GPR_CLOCK_REALTIME), test_end_time) < 0) { // Select the test case to execute based on the weights and execute it TestCaseType test_case = test_selector_.GetNextTest(); gpr_log(GPR_INFO, "%d - Executing the test case %d", test_id_, test_case); RunTest(test_case); + num_calls_per_interval++; + + // See if its time to collect stats yet + current_time = gpr_now(GPR_CLOCK_REALTIME); + if (gpr_time_cmp(next_stat_collection_time, current_time) < 0) { + qps_gauge->Set(num_calls_per_interval / + metrics_collection_interval_secs_); + + num_calls_per_interval = 0; + next_stat_collection_time = + gpr_time_add(current_time, collection_interval); + } + // Sleep between successive calls if needed if (sleep_duration_ms_ > 0) { - gpr_timespec sleep_time = gpr_time_add( - current_time, gpr_time_from_millis(sleep_duration_ms_, GPR_TIMESPAN)); + gpr_timespec sleep_time = + gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), + gpr_time_from_millis(sleep_duration_ms_, GPR_TIMESPAN)); gpr_sleep_until(sleep_time); } - - current_time = gpr_now(GPR_CLOCK_REALTIME); } } diff --git a/test/cpp/interop/stress_interop_client.h b/test/cpp/interop/stress_interop_client.h index 36261e501f..6fd303d6b7 100644 --- a/test/cpp/interop/stress_interop_client.h +++ b/test/cpp/interop/stress_interop_client.h @@ -41,6 +41,7 @@ #include <grpc++/create_channel.h> #include "test/cpp/interop/interop_client.h" +#include "test/cpp/util/metrics_server.h" namespace grpc { namespace testing { @@ -84,20 +85,26 @@ class WeightedRandomTestSelector { class StressTestInteropClient { public: StressTestInteropClient(int test_id, const grpc::string& server_address, + std::shared_ptr<Channel> channel, const WeightedRandomTestSelector& test_selector, - long test_duration_secs, long sleep_duration_ms); + long test_duration_secs, long sleep_duration_ms, + long metrics_collection_interval_secs); - void MainLoop(); // The main function. Use this as the thread entry point. + // The main function. Use this as the thread entry point. + // qps_gauge is the Gauge to record the requests per second metric + void MainLoop(std::shared_ptr<Gauge> qps_gauge); private: void RunTest(TestCaseType test_case); int test_id_; - std::unique_ptr<InteropClient> interop_client_; const grpc::string& server_address_; + std::shared_ptr<Channel> channel_; + std::unique_ptr<InteropClient> interop_client_; const WeightedRandomTestSelector& test_selector_; long test_duration_secs_; long sleep_duration_ms_; + long metrics_collection_interval_secs_; }; } // namespace testing diff --git a/test/cpp/interop/stress_test.cc b/test/cpp/interop/stress_test.cc index 5d1419728e..934f4f5722 100644 --- a/test/cpp/interop/stress_test.cc +++ b/test/cpp/interop/stress_test.cc @@ -38,13 +38,22 @@ #include <vector> #include <gflags/gflags.h> -#include <grpc/support/time.h> #include <grpc++/create_channel.h> #include <grpc++/grpc++.h> +#include <grpc++/impl/thd.h> +#include <grpc/support/time.h> #include "test/cpp/interop/interop_client.h" #include "test/cpp/interop/stress_interop_client.h" +#include "test/cpp/util/metrics_server.h" #include "test/cpp/util/test_config.h" +#include "test/proto/metrics.grpc.pb.h" +#include "test/proto/metrics.pb.h" + +DEFINE_int32(metrics_port, 8081, "The metrics server port."); + +DEFINE_int32(metrics_collection_interval_secs, 5, + "How often (in seconds) should metrics be recorded."); DEFINE_int32(sleep_duration_ms, 0, "The duration (in millisec) between two" @@ -61,6 +70,13 @@ DEFINE_string(server_addresses, "localhost:8080", " \"<name_1>:<port_1>,<name_2>:<port_1>...<name_N>:<port_N>\"\n" " Note: <name> can be servername or IP address."); +DEFINE_int32(num_channels_per_server, 1, "Number of channels for each server"); + +DEFINE_int32(num_stubs_per_channel, 1, + "Number of stubs per each channels to server. This number also " + "indicates the max number of parallel RPC calls on each channel " + "at any given time."); + // TODO(sreek): Add more test cases here in future DEFINE_string(test_cases, "", "List of test cases to call along with the" @@ -78,16 +94,13 @@ DEFINE_string(test_cases, "", " 'large_unary', 10% of the time and 'empty_stream' the remaining" " 70% of the time"); -using std::make_pair; -using std::pair; -using std::thread; -using std::vector; - using grpc::testing::kTestCaseList; +using grpc::testing::MetricsService; +using grpc::testing::MetricsServiceImpl; using grpc::testing::StressTestInteropClient; using grpc::testing::TestCaseType; -using grpc::testing::WeightedRandomTestSelector; using grpc::testing::UNKNOWN_TEST; +using grpc::testing::WeightedRandomTestSelector; TestCaseType GetTestTypeFromName(const grpc::string& test_name) { TestCaseType test_case = UNKNOWN_TEST; @@ -104,7 +117,7 @@ TestCaseType GetTestTypeFromName(const grpc::string& test_name) { // Converts a string of comma delimited tokens to a vector of tokens bool ParseCommaDelimitedString(const grpc::string& comma_delimited_str, - vector<grpc::string>& tokens) { + std::vector<grpc::string>& tokens) { size_t bpos = 0; size_t epos = grpc::string::npos; @@ -122,10 +135,10 @@ bool ParseCommaDelimitedString(const grpc::string& comma_delimited_str, // - Whether parsing was successful (return value) // - Vector of (test_type_enum, weight) pairs returned via 'tests' parameter bool ParseTestCasesString(const grpc::string& test_cases, - vector<pair<TestCaseType, int>>& tests) { + std::vector<std::pair<TestCaseType, int>>& tests) { bool is_success = true; - vector<grpc::string> tokens; + std::vector<grpc::string> tokens; ParseCommaDelimitedString(test_cases, tokens); for (auto it = tokens.begin(); it != tokens.end(); it++) { @@ -153,8 +166,8 @@ bool ParseTestCasesString(const grpc::string& test_cases, } // For debugging purposes -void LogParameterInfo(const vector<grpc::string>& addresses, - const vector<pair<TestCaseType, int>>& tests) { +void LogParameterInfo(const std::vector<grpc::string>& addresses, + const std::vector<std::pair<TestCaseType, int>>& tests) { gpr_log(GPR_INFO, "server_addresses: %s", FLAGS_server_addresses.c_str()); gpr_log(GPR_INFO, "test_cases : %s", FLAGS_test_cases.c_str()); gpr_log(GPR_INFO, "sleep_duration_ms: %d", FLAGS_sleep_duration_ms); @@ -180,7 +193,7 @@ int main(int argc, char** argv) { srand(time(NULL)); // Parse the server addresses - vector<grpc::string> server_addresses; + std::vector<grpc::string> server_addresses; ParseCommaDelimitedString(FLAGS_server_addresses, server_addresses); // Parse test cases and weights @@ -189,7 +202,7 @@ int main(int argc, char** argv) { return 1; } - vector<pair<TestCaseType, int>> tests; + std::vector<std::pair<TestCaseType, int>> tests; if (!ParseTestCasesString(FLAGS_test_cases, tests)) { gpr_log(GPR_ERROR, "Error in parsing test cases string %s ", FLAGS_test_cases.c_str()); @@ -199,23 +212,64 @@ int main(int argc, char** argv) { LogParameterInfo(server_addresses, tests); WeightedRandomTestSelector test_selector(tests); + MetricsServiceImpl metrics_service; gpr_log(GPR_INFO, "Starting test(s).."); - vector<thread> test_threads; + std::vector<grpc::thread> test_threads; + + // Create and start the test threads. + // Note that: + // - Each server can have multiple channels (as configured by + // FLAGS_num_channels_per_server). + // + // - Each channel can have multiple stubs (as configured by + // FLAGS_num_stubs_per_channel). This is to test calling multiple RPCs in + // parallel on the same channel. int thread_idx = 0; + int server_idx = -1; + char buffer[256]; for (auto it = server_addresses.begin(); it != server_addresses.end(); it++) { - StressTestInteropClient* client = new StressTestInteropClient( - ++thread_idx, *it, test_selector, FLAGS_test_duration_secs, - FLAGS_sleep_duration_ms); - - test_threads.emplace_back( - thread(&StressTestInteropClient::MainLoop, client)); + ++server_idx; + // Create channel(s) for each server + for (int channel_idx = 0; channel_idx < FLAGS_num_channels_per_server; + channel_idx++) { + // TODO (sreek). This won't work for tests that require Authentication + std::shared_ptr<grpc::Channel> channel( + grpc::CreateChannel(*it, grpc::InsecureChannelCredentials())); + + // Create stub(s) for each channel + for (int stub_idx = 0; stub_idx < FLAGS_num_stubs_per_channel; + stub_idx++) { + StressTestInteropClient* client = new StressTestInteropClient( + ++thread_idx, *it, channel, test_selector, FLAGS_test_duration_secs, + FLAGS_sleep_duration_ms, FLAGS_metrics_collection_interval_secs); + + bool is_already_created; + // Gauge name + std::snprintf(buffer, sizeof(buffer), + "/stress_test/server_%d/channel_%d/stub_%d/qps", + server_idx, channel_idx, stub_idx); + + test_threads.emplace_back(grpc::thread( + &StressTestInteropClient::MainLoop, client, + metrics_service.CreateGauge(buffer, &is_already_created))); + + // The Gauge should not have been already created + GPR_ASSERT(!is_already_created); + } + } } + // Start metrics server before waiting for the stress test threads + std::unique_ptr<grpc::Server> metrics_server = + metrics_service.StartServer(FLAGS_metrics_port); + + // Wait for the stress test threads to complete for (auto it = test_threads.begin(); it != test_threads.end(); it++) { it->join(); } + metrics_server->Wait(); return 0; } diff --git a/test/cpp/qps/async_streaming_ping_pong_test.cc b/test/cpp/qps/async_streaming_ping_pong_test.cc index 411df4d32a..0acdf3affb 100644 --- a/test/cpp/qps/async_streaming_ping_pong_test.cc +++ b/test/cpp/qps/async_streaming_ping_pong_test.cc @@ -35,8 +35,6 @@ #include <grpc/support/log.h> -#include <signal.h> - #include "test/cpp/qps/driver.h" #include "test/cpp/qps/report.h" #include "test/cpp/util/benchmark_config.h" @@ -52,17 +50,16 @@ static void RunAsyncStreamingPingPong() { ClientConfig client_config; client_config.set_client_type(ASYNC_CLIENT); - client_config.set_enable_ssl(false); client_config.set_outstanding_rpcs_per_channel(1); client_config.set_client_channels(1); - client_config.set_payload_size(1); client_config.set_async_client_threads(1); client_config.set_rpc_type(STREAMING); + client_config.mutable_load_params()->mutable_closed_loop(); ServerConfig server_config; server_config.set_server_type(ASYNC_SERVER); - server_config.set_enable_ssl(false); - server_config.set_threads(1); + server_config.set_host("localhost"); + server_config.set_async_server_threads(1); const auto result = RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2); @@ -77,7 +74,6 @@ static void RunAsyncStreamingPingPong() { int main(int argc, char** argv) { grpc::testing::InitBenchmark(&argc, &argv, true); - signal(SIGPIPE, SIG_IGN); grpc::testing::RunAsyncStreamingPingPong(); return 0; } diff --git a/test/cpp/qps/async_unary_ping_pong_test.cc b/test/cpp/qps/async_unary_ping_pong_test.cc index eda31b5744..d21e116171 100644 --- a/test/cpp/qps/async_unary_ping_pong_test.cc +++ b/test/cpp/qps/async_unary_ping_pong_test.cc @@ -35,8 +35,6 @@ #include <grpc/support/log.h> -#include <signal.h> - #include "test/cpp/qps/driver.h" #include "test/cpp/qps/report.h" #include "test/cpp/util/benchmark_config.h" @@ -52,17 +50,16 @@ static void RunAsyncUnaryPingPong() { ClientConfig client_config; client_config.set_client_type(ASYNC_CLIENT); - client_config.set_enable_ssl(false); client_config.set_outstanding_rpcs_per_channel(1); client_config.set_client_channels(1); - client_config.set_payload_size(1); client_config.set_async_client_threads(1); client_config.set_rpc_type(UNARY); + client_config.mutable_load_params()->mutable_closed_loop(); ServerConfig server_config; server_config.set_server_type(ASYNC_SERVER); - server_config.set_enable_ssl(false); - server_config.set_threads(1); + server_config.set_host("localhost"); + server_config.set_async_server_threads(1); const auto result = RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2); @@ -75,7 +72,6 @@ static void RunAsyncUnaryPingPong() { int main(int argc, char** argv) { grpc::testing::InitBenchmark(&argc, &argv, true); - signal(SIGPIPE, SIG_IGN); grpc::testing::RunAsyncUnaryPingPong(); return 0; diff --git a/test/cpp/qps/client.h b/test/cpp/qps/client.h index cd8b34f65b..b24a90adac 100644 --- a/test/cpp/qps/client.h +++ b/test/cpp/qps/client.h @@ -40,8 +40,9 @@ #include "test/cpp/qps/histogram.h" #include "test/cpp/qps/interarrival.h" #include "test/cpp/qps/timer.h" -#include "test/proto/qpstest.grpc.pb.h" #include "test/cpp/util/create_test_channel.h" +#include "test/proto/benchmarks/payloads.grpc.pb.h" +#include "test/proto/benchmarks/services.grpc.pb.h" namespace grpc { @@ -75,27 +76,54 @@ class Client { channels_[i].init(config.server_targets(i % config.server_targets_size()), config); } - request_.set_response_type(grpc::testing::PayloadType::COMPRESSABLE); - request_.set_response_size(config.payload_size()); + if (config.payload_config().has_bytebuf_params()) { + GPR_ASSERT(false); // not yet implemented + } else if (config.payload_config().has_simple_params()) { + request_.set_response_type(grpc::testing::PayloadType::COMPRESSABLE); + request_.set_response_size( + config.payload_config().simple_params().resp_size()); + request_.mutable_payload()->set_type( + grpc::testing::PayloadType::COMPRESSABLE); + int size = config.payload_config().simple_params().req_size(); + std::unique_ptr<char[]> body(new char[size]); + request_.mutable_payload()->set_body(body.get(), size); + } else if (config.payload_config().has_complex_params()) { + GPR_ASSERT(false); // not yet implemented + } else { + // default should be simple proto without payloads + request_.set_response_type(grpc::testing::PayloadType::COMPRESSABLE); + request_.set_response_size(0); + request_.mutable_payload()->set_type( + grpc::testing::PayloadType::COMPRESSABLE); + } } virtual ~Client() {} - ClientStats Mark() { + ClientStats Mark(bool reset) { Histogram latencies; + Timer::Result timer_result; + // avoid std::vector for old compilers that expect a copy constructor - Histogram* to_merge = new Histogram[threads_.size()]; - for (size_t i = 0; i < threads_.size(); i++) { - threads_[i]->BeginSwap(&to_merge[i]); - } - std::unique_ptr<Timer> timer(new Timer); - timer_.swap(timer); - for (size_t i = 0; i < threads_.size(); i++) { - threads_[i]->EndSwap(); - latencies.Merge(&to_merge[i]); + if (reset) { + Histogram* to_merge = new Histogram[threads_.size()]; + for (size_t i = 0; i < threads_.size(); i++) { + threads_[i]->BeginSwap(&to_merge[i]); + } + std::unique_ptr<Timer> timer(new Timer); + timer_.swap(timer); + for (size_t i = 0; i < threads_.size(); i++) { + threads_[i]->EndSwap(); + latencies.Merge(to_merge[i]); + } + delete[] to_merge; + timer_result = timer->Mark(); + } else { + // merge snapshots of each thread histogram + for (size_t i = 0; i < threads_.size(); i++) { + threads_[i]->MergeStatsInto(&latencies); + } + timer_result = timer_->Mark(); } - delete[] to_merge; - - auto timer_result = timer->Mark(); ClientStats stats; latencies.FillProto(stats.mutable_latencies()); @@ -122,15 +150,18 @@ class Client { // We have to use a 2-phase init like this with a default // constructor followed by an initializer function to make // old compilers happy with using this in std::vector - channel_ = CreateTestChannel(target, config.enable_ssl()); - stub_ = TestService::NewStub(channel_); + channel_ = CreateTestChannel( + target, config.security_params().server_host_override(), + config.has_security_params(), + !config.security_params().use_test_ca()); + stub_ = BenchmarkService::NewStub(channel_); } Channel* get_channel() { return channel_.get(); } - TestService::Stub* get_stub() { return stub_.get(); } + BenchmarkService::Stub* get_stub() { return stub_.get(); } private: std::shared_ptr<Channel> channel_; - std::unique_ptr<TestService::Stub> stub_; + std::unique_ptr<BenchmarkService::Stub> stub_; }; std::vector<ClientChannelInfo> channels_; @@ -146,37 +177,41 @@ class Client { void SetupLoadTest(const ClientConfig& config, size_t num_threads) { // Set up the load distribution based on the number of threads - if (config.load_type() == CLOSED_LOOP) { + const auto& load = config.load_params(); + + std::unique_ptr<RandomDist> random_dist; + switch (load.load_case()) { + case LoadParams::kClosedLoop: + // Closed-loop doesn't use random dist at all + break; + case LoadParams::kPoisson: + random_dist.reset( + new ExpDist(load.poisson().offered_load() / num_threads)); + break; + case LoadParams::kUniform: + random_dist.reset( + new UniformDist(load.uniform().interarrival_lo() * num_threads, + load.uniform().interarrival_hi() * num_threads)); + break; + case LoadParams::kDeterm: + random_dist.reset( + new DetDist(num_threads / load.determ().offered_load())); + break; + case LoadParams::kPareto: + random_dist.reset( + new ParetoDist(load.pareto().interarrival_base() * num_threads, + load.pareto().alpha())); + break; + default: + GPR_ASSERT(false); + } + + // Set closed_loop_ based on whether or not random_dist is set + if (!random_dist) { closed_loop_ = true; } else { closed_loop_ = false; - - std::unique_ptr<RandomDist> random_dist; - const auto& load = config.load_params(); - switch (config.load_type()) { - case POISSON: - random_dist.reset( - new ExpDist(load.poisson().offered_load() / num_threads)); - break; - case UNIFORM: - random_dist.reset( - new UniformDist(load.uniform().interarrival_lo() * num_threads, - load.uniform().interarrival_hi() * num_threads)); - break; - case DETERMINISTIC: - random_dist.reset( - new DetDist(num_threads / load.determ().offered_load())); - break; - case PARETO: - random_dist.reset( - new ParetoDist(load.pareto().interarrival_base() * num_threads, - load.pareto().alpha())); - break; - default: - GPR_ASSERT(false); - break; - } - + // set up interarrival timer according to random dist interarrival_timer_.init(*random_dist, num_threads); for (size_t i = 0; i < num_threads; i++) { next_time_.push_back( @@ -204,7 +239,7 @@ class Client { public: Thread(Client* client, size_t idx) : done_(false), - new_(nullptr), + new_stats_(nullptr), client_(client), idx_(idx), impl_(&Thread::ThreadFunc, this) {} @@ -219,16 +254,21 @@ class Client { void BeginSwap(Histogram* n) { std::lock_guard<std::mutex> g(mu_); - new_ = n; + new_stats_ = n; } void EndSwap() { std::unique_lock<std::mutex> g(mu_); - while (new_ != nullptr) { + while (new_stats_ != nullptr) { cv_.wait(g); }; } + void MergeStatsInto(Histogram* hist) { + std::unique_lock<std::mutex> g(mu_); + hist->Merge(histogram_); + } + private: Thread(const Thread&); Thread& operator=(const Thread&); @@ -246,21 +286,21 @@ class Client { if (done_) { return; } - // check if we're marking, swap out the histogram if so - if (new_) { - new_->Swap(&histogram_); - new_ = nullptr; + // check if we're resetting stats, swap out the histogram if so + if (new_stats_) { + new_stats_->Swap(&histogram_); + new_stats_ = nullptr; cv_.notify_one(); } } } - TestService::Stub* stub_; + BenchmarkService::Stub* stub_; ClientConfig config_; std::mutex mu_; std::condition_variable cv_; bool done_; - Histogram* new_; + Histogram* new_stats_; Histogram histogram_; Client* client_; size_t idx_; diff --git a/test/cpp/qps/client_async.cc b/test/cpp/qps/client_async.cc index 9ed42b7db6..9594179822 100644 --- a/test/cpp/qps/client_async.cc +++ b/test/cpp/qps/client_async.cc @@ -48,10 +48,10 @@ #include <gflags/gflags.h> #include <grpc++/client_context.h> -#include "test/proto/qpstest.grpc.pb.h" #include "test/cpp/qps/timer.h" #include "test/cpp/qps/client.h" #include "test/cpp/util/create_test_channel.h" +#include "test/proto/benchmarks/services.grpc.pb.h" namespace grpc { namespace testing { @@ -88,10 +88,10 @@ template <class RequestType, class ResponseType> class ClientRpcContextUnaryImpl : public ClientRpcContext { public: ClientRpcContextUnaryImpl( - int channel_id, TestService::Stub* stub, const RequestType& req, + int channel_id, BenchmarkService::Stub* stub, const RequestType& req, std::function< std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>( - TestService::Stub*, grpc::ClientContext*, const RequestType&, + BenchmarkService::Stub*, grpc::ClientContext*, const RequestType&, CompletionQueue*)> start_req, std::function<void(grpc::Status, ResponseType*)> on_done) : ClientRpcContext(channel_id), @@ -131,13 +131,13 @@ class ClientRpcContextUnaryImpl : public ClientRpcContext { return true; // we're done, this'll be ignored } grpc::ClientContext context_; - TestService::Stub* stub_; + BenchmarkService::Stub* stub_; RequestType req_; ResponseType response_; bool (ClientRpcContextUnaryImpl::*next_state_)(bool); std::function<void(grpc::Status, ResponseType*)> callback_; std::function<std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>( - TestService::Stub*, grpc::ClientContext*, const RequestType&, + BenchmarkService::Stub*, grpc::ClientContext*, const RequestType&, CompletionQueue*)> start_req_; grpc::Status status_; double start_; @@ -151,7 +151,7 @@ class AsyncClient : public Client { public: explicit AsyncClient( const ClientConfig& config, - std::function<ClientRpcContext*(int, TestService::Stub*, + std::function<ClientRpcContext*(int, BenchmarkService::Stub*, const SimpleRequest&)> setup_ctx) : Client(config), channel_lock_(new std::mutex[config.client_channels()]), @@ -354,11 +354,12 @@ class AsyncUnaryClient GRPC_FINAL : public AsyncClient { private: static void CheckDone(grpc::Status s, SimpleResponse* response) {} static std::unique_ptr<grpc::ClientAsyncResponseReader<SimpleResponse>> - StartReq(TestService::Stub* stub, grpc::ClientContext* ctx, + StartReq(BenchmarkService::Stub* stub, grpc::ClientContext* ctx, const SimpleRequest& request, CompletionQueue* cq) { return stub->AsyncUnaryCall(ctx, request, cq); }; - static ClientRpcContext* SetupCtx(int channel_id, TestService::Stub* stub, + static ClientRpcContext* SetupCtx(int channel_id, + BenchmarkService::Stub* stub, const SimpleRequest& req) { return new ClientRpcContextUnaryImpl<SimpleRequest, SimpleResponse>( channel_id, stub, req, AsyncUnaryClient::StartReq, @@ -370,10 +371,11 @@ template <class RequestType, class ResponseType> class ClientRpcContextStreamingImpl : public ClientRpcContext { public: ClientRpcContextStreamingImpl( - int channel_id, TestService::Stub* stub, const RequestType& req, - std::function<std::unique_ptr<grpc::ClientAsyncReaderWriter< - RequestType, ResponseType>>(TestService::Stub*, grpc::ClientContext*, - CompletionQueue*, void*)> start_req, + int channel_id, BenchmarkService::Stub* stub, const RequestType& req, + std::function<std::unique_ptr< + grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>( + BenchmarkService::Stub*, grpc::ClientContext*, CompletionQueue*, + void*)> start_req, std::function<void(grpc::Status, ResponseType*)> on_done) : ClientRpcContext(channel_id), context_(), @@ -420,15 +422,15 @@ class ClientRpcContextStreamingImpl : public ClientRpcContext { return StartWrite(ok); } grpc::ClientContext context_; - TestService::Stub* stub_; + BenchmarkService::Stub* stub_; RequestType req_; ResponseType response_; bool (ClientRpcContextStreamingImpl::*next_state_)(bool, Histogram*); std::function<void(grpc::Status, ResponseType*)> callback_; std::function< std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType, ResponseType>>( - TestService::Stub*, grpc::ClientContext*, CompletionQueue*, void*)> - start_req_; + BenchmarkService::Stub*, grpc::ClientContext*, CompletionQueue*, + void*)> start_req_; grpc::Status status_; double start_; std::unique_ptr<grpc::ClientAsyncReaderWriter<RequestType, ResponseType>> @@ -439,8 +441,8 @@ class AsyncStreamingClient GRPC_FINAL : public AsyncClient { public: explicit AsyncStreamingClient(const ClientConfig& config) : AsyncClient(config, SetupCtx) { - // async streaming currently only supported closed loop - GPR_ASSERT(config.load_type() == CLOSED_LOOP); + // async streaming currently only supports closed loop + GPR_ASSERT(closed_loop_); StartThreads(config.async_client_threads()); } @@ -451,12 +453,13 @@ class AsyncStreamingClient GRPC_FINAL : public AsyncClient { static void CheckDone(grpc::Status s, SimpleResponse* response) {} static std::unique_ptr< grpc::ClientAsyncReaderWriter<SimpleRequest, SimpleResponse>> - StartReq(TestService::Stub* stub, grpc::ClientContext* ctx, + StartReq(BenchmarkService::Stub* stub, grpc::ClientContext* ctx, CompletionQueue* cq, void* tag) { auto stream = stub->AsyncStreamingCall(ctx, cq, tag); return stream; }; - static ClientRpcContext* SetupCtx(int channel_id, TestService::Stub* stub, + static ClientRpcContext* SetupCtx(int channel_id, + BenchmarkService::Stub* stub, const SimpleRequest& req) { return new ClientRpcContextStreamingImpl<SimpleRequest, SimpleResponse>( channel_id, stub, req, AsyncStreamingClient::StartReq, diff --git a/test/cpp/qps/client_sync.cc b/test/cpp/qps/client_sync.cc index ed4134c743..10d680860a 100644 --- a/test/cpp/qps/client_sync.cc +++ b/test/cpp/qps/client_sync.cc @@ -54,10 +54,10 @@ #include "test/cpp/util/create_test_channel.h" #include "test/cpp/qps/client.h" -#include "test/proto/qpstest.grpc.pb.h" #include "test/cpp/qps/histogram.h" #include "test/cpp/qps/interarrival.h" #include "test/cpp/qps/timer.h" +#include "test/proto/benchmarks/services.grpc.pb.h" #include "src/core/profiling/timers.h" diff --git a/test/cpp/qps/driver.cc b/test/cpp/qps/driver.cc index dd5c4f4f73..20dc65046b 100644 --- a/test/cpp/qps/driver.cc +++ b/test/cpp/qps/driver.cc @@ -48,6 +48,7 @@ #include "test/cpp/qps/driver.h" #include "test/cpp/qps/histogram.h" #include "test/cpp/qps/qps_worker.h" +#include "test/proto/benchmarks/services.grpc.pb.h" using std::list; using std::thread; @@ -91,12 +92,12 @@ static ClientContext* AllocContext(list<ClientContext>* contexts, T deadline) { } struct ServerData { - unique_ptr<Worker::Stub> stub; + unique_ptr<WorkerService::Stub> stub; unique_ptr<ClientReaderWriter<ServerArgs, ServerStatus>> stream; }; struct ClientData { - unique_ptr<Worker::Stub> stub; + unique_ptr<WorkerService::Stub> stub; unique_ptr<ClientReaderWriter<ClientArgs, ClientStatus>> stream; }; } // namespace runsc @@ -109,7 +110,7 @@ std::unique_ptr<ScenarioResult> RunScenario( list<ClientContext> contexts; // To be added to the result, containing the final configuration used for - // client and config (incluiding host, etc.) + // client and config (including host, etc.) ClientConfig result_client_config; ServerConfig result_server_config; @@ -131,8 +132,7 @@ std::unique_ptr<ScenarioResult> RunScenario( } int driver_port = grpc_pick_unused_port_or_die(); - int benchmark_port = grpc_pick_unused_port_or_die(); - local_workers.emplace_back(new QpsWorker(driver_port, benchmark_port)); + local_workers.emplace_back(new QpsWorker(driver_port)); char addr[256]; sprintf(addr, "localhost:%d", driver_port); if (spawn_local_worker_count < 0) { @@ -161,11 +161,10 @@ std::unique_ptr<ScenarioResult> RunScenario( // where class contained in std::vector must have a copy constructor auto* servers = new ServerData[num_servers]; for (size_t i = 0; i < num_servers; i++) { - servers[i].stub = - Worker::NewStub(CreateChannel(workers[i], InsecureCredentials())); + servers[i].stub = WorkerService::NewStub( + CreateChannel(workers[i], InsecureChannelCredentials())); ServerArgs args; result_server_config = server_config; - result_server_config.set_host(workers[i]); *args.mutable_setup() = server_config; servers[i].stream = servers[i].stub->RunServer(runsc::AllocContext(&contexts, deadline)); @@ -189,14 +188,13 @@ std::unique_ptr<ScenarioResult> RunScenario( // where class contained in std::vector must have a copy constructor auto* clients = new ClientData[num_clients]; for (size_t i = 0; i < num_clients; i++) { - clients[i].stub = Worker::NewStub( - CreateChannel(workers[i + num_servers], InsecureCredentials())); + clients[i].stub = WorkerService::NewStub( + CreateChannel(workers[i + num_servers], InsecureChannelCredentials())); ClientArgs args; result_client_config = client_config; - result_client_config.set_host(workers[i + num_servers]); *args.mutable_setup() = client_config; clients[i].stream = - clients[i].stub->RunTest(runsc::AllocContext(&contexts, deadline)); + clients[i].stub->RunClient(runsc::AllocContext(&contexts, deadline)); GPR_ASSERT(clients[i].stream->Write(args)); ClientStatus init_status; GPR_ASSERT(clients[i].stream->Read(&init_status)); @@ -211,9 +209,9 @@ std::unique_ptr<ScenarioResult> RunScenario( // Start a run gpr_log(GPR_INFO, "Starting"); ServerArgs server_mark; - server_mark.mutable_mark(); + server_mark.mutable_mark()->set_reset(true); ClientArgs client_mark; - client_mark.mutable_mark(); + client_mark.mutable_mark()->set_reset(true); for (auto server = &servers[0]; server != &servers[num_servers]; server++) { GPR_ASSERT(server->stream->Write(server_mark)); } @@ -251,14 +249,15 @@ std::unique_ptr<ScenarioResult> RunScenario( GPR_ASSERT(server->stream->Read(&server_status)); const auto& stats = server_status.stats(); result->server_resources.emplace_back( - stats.time_elapsed(), stats.time_user(), stats.time_system()); + stats.time_elapsed(), stats.time_user(), stats.time_system(), + server_status.cores()); } for (auto client = &clients[0]; client != &clients[num_clients]; client++) { GPR_ASSERT(client->stream->Read(&client_status)); const auto& stats = client_status.stats(); result->latencies.MergeProto(stats.latencies()); result->client_resources.emplace_back( - stats.time_elapsed(), stats.time_user(), stats.time_system()); + stats.time_elapsed(), stats.time_user(), stats.time_system(), -1); } for (auto client = &clients[0]; client != &clients[num_clients]; client++) { diff --git a/test/cpp/qps/driver.h b/test/cpp/qps/driver.h index 6116aa656a..50bf17ceab 100644 --- a/test/cpp/qps/driver.h +++ b/test/cpp/qps/driver.h @@ -37,22 +37,24 @@ #include <memory> #include "test/cpp/qps/histogram.h" -#include "test/proto/qpstest.grpc.pb.h" +#include "test/proto/benchmarks/control.grpc.pb.h" namespace grpc { namespace testing { class ResourceUsage { public: - ResourceUsage(double w, double u, double s) - : wall_time_(w), user_time_(u), system_time_(s) {} + ResourceUsage(double w, double u, double s, int c) + : wall_time_(w), user_time_(u), system_time_(s), cores_(c) {} double wall_time() const { return wall_time_; } double user_time() const { return user_time_; } double system_time() const { return system_time_; } + int cores() const { return cores_; } private: double wall_time_; double user_time_; double system_time_; + int cores_; }; struct ScenarioResult { diff --git a/test/cpp/qps/histogram.h b/test/cpp/qps/histogram.h index 1151cca87c..4161eac826 100644 --- a/test/cpp/qps/histogram.h +++ b/test/cpp/qps/histogram.h @@ -35,20 +35,23 @@ #define TEST_QPS_HISTOGRAM_H #include <grpc/support/histogram.h> -#include "test/proto/qpstest.grpc.pb.h" +#include "test/proto/benchmarks/stats.grpc.pb.h" namespace grpc { namespace testing { class Histogram { public: - Histogram() : impl_(gpr_histogram_create(0.01, 60e9)) {} + // TODO: look into making histogram params not hardcoded for C++ + Histogram() + : impl_(gpr_histogram_create(default_resolution(), + default_max_possible())) {} ~Histogram() { if (impl_) gpr_histogram_destroy(impl_); } Histogram(Histogram&& other) : impl_(other.impl_) { other.impl_ = nullptr; } - void Merge(Histogram* h) { gpr_histogram_merge(impl_, h->impl_); } + void Merge(const Histogram& h) { gpr_histogram_merge(impl_, h.impl_); } void Add(double value) { gpr_histogram_add(impl_, value); } double Percentile(double pctile) const { return gpr_histogram_percentile(impl_, pctile); @@ -73,6 +76,9 @@ class Histogram { p.sum_of_squares(), p.count()); } + static double default_resolution() { return 0.01; } + static double default_max_possible() { return 60e9; } + private: Histogram(const Histogram&); Histogram& operator=(const Histogram&); diff --git a/test/cpp/qps/perf_db.proto b/test/cpp/qps/perf_db.proto index 7ae5cfe86e..8a691ddded 100644 --- a/test/cpp/qps/perf_db.proto +++ b/test/cpp/qps/perf_db.proto @@ -29,7 +29,7 @@ syntax = "proto3"; -import "test/proto/qpstest.proto"; +import "test/proto/benchmarks/control.proto"; package grpc.testing; diff --git a/test/cpp/qps/qps-sweep.sh b/test/cpp/qps/qps-sweep.sh index cb93201933..36ea974812 100755 --- a/test/cpp/qps/qps-sweep.sh +++ b/test/cpp/qps/qps-sweep.sh @@ -37,17 +37,21 @@ fi bins=`find . .. ../.. ../../.. -name bins | head -1` -for channels in 1 2 4 8 +for secure in true false do - for client in SYNCHRONOUS_CLIENT ASYNC_CLIENT + for channels in 1 2 4 8 do - for server in SYNCHRONOUS_SERVER ASYNC_SERVER + for client in SYNC_CLIENT ASYNC_CLIENT do - for rpc in UNARY STREAMING + for server in SYNC_SERVER ASYNC_SERVER do - echo "Test $rpc $client $server , $channels channels" - "$bins"/opt/qps_driver --rpc_type=$rpc \ - --client_type=$client --server_type=$server + for rpc in UNARY STREAMING + do + echo "Test $rpc $client $server, $channels channels, secure=$secure" + "$bins"/opt/qps_driver --rpc_type=$rpc \ + --client_type=$client --server_type=$server \ + --secure_test=$secure + done done done done diff --git a/test/cpp/qps/qps_driver.cc b/test/cpp/qps/qps_driver.cc index b1463be8f6..c7096391e6 100644 --- a/test/cpp/qps/qps_driver.cc +++ b/test/cpp/qps/qps_driver.cc @@ -33,7 +33,6 @@ #include <memory> #include <set> -#include <signal.h> #include <gflags/gflags.h> #include <grpc/support/log.h> @@ -50,31 +49,39 @@ DEFINE_int32(benchmark_seconds, 30, "Benchmark time (in seconds)"); DEFINE_int32(local_workers, 0, "Number of local workers to start"); // Common config -DEFINE_bool(enable_ssl, false, "Use SSL"); DEFINE_string(rpc_type, "UNARY", "Type of RPC: UNARY or STREAMING"); // Server config -DEFINE_int32(server_threads, 1, "Number of server threads"); -DEFINE_string(server_type, "SYNCHRONOUS_SERVER", "Server type"); +DEFINE_int32(async_server_threads, 1, "Number of threads for async servers"); +DEFINE_string(server_type, "SYNC_SERVER", "Server type"); // Client config DEFINE_int32(outstanding_rpcs_per_channel, 1, "Number of outstanding rpcs per channel"); DEFINE_int32(client_channels, 1, "Number of client channels"); -DEFINE_int32(payload_size, 1, "Payload size"); -DEFINE_string(client_type, "SYNCHRONOUS_CLIENT", "Client type"); + +DEFINE_int32(simple_req_size, -1, "Simple proto request payload size"); +DEFINE_int32(simple_resp_size, -1, "Simple proto response payload size"); + +DEFINE_string(client_type, "SYNC_CLIENT", "Client type"); DEFINE_int32(async_client_threads, 1, "Async client threads"); -DEFINE_string(load_type, "CLOSED_LOOP", "Load type"); -DEFINE_double(load_param_1, 0.0, "Load parameter 1"); -DEFINE_double(load_param_2, 0.0, "Load parameter 2"); + +DEFINE_double(poisson_load, -1.0, "Poisson offered load (qps)"); +DEFINE_double(uniform_lo, -1.0, "Uniform low interarrival time (us)"); +DEFINE_double(uniform_hi, -1.0, "Uniform high interarrival time (us)"); +DEFINE_double(determ_load, -1.0, "Deterministic offered load (qps)"); +DEFINE_double(pareto_base, -1.0, "Pareto base interarrival time (us)"); +DEFINE_double(pareto_alpha, -1.0, "Pareto alpha value"); + +DEFINE_bool(secure_test, false, "Run a secure test"); using grpc::testing::ClientConfig; using grpc::testing::ServerConfig; using grpc::testing::ClientType; using grpc::testing::ServerType; -using grpc::testing::LoadType; using grpc::testing::RpcType; using grpc::testing::ResourceUsage; +using grpc::testing::SecurityParams; namespace grpc { namespace testing { @@ -85,72 +92,69 @@ static void QpsDriver() { ClientType client_type; ServerType server_type; - LoadType load_type; GPR_ASSERT(ClientType_Parse(FLAGS_client_type, &client_type)); GPR_ASSERT(ServerType_Parse(FLAGS_server_type, &server_type)); - GPR_ASSERT(LoadType_Parse(FLAGS_load_type, &load_type)); ClientConfig client_config; client_config.set_client_type(client_type); - client_config.set_load_type(load_type); - client_config.set_enable_ssl(FLAGS_enable_ssl); client_config.set_outstanding_rpcs_per_channel( FLAGS_outstanding_rpcs_per_channel); client_config.set_client_channels(FLAGS_client_channels); - client_config.set_payload_size(FLAGS_payload_size); + + // Decide which type to use based on the response type + if (FLAGS_simple_resp_size >= 0) { + auto params = + client_config.mutable_payload_config()->mutable_simple_params(); + params->set_resp_size(FLAGS_simple_resp_size); + if (FLAGS_simple_req_size >= 0) { + params->set_req_size(FLAGS_simple_req_size); + } + } else { + // set a reasonable default: proto but no payload + client_config.mutable_payload_config()->mutable_simple_params(); + } + client_config.set_async_client_threads(FLAGS_async_client_threads); client_config.set_rpc_type(rpc_type); // set up the load parameters - switch (load_type) { - case grpc::testing::CLOSED_LOOP: - break; - case grpc::testing::POISSON: { - auto poisson = client_config.mutable_load_params()->mutable_poisson(); - GPR_ASSERT(FLAGS_load_param_1 != 0.0); - poisson->set_offered_load(FLAGS_load_param_1); - break; - } - case grpc::testing::UNIFORM: { - auto uniform = client_config.mutable_load_params()->mutable_uniform(); - GPR_ASSERT(FLAGS_load_param_1 != 0.0); - GPR_ASSERT(FLAGS_load_param_2 != 0.0); - uniform->set_interarrival_lo(FLAGS_load_param_1 / 1e6); - uniform->set_interarrival_hi(FLAGS_load_param_2 / 1e6); - break; - } - case grpc::testing::DETERMINISTIC: { - auto determ = client_config.mutable_load_params()->mutable_determ(); - GPR_ASSERT(FLAGS_load_param_1 != 0.0); - determ->set_offered_load(FLAGS_load_param_1); - break; - } - case grpc::testing::PARETO: { - auto pareto = client_config.mutable_load_params()->mutable_pareto(); - GPR_ASSERT(FLAGS_load_param_1 != 0.0); - GPR_ASSERT(FLAGS_load_param_2 != 0.0); - pareto->set_interarrival_base(FLAGS_load_param_1 / 1e6); - pareto->set_alpha(FLAGS_load_param_2); - break; - } - default: - GPR_ASSERT(false); - break; + if (FLAGS_poisson_load > 0.0) { + auto poisson = client_config.mutable_load_params()->mutable_poisson(); + poisson->set_offered_load(FLAGS_poisson_load); + } else if (FLAGS_uniform_lo > 0.0) { + auto uniform = client_config.mutable_load_params()->mutable_uniform(); + uniform->set_interarrival_lo(FLAGS_uniform_lo / 1e6); + uniform->set_interarrival_hi(FLAGS_uniform_hi / 1e6); + } else if (FLAGS_determ_load > 0.0) { + auto determ = client_config.mutable_load_params()->mutable_determ(); + determ->set_offered_load(FLAGS_determ_load); + } else if (FLAGS_pareto_base > 0.0) { + auto pareto = client_config.mutable_load_params()->mutable_pareto(); + pareto->set_interarrival_base(FLAGS_pareto_base / 1e6); + pareto->set_alpha(FLAGS_pareto_alpha); + } else { + client_config.mutable_load_params()->mutable_closed_loop(); + // No further load parameters to set up for closed loop } + client_config.mutable_histogram_params()->set_resolution( + Histogram::default_resolution()); + client_config.mutable_histogram_params()->set_max_possible( + Histogram::default_max_possible()); + ServerConfig server_config; server_config.set_server_type(server_type); - server_config.set_threads(FLAGS_server_threads); - server_config.set_enable_ssl(FLAGS_enable_ssl); - - // If we're running a sync-server streaming test, make sure - // that we have at least as many threads as the active streams - // or else threads will be blocked from forward progress and the - // client will deadlock on a timer. - GPR_ASSERT(!(server_type == grpc::testing::SYNCHRONOUS_SERVER && - rpc_type == grpc::testing::STREAMING && - FLAGS_server_threads < - FLAGS_client_channels * FLAGS_outstanding_rpcs_per_channel)); + server_config.set_host("localhost"); + server_config.set_async_server_threads(FLAGS_async_server_threads); + + if (FLAGS_secure_test) { + // Set up security params + SecurityParams security; + security.set_use_test_ca(true); + security.set_server_host_override("foo.test.google.fr"); + client_config.mutable_security_params()->CopyFrom(security); + server_config.mutable_security_params()->CopyFrom(security); + } const auto result = RunScenario( client_config, FLAGS_num_clients, server_config, FLAGS_num_servers, @@ -168,7 +172,6 @@ static void QpsDriver() { int main(int argc, char** argv) { grpc::testing::InitBenchmark(&argc, &argv, true); - signal(SIGPIPE, SIG_IGN); grpc::testing::QpsDriver(); return 0; diff --git a/test/cpp/qps/qps_interarrival_test.cc b/test/cpp/qps/qps_interarrival_test.cc index a7979e6187..ccda28f09a 100644 --- a/test/cpp/qps/qps_interarrival_test.cc +++ b/test/cpp/qps/qps_interarrival_test.cc @@ -42,7 +42,7 @@ using grpc::testing::RandomDist; using grpc::testing::InterarrivalTimer; -void RunTest(RandomDist &&r, int threads, std::string title) { +static void RunTest(RandomDist &&r, int threads, std::string title) { InterarrivalTimer timer; timer.init(r, threads); gpr_histogram *h(gpr_histogram_create(0.01, 60e9)); diff --git a/test/cpp/qps/qps_openloop_test.cc b/test/cpp/qps/qps_openloop_test.cc index 5a6a9249a9..51df79ef2f 100644 --- a/test/cpp/qps/qps_openloop_test.cc +++ b/test/cpp/qps/qps_openloop_test.cc @@ -31,8 +31,6 @@ * */ -#include <signal.h> - #include <set> #include <grpc/support/log.h> @@ -52,20 +50,17 @@ static void RunQPS() { ClientConfig client_config; client_config.set_client_type(ASYNC_CLIENT); - client_config.set_enable_ssl(false); client_config.set_outstanding_rpcs_per_channel(1000); client_config.set_client_channels(8); - client_config.set_payload_size(1); client_config.set_async_client_threads(8); client_config.set_rpc_type(UNARY); - client_config.set_load_type(POISSON); client_config.mutable_load_params()->mutable_poisson()->set_offered_load( 1000.0); ServerConfig server_config; server_config.set_server_type(ASYNC_SERVER); - server_config.set_enable_ssl(false); - server_config.set_threads(4); + server_config.set_host("localhost"); + server_config.set_async_server_threads(4); const auto result = RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2); @@ -80,7 +75,6 @@ static void RunQPS() { int main(int argc, char** argv) { grpc::testing::InitBenchmark(&argc, &argv, true); - signal(SIGPIPE, SIG_IGN); grpc::testing::RunQPS(); return 0; diff --git a/test/cpp/qps/qps_test.cc b/test/cpp/qps/qps_test.cc index d0c4a79cd9..1f87d18137 100644 --- a/test/cpp/qps/qps_test.cc +++ b/test/cpp/qps/qps_test.cc @@ -31,8 +31,6 @@ * */ -#include <signal.h> - #include <set> #include <grpc/support/log.h> @@ -52,17 +50,16 @@ static void RunQPS() { ClientConfig client_config; client_config.set_client_type(ASYNC_CLIENT); - client_config.set_enable_ssl(false); client_config.set_outstanding_rpcs_per_channel(1000); client_config.set_client_channels(8); - client_config.set_payload_size(1); client_config.set_async_client_threads(8); client_config.set_rpc_type(UNARY); + client_config.mutable_load_params()->mutable_closed_loop(); ServerConfig server_config; server_config.set_server_type(ASYNC_SERVER); - server_config.set_enable_ssl(false); - server_config.set_threads(8); + server_config.set_host("localhost"); + server_config.set_async_server_threads(8); const auto result = RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2); @@ -77,7 +74,6 @@ static void RunQPS() { int main(int argc, char** argv) { grpc::testing::InitBenchmark(&argc, &argv, true); - signal(SIGPIPE, SIG_IGN); grpc::testing::RunQPS(); return 0; diff --git a/test/cpp/qps/qps_test_with_poll.cc b/test/cpp/qps/qps_test_with_poll.cc index 31d2c1bf7b..dc800092db 100644 --- a/test/cpp/qps/qps_test_with_poll.cc +++ b/test/cpp/qps/qps_test_with_poll.cc @@ -31,8 +31,6 @@ * */ -#include <signal.h> - #include <set> #include <grpc/support/log.h> @@ -56,17 +54,16 @@ static void RunQPS() { ClientConfig client_config; client_config.set_client_type(ASYNC_CLIENT); - client_config.set_enable_ssl(false); client_config.set_outstanding_rpcs_per_channel(1000); client_config.set_client_channels(8); - client_config.set_payload_size(1); client_config.set_async_client_threads(8); client_config.set_rpc_type(UNARY); + client_config.mutable_load_params()->mutable_closed_loop(); ServerConfig server_config; server_config.set_server_type(ASYNC_SERVER); - server_config.set_enable_ssl(false); - server_config.set_threads(4); + server_config.set_host("localhost"); + server_config.set_async_server_threads(4); const auto result = RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2); @@ -83,7 +80,6 @@ int main(int argc, char** argv) { grpc_platform_become_multipoller = grpc_poll_become_multipoller; - signal(SIGPIPE, SIG_IGN); grpc::testing::RunQPS(); return 0; diff --git a/test/cpp/qps/qps_worker.cc b/test/cpp/qps/qps_worker.cc index 4ce77f366d..dc59eab7ef 100644 --- a/test/cpp/qps/qps_worker.cc +++ b/test/cpp/qps/qps_worker.cc @@ -52,17 +52,17 @@ #include <grpc++/security/server_credentials.h> #include "test/core/util/grpc_profiler.h" -#include "test/proto/qpstest.pb.h" #include "test/cpp/qps/client.h" #include "test/cpp/qps/server.h" #include "test/cpp/util/create_test_channel.h" +#include "test/proto/benchmarks/services.pb.h" namespace grpc { namespace testing { -std::unique_ptr<Client> CreateClient(const ClientConfig& config) { +static std::unique_ptr<Client> CreateClient(const ClientConfig& config) { switch (config.client_type()) { - case ClientType::SYNCHRONOUS_CLIENT: + case ClientType::SYNC_CLIENT: return (config.rpc_type() == RpcType::UNARY) ? CreateSynchronousUnaryClient(config) : CreateSynchronousStreamingClient(config); @@ -76,26 +76,29 @@ std::unique_ptr<Client> CreateClient(const ClientConfig& config) { abort(); } -std::unique_ptr<Server> CreateServer(const ServerConfig& config, - int server_port) { +static void LimitCores(int cores) {} + +static std::unique_ptr<Server> CreateServer(const ServerConfig& config) { + if (config.core_limit() > 0) { + LimitCores(config.core_limit()); + } switch (config.server_type()) { - case ServerType::SYNCHRONOUS_SERVER: - return CreateSynchronousServer(config, server_port); + case ServerType::SYNC_SERVER: + return CreateSynchronousServer(config); case ServerType::ASYNC_SERVER: - return CreateAsyncServer(config, server_port); + return CreateAsyncServer(config); default: abort(); } abort(); } -class WorkerImpl GRPC_FINAL : public Worker::Service { +class WorkerServiceImpl GRPC_FINAL : public WorkerService::Service { public: - explicit WorkerImpl(int server_port) - : server_port_(server_port), acquired_(false) {} + explicit WorkerServiceImpl() : acquired_(false) {} - Status RunTest(ServerContext* ctx, - ServerReaderWriter<ClientStatus, ClientArgs>* stream) + Status RunClient(ServerContext* ctx, + ServerReaderWriter<ClientStatus, ClientArgs>* stream) GRPC_OVERRIDE { InstanceGuard g(this); if (!g.Acquired()) { @@ -103,7 +106,7 @@ class WorkerImpl GRPC_FINAL : public Worker::Service { } grpc_profiler_start("qps_client.prof"); - Status ret = RunTestBody(ctx, stream); + Status ret = RunClientBody(ctx, stream); grpc_profiler_stop(); return ret; } @@ -126,7 +129,7 @@ class WorkerImpl GRPC_FINAL : public Worker::Service { // Protect against multiple clients using this worker at once. class InstanceGuard { public: - InstanceGuard(WorkerImpl* impl) + InstanceGuard(WorkerServiceImpl* impl) : impl_(impl), acquired_(impl->TryAcquireInstance()) {} ~InstanceGuard() { if (acquired_) { @@ -137,7 +140,7 @@ class WorkerImpl GRPC_FINAL : public Worker::Service { bool Acquired() const { return acquired_; } private: - WorkerImpl* const impl_; + WorkerServiceImpl* const impl_; const bool acquired_; }; @@ -154,8 +157,8 @@ class WorkerImpl GRPC_FINAL : public Worker::Service { acquired_ = false; } - Status RunTestBody(ServerContext* ctx, - ServerReaderWriter<ClientStatus, ClientArgs>* stream) { + Status RunClientBody(ServerContext* ctx, + ServerReaderWriter<ClientStatus, ClientArgs>* stream) { ClientArgs args; if (!stream->Read(&args)) { return Status(StatusCode::INVALID_ARGUMENT, ""); @@ -175,7 +178,7 @@ class WorkerImpl GRPC_FINAL : public Worker::Service { if (!args.has_mark()) { return Status(StatusCode::INVALID_ARGUMENT, ""); } - *status.mutable_stats() = client->Mark(); + *status.mutable_stats() = client->Mark(args.mark().reset()); stream->Write(status); } @@ -191,12 +194,13 @@ class WorkerImpl GRPC_FINAL : public Worker::Service { if (!args.has_setup()) { return Status(StatusCode::INVALID_ARGUMENT, ""); } - auto server = CreateServer(args.setup(), server_port_); + auto server = CreateServer(args.setup()); if (!server) { return Status(StatusCode::INVALID_ARGUMENT, ""); } ServerStatus status; - status.set_port(server_port_); + status.set_port(server->port()); + status.set_cores(server->cores()); if (!stream->Write(status)) { return Status(StatusCode::UNKNOWN, ""); } @@ -204,21 +208,19 @@ class WorkerImpl GRPC_FINAL : public Worker::Service { if (!args.has_mark()) { return Status(StatusCode::INVALID_ARGUMENT, ""); } - *status.mutable_stats() = server->Mark(); + *status.mutable_stats() = server->Mark(args.mark().reset()); stream->Write(status); } return Status::OK; } - const int server_port_; - std::mutex mu_; bool acquired_; }; -QpsWorker::QpsWorker(int driver_port, int server_port) { - impl_.reset(new WorkerImpl(server_port)); +QpsWorker::QpsWorker(int driver_port) { + impl_.reset(new WorkerServiceImpl()); char* server_address = NULL; gpr_join_host_port(&server_address, "::", driver_port); diff --git a/test/cpp/qps/qps_worker.h b/test/cpp/qps/qps_worker.h index 861588907e..0db88ad3d1 100644 --- a/test/cpp/qps/qps_worker.h +++ b/test/cpp/qps/qps_worker.h @@ -42,15 +42,15 @@ class Server; namespace testing { -class WorkerImpl; +class WorkerServiceImpl; class QpsWorker { public: - QpsWorker(int driver_port, int server_port); + explicit QpsWorker(int driver_port); ~QpsWorker(); private: - std::unique_ptr<WorkerImpl> impl_; + std::unique_ptr<WorkerServiceImpl> impl_; std::unique_ptr<Server> server_; }; diff --git a/test/cpp/qps/report.cc b/test/cpp/qps/report.cc index e03e8e1fb0..b230eb441e 100644 --- a/test/cpp/qps/report.cc +++ b/test/cpp/qps/report.cc @@ -43,6 +43,7 @@ namespace testing { static double WallTime(ResourceUsage u) { return u.wall_time(); } static double UserTime(ResourceUsage u) { return u.user_time(); } static double SystemTime(ResourceUsage u) { return u.system_time(); } +static int Cores(ResourceUsage u) { return u.cores(); } void CompositeReporter::add(std::unique_ptr<Reporter> reporter) { reporters_.emplace_back(std::move(reporter)); @@ -83,7 +84,7 @@ void GprLogReporter::ReportQPSPerCore(const ScenarioResult& result) { result.latencies.Count() / average(result.client_resources, WallTime); gpr_log(GPR_INFO, "QPS: %.1f (%.1f/server core)", qps, - qps / result.server_config.threads()); + qps / sum(result.server_resources, Cores)); } void GprLogReporter::ReportLatency(const ScenarioResult& result) { @@ -123,10 +124,10 @@ void PerfDbReporter::ReportQPSPerCore(const ScenarioResult& result) { auto qps = result.latencies.Count() / average(result.client_resources, WallTime); - auto qpsPerCore = qps / result.server_config.threads(); + auto qps_per_core = qps / sum(result.server_resources, Cores); perf_db_client_.setQps(qps); - perf_db_client_.setQpsPerCore(qpsPerCore); + perf_db_client_.setQpsPerCore(qps_per_core); perf_db_client_.setConfigs(result.client_config, result.server_config); } diff --git a/test/cpp/qps/report.h b/test/cpp/qps/report.h index 00d12369d5..5caf3fe69a 100644 --- a/test/cpp/qps/report.h +++ b/test/cpp/qps/report.h @@ -41,7 +41,6 @@ #include <grpc++/support/config.h> #include "test/cpp/qps/driver.h" -#include "test/proto/qpstest.grpc.pb.h" #include "test/cpp/qps/perf_db_client.h" namespace grpc { @@ -116,8 +115,8 @@ class PerfDbReporter : public Reporter { test_name_(test_name), sys_info_(sys_info), tag_(tag) { - perf_db_client_.init( - grpc::CreateChannel(server_address, grpc::InsecureCredentials())); + perf_db_client_.init(grpc::CreateChannel( + server_address, grpc::InsecureChannelCredentials())); } ~PerfDbReporter() GRPC_OVERRIDE { SendData(); }; diff --git a/test/cpp/qps/secure_sync_unary_ping_pong_test.cc b/test/cpp/qps/secure_sync_unary_ping_pong_test.cc new file mode 100644 index 0000000000..ce9f02cceb --- /dev/null +++ b/test/cpp/qps/secure_sync_unary_ping_pong_test.cc @@ -0,0 +1,85 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#include <set> + +#include <grpc/support/log.h> + +#include "test/cpp/qps/driver.h" +#include "test/cpp/qps/report.h" +#include "test/cpp/util/benchmark_config.h" + +namespace grpc { +namespace testing { + +static const int WARMUP = 5; +static const int BENCHMARK = 10; + +static void RunSynchronousUnaryPingPong() { + gpr_log(GPR_INFO, "Running Synchronous Unary Ping Pong"); + + ClientConfig client_config; + client_config.set_client_type(SYNC_CLIENT); + client_config.set_outstanding_rpcs_per_channel(1); + client_config.set_client_channels(1); + client_config.set_rpc_type(UNARY); + client_config.mutable_load_params()->mutable_closed_loop(); + + ServerConfig server_config; + server_config.set_server_type(SYNC_SERVER); + server_config.set_host("localhost"); + + // Set up security params + SecurityParams security; + security.set_use_test_ca(true); + security.set_server_host_override("foo.test.google.fr"); + client_config.mutable_security_params()->CopyFrom(security); + server_config.mutable_security_params()->CopyFrom(security); + + const auto result = + RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2); + + GetReporter()->ReportQPS(*result); + GetReporter()->ReportLatency(*result); +} + +} // namespace testing +} // namespace grpc + +int main(int argc, char** argv) { + grpc::testing::InitBenchmark(&argc, &argv, true); + + grpc::testing::RunSynchronousUnaryPingPong(); + + return 0; +} diff --git a/test/cpp/qps/server.h b/test/cpp/qps/server.h index e48e873dc3..6e81edc8ff 100644 --- a/test/cpp/qps/server.h +++ b/test/cpp/qps/server.h @@ -34,22 +34,38 @@ #ifndef TEST_QPS_SERVER_H #define TEST_QPS_SERVER_H +#include <grpc/support/cpu.h> +#include <grpc++/security/server_credentials.h> + +#include "test/core/end2end/data/ssl_test_data.h" +#include "test/core/util/port.h" #include "test/cpp/qps/timer.h" -#include "test/proto/qpstest.grpc.pb.h" +#include "test/proto/messages.grpc.pb.h" +#include "test/proto/benchmarks/control.grpc.pb.h" namespace grpc { namespace testing { class Server { public: - Server() : timer_(new Timer) {} + explicit Server(const ServerConfig& config) : timer_(new Timer) { + if (config.port()) { + port_ = config.port(); + } else { + port_ = grpc_pick_unused_port_or_die(); + } + } virtual ~Server() {} - ServerStats Mark() { - std::unique_ptr<Timer> timer(new Timer); - timer.swap(timer_); - - auto timer_result = timer->Mark(); + ServerStats Mark(bool reset) { + Timer::Result timer_result; + if (reset) { + std::unique_ptr<Timer> timer(new Timer); + timer.swap(timer_); + timer_result = timer->Mark(); + } else { + timer_result = timer_->Mark(); + } ServerStats stats; stats.set_time_elapsed(timer_result.wall); @@ -70,13 +86,29 @@ class Server { return true; } + int port() const { return port_; } + int cores() const { return gpr_cpu_num_cores(); } + static std::shared_ptr<ServerCredentials> CreateServerCredentials( + const ServerConfig& config) { + if (config.has_security_params()) { + SslServerCredentialsOptions::PemKeyCertPair pkcp = {test_server1_key, + test_server1_cert}; + SslServerCredentialsOptions ssl_opts; + ssl_opts.pem_root_certs = ""; + ssl_opts.pem_key_cert_pairs.push_back(pkcp); + return SslServerCredentials(ssl_opts); + } else { + return InsecureServerCredentials(); + } + } + private: + int port_; std::unique_ptr<Timer> timer_; }; -std::unique_ptr<Server> CreateSynchronousServer(const ServerConfig& config, - int port); -std::unique_ptr<Server> CreateAsyncServer(const ServerConfig& config, int port); +std::unique_ptr<Server> CreateSynchronousServer(const ServerConfig& config); +std::unique_ptr<Server> CreateAsyncServer(const ServerConfig& config); } // namespace testing } // namespace grpc diff --git a/test/cpp/qps/server_async.cc b/test/cpp/qps/server_async.cc index 98fa9c53e2..c151918ce4 100644 --- a/test/cpp/qps/server_async.cc +++ b/test/cpp/qps/server_async.cc @@ -49,38 +49,40 @@ #include <grpc++/security/server_credentials.h> #include <gtest/gtest.h> -#include "test/proto/qpstest.grpc.pb.h" #include "test/cpp/qps/server.h" +#include "test/proto/benchmarks/services.grpc.pb.h" namespace grpc { namespace testing { class AsyncQpsServerTest : public Server { public: - AsyncQpsServerTest(const ServerConfig &config, int port) { + explicit AsyncQpsServerTest(const ServerConfig &config) : Server(config) { char *server_address = NULL; - gpr_join_host_port(&server_address, "::", port); + + gpr_join_host_port(&server_address, config.host().c_str(), port()); ServerBuilder builder; - builder.AddListeningPort(server_address, InsecureServerCredentials()); + builder.AddListeningPort(server_address, + Server::CreateServerCredentials(config)); gpr_free(server_address); builder.RegisterAsyncService(&async_service_); - for (int i = 0; i < config.threads(); i++) { + for (int i = 0; i < config.async_server_threads(); i++) { srv_cqs_.emplace_back(builder.AddCompletionQueue()); } server_ = builder.BuildAndStart(); using namespace std::placeholders; - for (int i = 0; i < 10000 / config.threads(); i++) { - for (int j = 0; j < config.threads(); j++) { + for (int i = 0; i < 10000 / config.async_server_threads(); i++) { + for (int j = 0; j < config.async_server_threads(); j++) { auto request_unary = std::bind( - &TestService::AsyncService::RequestUnaryCall, &async_service_, _1, - _2, _3, srv_cqs_[j].get(), srv_cqs_[j].get(), _4); + &BenchmarkService::AsyncService::RequestUnaryCall, &async_service_, + _1, _2, _3, srv_cqs_[j].get(), srv_cqs_[j].get(), _4); auto request_streaming = std::bind( - &TestService::AsyncService::RequestStreamingCall, &async_service_, - _1, _2, srv_cqs_[j].get(), srv_cqs_[j].get(), _3); + &BenchmarkService::AsyncService::RequestStreamingCall, + &async_service_, _1, _2, srv_cqs_[j].get(), srv_cqs_[j].get(), _3); contexts_.push_front( new ServerRpcContextUnaryImpl<SimpleRequest, SimpleResponse>( request_unary, ProcessRPC)); @@ -89,10 +91,10 @@ class AsyncQpsServerTest : public Server { request_streaming, ProcessRPC)); } } - for (int i = 0; i < config.threads(); i++) { + for (int i = 0; i < config.async_server_threads(); i++) { shutdown_state_.emplace_back(new PerThreadShutdownState()); } - for (int i = 0; i < config.threads(); i++) { + for (int i = 0; i < config.async_server_threads(); i++) { threads_.emplace_back(&AsyncQpsServerTest::ThreadFunc, this, i); } } @@ -309,7 +311,7 @@ class AsyncQpsServerTest : public Server { std::vector<std::thread> threads_; std::unique_ptr<grpc::Server> server_; std::vector<std::unique_ptr<grpc::ServerCompletionQueue>> srv_cqs_; - TestService::AsyncService async_service_; + BenchmarkService::AsyncService async_service_; std::forward_list<ServerRpcContext *> contexts_; class PerThreadShutdownState { @@ -333,9 +335,8 @@ class AsyncQpsServerTest : public Server { std::vector<std::unique_ptr<PerThreadShutdownState>> shutdown_state_; }; -std::unique_ptr<Server> CreateAsyncServer(const ServerConfig &config, - int port) { - return std::unique_ptr<Server>(new AsyncQpsServerTest(config, port)); +std::unique_ptr<Server> CreateAsyncServer(const ServerConfig &config) { + return std::unique_ptr<Server>(new AsyncQpsServerTest(config)); } } // namespace testing diff --git a/test/cpp/qps/server_sync.cc b/test/cpp/qps/server_sync.cc index b760ef63ec..3a15bec888 100644 --- a/test/cpp/qps/server_sync.cc +++ b/test/cpp/qps/server_sync.cc @@ -43,14 +43,14 @@ #include <grpc++/server_context.h> #include <grpc++/security/server_credentials.h> -#include "test/proto/qpstest.grpc.pb.h" #include "test/cpp/qps/server.h" #include "test/cpp/qps/timer.h" +#include "test/proto/benchmarks/services.grpc.pb.h" namespace grpc { namespace testing { -class TestServiceImpl GRPC_FINAL : public TestService::Service { +class BenchmarkServiceImpl GRPC_FINAL : public BenchmarkService::Service { public: Status UnaryCall(ServerContext* context, const SimpleRequest* request, SimpleResponse* response) GRPC_OVERRIDE { @@ -84,30 +84,29 @@ class TestServiceImpl GRPC_FINAL : public TestService::Service { class SynchronousServer GRPC_FINAL : public grpc::testing::Server { public: - SynchronousServer(const ServerConfig& config, int port) - : impl_(MakeImpl(port)) {} - - private: - std::unique_ptr<grpc::Server> MakeImpl(int port) { + explicit SynchronousServer(const ServerConfig& config) : Server(config) { ServerBuilder builder; char* server_address = NULL; - gpr_join_host_port(&server_address, "::", port); - builder.AddListeningPort(server_address, InsecureServerCredentials()); + + gpr_join_host_port(&server_address, config.host().c_str(), port()); + builder.AddListeningPort(server_address, + Server::CreateServerCredentials(config)); gpr_free(server_address); builder.RegisterService(&service_); - return builder.BuildAndStart(); + impl_ = builder.BuildAndStart(); } - TestServiceImpl service_; + private: + BenchmarkServiceImpl service_; std::unique_ptr<grpc::Server> impl_; }; std::unique_ptr<grpc::testing::Server> CreateSynchronousServer( - const ServerConfig& config, int port) { - return std::unique_ptr<Server>(new SynchronousServer(config, port)); + const ServerConfig& config) { + return std::unique_ptr<Server>(new SynchronousServer(config)); } } // namespace testing diff --git a/test/cpp/qps/single_run_localhost.sh b/test/cpp/qps/single_run_localhost.sh index 9d76f08f80..f5356f1834 100755 --- a/test/cpp/qps/single_run_localhost.sh +++ b/test/cpp/qps/single_run_localhost.sh @@ -42,9 +42,9 @@ NUMCPUS=`python2.7 -c 'import multiprocessing; print multiprocessing.cpu_count() make CONFIG=$config qps_worker qps_driver -j$NUMCPUS -bins/$config/qps_worker -driver_port 10000 -server_port 10001 & +bins/$config/qps_worker -driver_port 10000 & PID1=$! -bins/$config/qps_worker -driver_port 10010 -server_port 10011 & +bins/$config/qps_worker -driver_port 10010 & PID2=$! export QPS_WORKERS="localhost:10000,localhost:10010" diff --git a/test/cpp/qps/sync_streaming_ping_pong_test.cc b/test/cpp/qps/sync_streaming_ping_pong_test.cc index 52e43939a8..dd8c682815 100644 --- a/test/cpp/qps/sync_streaming_ping_pong_test.cc +++ b/test/cpp/qps/sync_streaming_ping_pong_test.cc @@ -31,8 +31,6 @@ * */ -#include <signal.h> - #include <set> #include <grpc/support/log.h> @@ -51,17 +49,15 @@ static void RunSynchronousStreamingPingPong() { gpr_log(GPR_INFO, "Running Synchronous Streaming Ping Pong"); ClientConfig client_config; - client_config.set_client_type(SYNCHRONOUS_CLIENT); - client_config.set_enable_ssl(false); + client_config.set_client_type(SYNC_CLIENT); client_config.set_outstanding_rpcs_per_channel(1); client_config.set_client_channels(1); - client_config.set_payload_size(1); client_config.set_rpc_type(STREAMING); + client_config.mutable_load_params()->mutable_closed_loop(); ServerConfig server_config; - server_config.set_server_type(SYNCHRONOUS_SERVER); - server_config.set_enable_ssl(false); - server_config.set_threads(1); + server_config.set_server_type(SYNC_SERVER); + server_config.set_host("localhost"); const auto result = RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2); @@ -75,7 +71,6 @@ static void RunSynchronousStreamingPingPong() { int main(int argc, char** argv) { grpc::testing::InitBenchmark(&argc, &argv, true); - signal(SIGPIPE, SIG_IGN); grpc::testing::RunSynchronousStreamingPingPong(); return 0; diff --git a/test/cpp/qps/sync_unary_ping_pong_test.cc b/test/cpp/qps/sync_unary_ping_pong_test.cc index fbd21357aa..2edb33ef01 100644 --- a/test/cpp/qps/sync_unary_ping_pong_test.cc +++ b/test/cpp/qps/sync_unary_ping_pong_test.cc @@ -31,8 +31,6 @@ * */ -#include <signal.h> - #include <set> #include <grpc/support/log.h> @@ -51,17 +49,15 @@ static void RunSynchronousUnaryPingPong() { gpr_log(GPR_INFO, "Running Synchronous Unary Ping Pong"); ClientConfig client_config; - client_config.set_client_type(SYNCHRONOUS_CLIENT); - client_config.set_enable_ssl(false); + client_config.set_client_type(SYNC_CLIENT); client_config.set_outstanding_rpcs_per_channel(1); client_config.set_client_channels(1); - client_config.set_payload_size(1); client_config.set_rpc_type(UNARY); + client_config.mutable_load_params()->mutable_closed_loop(); ServerConfig server_config; - server_config.set_server_type(SYNCHRONOUS_SERVER); - server_config.set_enable_ssl(false); - server_config.set_threads(1); + server_config.set_server_type(SYNC_SERVER); + server_config.set_host("localhost"); const auto result = RunScenario(client_config, 1, server_config, 1, WARMUP, BENCHMARK, -2); @@ -76,7 +72,6 @@ static void RunSynchronousUnaryPingPong() { int main(int argc, char** argv) { grpc::testing::InitBenchmark(&argc, &argv, true); - signal(SIGPIPE, SIG_IGN); grpc::testing::RunSynchronousUnaryPingPong(); return 0; diff --git a/test/cpp/qps/timer.cc b/test/cpp/qps/timer.cc index 8edb838da3..3ec7f49f83 100644 --- a/test/cpp/qps/timer.cc +++ b/test/cpp/qps/timer.cc @@ -61,7 +61,7 @@ Timer::Result Timer::Sample() { return r; } -Timer::Result Timer::Mark() { +Timer::Result Timer::Mark() const { Result s = Sample(); Result r; r.wall = s.wall - start_.wall; diff --git a/test/cpp/qps/timer.h b/test/cpp/qps/timer.h index 30dbd7e7d5..d1aee1a9d1 100644 --- a/test/cpp/qps/timer.h +++ b/test/cpp/qps/timer.h @@ -44,7 +44,7 @@ class Timer { double system; }; - Result Mark(); + Result Mark() const; static double Now(); diff --git a/test/cpp/qps/worker.cc b/test/cpp/qps/worker.cc index 935e4853a6..430ffb7cdc 100644 --- a/test/cpp/qps/worker.cc +++ b/test/cpp/qps/worker.cc @@ -43,8 +43,7 @@ #include "test/cpp/qps/qps_worker.h" #include "test/cpp/util/test_config.h" -DEFINE_int32(driver_port, 0, "Driver server port."); -DEFINE_int32(server_port, 0, "Spawned server port."); +DEFINE_int32(driver_port, 0, "Port for communication with driver"); static bool got_sigint = false; @@ -54,7 +53,7 @@ namespace grpc { namespace testing { static void RunServer() { - QpsWorker worker(FLAGS_driver_port, FLAGS_server_port); + QpsWorker worker(FLAGS_driver_port); while (!got_sigint) { gpr_sleep_until(gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), diff --git a/test/cpp/util/cli_call_test.cc b/test/cpp/util/cli_call_test.cc index 9c8d59987e..32cd8e4103 100644 --- a/test/cpp/util/cli_call_test.cc +++ b/test/cpp/util/cli_call_test.cc @@ -89,7 +89,8 @@ class CliCallTest : public ::testing::Test { void TearDown() GRPC_OVERRIDE { server_->Shutdown(); } void ResetStub() { - channel_ = CreateChannel(server_address_.str(), InsecureCredentials()); + channel_ = + CreateChannel(server_address_.str(), InsecureChannelCredentials()); stub_ = grpc::cpp::test::util::TestService::NewStub(channel_); } diff --git a/test/cpp/util/create_test_channel.cc b/test/cpp/util/create_test_channel.cc index f0d5bfc7eb..0cd9f9e767 100644 --- a/test/cpp/util/create_test_channel.cc +++ b/test/cpp/util/create_test_channel.cc @@ -58,13 +58,14 @@ namespace grpc { std::shared_ptr<Channel> CreateTestChannel( const grpc::string& server, const grpc::string& override_hostname, bool enable_ssl, bool use_prod_roots, - const std::shared_ptr<Credentials>& creds) { + const std::shared_ptr<CallCredentials>& creds) { ChannelArguments channel_args; if (enable_ssl) { const char* roots_certs = use_prod_roots ? "" : test_root_cert; SslCredentialsOptions ssl_opts = {roots_certs, "", ""}; - std::shared_ptr<Credentials> channel_creds = SslCredentials(ssl_opts); + std::shared_ptr<ChannelCredentials> channel_creds = + SslCredentials(ssl_opts); if (!server.empty() && !override_hostname.empty()) { channel_args.SetSslTargetNameOverride(override_hostname); @@ -72,11 +73,11 @@ std::shared_ptr<Channel> CreateTestChannel( const grpc::string& connect_to = server.empty() ? override_hostname : server; if (creds.get()) { - channel_creds = CompositeCredentials(creds, channel_creds); + channel_creds = CompositeChannelCredentials(channel_creds, creds); } return CreateCustomChannel(connect_to, channel_creds, channel_args); } else { - return CreateChannel(server, InsecureCredentials()); + return CreateChannel(server, InsecureChannelCredentials()); } } @@ -84,7 +85,7 @@ std::shared_ptr<Channel> CreateTestChannel( const grpc::string& server, const grpc::string& override_hostname, bool enable_ssl, bool use_prod_roots) { return CreateTestChannel(server, override_hostname, enable_ssl, - use_prod_roots, std::shared_ptr<Credentials>()); + use_prod_roots, std::shared_ptr<CallCredentials>()); } // Shortcut for end2end and interop tests. diff --git a/test/cpp/util/create_test_channel.h b/test/cpp/util/create_test_channel.h index a4750689a0..b50d653de3 100644 --- a/test/cpp/util/create_test_channel.h +++ b/test/cpp/util/create_test_channel.h @@ -51,7 +51,7 @@ std::shared_ptr<Channel> CreateTestChannel( std::shared_ptr<Channel> CreateTestChannel( const grpc::string& server, const grpc::string& override_hostname, bool enable_ssl, bool use_prod_roots, - const std::shared_ptr<Credentials>& creds); + const std::shared_ptr<CallCredentials>& creds); } // namespace grpc diff --git a/test/cpp/util/grpc_cli.cc b/test/cpp/util/grpc_cli.cc index 334b6efb6a..3f40b242fc 100644 --- a/test/cpp/util/grpc_cli.cc +++ b/test/cpp/util/grpc_cli.cc @@ -148,9 +148,9 @@ int main(int argc, char** argv) { std::stringstream input_stream; input_stream << input_file.rdbuf(); - std::shared_ptr<grpc::Credentials> creds; + std::shared_ptr<grpc::ChannelCredentials> creds; if (!FLAGS_enable_ssl) { - creds = grpc::InsecureCredentials(); + creds = grpc::InsecureChannelCredentials(); } else { if (FLAGS_use_auth) { creds = grpc::GoogleDefaultCredentials(); diff --git a/test/cpp/util/metrics_server.cc b/test/cpp/util/metrics_server.cc new file mode 100644 index 0000000000..426295f9b4 --- /dev/null +++ b/test/cpp/util/metrics_server.cc @@ -0,0 +1,119 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *is % allowed in string + */ + +#include "test/cpp/util/metrics_server.h" + +#include <grpc++/server_builder.h> + +#include "test/proto/metrics.grpc.pb.h" +#include "test/proto/metrics.pb.h" + +namespace grpc { +namespace testing { + +Gauge::Gauge(long initial_val) : val_(initial_val) {} + +void Gauge::Set(long new_val) { + std::lock_guard<std::mutex> lock(val_mu_); + val_ = new_val; +} + +long Gauge::Get() { + std::lock_guard<std::mutex> lock(val_mu_); + return val_; +} + +grpc::Status MetricsServiceImpl::GetAllGauges( + ServerContext* context, const EmptyMessage* request, + ServerWriter<GaugeResponse>* writer) { + gpr_log(GPR_INFO, "GetAllGauges called"); + + std::lock_guard<std::mutex> lock(mu_); + for (auto it = gauges_.begin(); it != gauges_.end(); it++) { + GaugeResponse resp; + resp.set_name(it->first); // Gauge name + resp.set_long_value(it->second->Get()); // Gauge value + writer->Write(resp); + } + + return Status::OK; +} + +grpc::Status MetricsServiceImpl::GetGauge(ServerContext* context, + const GaugeRequest* request, + GaugeResponse* response) { + std::lock_guard<std::mutex> lock(mu_); + + const auto it = gauges_.find(request->name()); + if (it != gauges_.end()) { + response->set_name(it->first); + response->set_long_value(it->second->Get()); + } + + return Status::OK; +} + +std::shared_ptr<Gauge> MetricsServiceImpl::CreateGauge(const grpc::string& name, + bool* already_present) { + std::lock_guard<std::mutex> lock(mu_); + + std::shared_ptr<Gauge> gauge(new Gauge(0)); + const auto p = gauges_.emplace(name, gauge); + + // p.first is an iterator pointing to <name, shared_ptr<Gauge>> pair. p.second + // is a boolean which is set to 'true' if the Gauge is inserted in the guages_ + // map and 'false' if it is already present in the map + *already_present = !p.second; + return p.first->second; +} + +// Starts the metrics server and returns the grpc::Server instance. Call Wait() +// on the returned server instance. +std::unique_ptr<grpc::Server> MetricsServiceImpl::StartServer(int port) { + gpr_log(GPR_INFO, "Building metrics server.."); + + const grpc::string address = "0.0.0.0:" + std::to_string(port); + + ServerBuilder builder; + builder.AddListeningPort(address, grpc::InsecureServerCredentials()); + builder.RegisterService(this); + + std::unique_ptr<grpc::Server> server(builder.BuildAndStart()); + gpr_log(GPR_INFO, "Metrics server %s started. Ready to receive requests..", + address.c_str()); + + return server; +} + +} // namespace testing +} // namespace grpc diff --git a/test/cpp/util/metrics_server.h b/test/cpp/util/metrics_server.h new file mode 100644 index 0000000000..edde37dc4c --- /dev/null +++ b/test/cpp/util/metrics_server.h @@ -0,0 +1,100 @@ +/* + * + * Copyright 2015, Google Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *is % allowed in string + */ +#ifndef GRPC_TEST_CPP_METRICS_SERVER_H +#define GRPC_TEST_CPP_METRICS_SERVER_H + +#include <map> +#include <mutex> + +#include "test/proto/metrics.grpc.pb.h" +#include "test/proto/metrics.pb.h" + +/* + * This implements a Metrics server defined in test/proto/metrics.proto. Any + * test service can use this to export Metrics (TODO (sreek): Only Gauges for + * now). + * + * Example: + * MetricsServiceImpl metricsImpl; + * .. + * // Create Gauge(s). Note: Gauges can be created even after calling + * // 'StartServer'. + * Gauge gauge1 = metricsImpl.CreateGauge("foo",is_present); + * // gauge1 can now be used anywhere in the program to set values. + * ... + * // Create the metrics server + * std::unique_ptr<grpc::Server> server = metricsImpl.StartServer(port); + * server->Wait(); // Note: This is blocking. + */ +namespace grpc { +namespace testing { + +// TODO(sreek): Add support for other types of Gauges like Double, String in +// future +class Gauge { + public: + Gauge(long initial_val); + void Set(long new_val); + long Get(); + + private: + long val_; + std::mutex val_mu_; +}; + +class MetricsServiceImpl GRPC_FINAL : public MetricsService::Service { + public: + grpc::Status GetAllGauges(ServerContext* context, const EmptyMessage* request, + ServerWriter<GaugeResponse>* writer) GRPC_OVERRIDE; + + grpc::Status GetGauge(ServerContext* context, const GaugeRequest* request, + GaugeResponse* response) GRPC_OVERRIDE; + + // Create a Gauge with name 'name'. is_present is set to true if the Gauge + // is already present in the map. + // NOTE: CreateGauge can be called anytime (i.e before or after calling + // StartServer). + std::shared_ptr<Gauge> CreateGauge(const grpc::string& name, + bool* already_present); + + std::unique_ptr<grpc::Server> StartServer(int port); + + private: + std::map<string, std::shared_ptr<Gauge>> gauges_; + std::mutex mu_; +}; + +} // namespace testing +} // namespace grpc + +#endif // GRPC_TEST_CPP_METRICS_SERVER_H diff --git a/test/proto/qpstest.proto b/test/proto/benchmarks/control.proto index ef1f9451e9..42a5dd0a85 100644 --- a/test/proto/qpstest.proto +++ b/test/proto/benchmarks/control.proto @@ -1,4 +1,3 @@ - // Copyright 2015, Google Inc. // All rights reserved. // @@ -28,62 +27,20 @@ // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// An integration test service that covers all the method signature permutations -// of unary/streaming requests/responses. syntax = "proto3"; -package grpc.testing; - -enum PayloadType { - // Compressable text format. - COMPRESSABLE = 0; - - // Uncompressable binary format. - UNCOMPRESSABLE = 1; - - // Randomly chosen from all other formats defined in this enum. - RANDOM = 2; -} - -message StatsRequest { - // run number - int32 test_num = 1; -} - -message ServerStats { - // wall clock time - double time_elapsed = 1; - - // user time used by the server process and threads - double time_user = 2; - - // server time used by the server process and all threads - double time_system = 3; -} - -message Payload { - // The type of data in body. - PayloadType type = 1; - // Primary contents of payload. - bytes body = 2; -} +import "test/proto/benchmarks/payloads.proto"; +import "test/proto/benchmarks/stats.proto"; -message HistogramData { - repeated uint32 bucket = 1; - double min_seen = 2; - double max_seen = 3; - double sum = 4; - double sum_of_squares = 5; - double count = 6; -} +package grpc.testing; enum ClientType { - SYNCHRONOUS_CLIENT = 0; + SYNC_CLIENT = 0; ASYNC_CLIENT = 1; } enum ServerType { - SYNCHRONOUS_SERVER = 0; + SYNC_SERVER = 0; ASYNC_SERVER = 1; } @@ -92,15 +49,10 @@ enum RpcType { STREAMING = 1; } -enum LoadType { - CLOSED_LOOP = 0; - POISSON = 1; - UNIFORM = 2; - DETERMINISTIC = 3; - PARETO = 4; -} - +// Parameters of poisson process distribution, which is a good representation +// of activity coming in from independent identical stationary sources. message PoissonParams { + // The rate of arrivals (a.k.a. lambda parameter of the exp distribution). double offered_load = 1; } @@ -118,32 +70,55 @@ message ParetoParams { double alpha = 2; } +// Once an RPC finishes, immediately start a new one. +// No configuration parameters needed. +message ClosedLoopParams { +} + message LoadParams { oneof load { - PoissonParams poisson = 1; - UniformParams uniform = 2; - DeterministicParams determ = 3; - ParetoParams pareto = 4; + ClosedLoopParams closed_loop = 1; + PoissonParams poisson = 2; + UniformParams uniform = 3; + DeterministicParams determ = 4; + ParetoParams pareto = 5; }; } +// presence of SecurityParams implies use of TLS +message SecurityParams { + bool use_test_ca = 1; + string server_host_override = 2; +} + message ClientConfig { + // List of targets to connect to. At least one target needs to be specified. repeated string server_targets = 1; ClientType client_type = 2; - bool enable_ssl = 3; + SecurityParams security_params = 3; + // How many concurrent RPCs to start for each channel. + // For synchronous client, use a separate thread for each outstanding RPC. int32 outstanding_rpcs_per_channel = 4; + // Number of independent client channels to create. + // i-th channel will connect to server_target[i % server_targets.size()] int32 client_channels = 5; - int32 payload_size = 6; - // only for async client: + // Only for async client. Number of threads to use to start/manage RPCs. int32 async_client_threads = 7; RpcType rpc_type = 8; - string host = 9; - LoadType load_type = 10; - LoadParams load_params = 11; + // The requested load for the entire client (aggregated over all the threads). + LoadParams load_params = 10; + PayloadConfig payload_config = 11; + HistogramParams histogram_params = 12; +} + +message ClientStatus { + ClientStats stats = 1; } // Request current stats message Mark { + // if true, the stats will be reset after taking their snapshot. + bool reset = 1; } message ClientArgs { @@ -153,22 +128,18 @@ message ClientArgs { } } -message ClientStats { - HistogramData latencies = 1; - double time_elapsed = 2; - double time_user = 3; - double time_system = 4; -} - -message ClientStatus { - ClientStats stats = 1; -} - message ServerConfig { ServerType server_type = 1; - int32 threads = 2; - bool enable_ssl = 3; - string host = 4; + SecurityParams security_params = 2; + // Host on which to listen. + string host = 3; + // Port on which to listen. Zero means pick unused port. + int32 port = 4; + // Only for async server. Number of threads used to serve the requests. + int32 async_server_threads = 7; + // restrict core usage, currently unused + int32 core_limit = 8; + PayloadConfig payload_config = 9; } message ServerArgs { @@ -180,39 +151,8 @@ message ServerArgs { message ServerStatus { ServerStats stats = 1; + // the port bound by the server int32 port = 2; -} - -message SimpleRequest { - // Desired payload type in the response from the server. - // If response_type is RANDOM, server randomly chooses one from other formats. - PayloadType response_type = 1; - - // Desired payload size in the response from the server. - // If response_type is COMPRESSABLE, this denotes the size before compression. - int32 response_size = 2; - - // Optional input payload sent along with the request. - Payload payload = 3; -} - -message SimpleResponse { - Payload payload = 1; -} - -service TestService { - // One request followed by one response. - // The server returns the client payload as-is. - rpc UnaryCall(SimpleRequest) returns (SimpleResponse); - - // One request followed by one response. - // The server returns the client payload as-is. - rpc StreamingCall(stream SimpleRequest) returns (stream SimpleResponse); -} - -service Worker { - // Start test with specified workload - rpc RunTest(stream ClientArgs) returns (stream ClientStatus); - // Start test with specified workload - rpc RunServer(stream ServerArgs) returns (stream ServerStatus); + // Number of cores on the server. See gpr_cpu_num_cores. + int32 cores = 3; } diff --git a/test/proto/benchmarks/payloads.proto b/test/proto/benchmarks/payloads.proto new file mode 100644 index 0000000000..7e5b2c61ff --- /dev/null +++ b/test/proto/benchmarks/payloads.proto @@ -0,0 +1,55 @@ +// Copyright 2015, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package grpc.testing; + +message ByteBufferParams { + int32 req_size = 1; + int32 resp_size = 2; +} + +message SimpleProtoParams { + int32 req_size = 1; + int32 resp_size = 2; +} + +message ComplexProtoParams { + // TODO (vpai): Fill this in once the details of complex, representative + // protos are decided +} + +message PayloadConfig { + oneof payload { + ByteBufferParams bytebuf_params = 1; + SimpleProtoParams simple_params = 2; + ComplexProtoParams complex_params = 3; + } +} diff --git a/test/proto/benchmarks/services.proto b/test/proto/benchmarks/services.proto new file mode 100644 index 0000000000..ff295ed970 --- /dev/null +++ b/test/proto/benchmarks/services.proto @@ -0,0 +1,65 @@ +// Copyright 2015, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// An integration test service that covers all the method signature permutations +// of unary/streaming requests/responses. +syntax = "proto3"; + +import "test/proto/messages.proto"; +import "test/proto/benchmarks/control.proto"; + +package grpc.testing; + +service BenchmarkService { + // One request followed by one response. + // The server returns the client payload as-is. + rpc UnaryCall(SimpleRequest) returns (SimpleResponse); + + // One request followed by one response. + // The server returns the client payload as-is. + rpc StreamingCall(stream SimpleRequest) returns (stream SimpleResponse); +} + +service WorkerService { + // Start server with specified workload. + // First request sent specifies the ServerConfig followed by ServerStatus + // response. After that, a "Mark" can be sent anytime to request the latest + // stats. Closing the stream will initiate shutdown of the test server + // and once the shutdown has finished, the OK status is sent to terminate + // this RPC. + rpc RunServer(stream ServerArgs) returns (stream ServerStatus); + + // Start client with specified workload. + // First request sent specifies the ClientConfig followed by ClientStatus + // response. After that, a "Mark" can be sent anytime to request the latest + // stats. Closing the stream will initiate shutdown of the test client + // and once the shutdown has finished, the OK status is sent to terminate + // this RPC. + rpc RunClient(stream ClientArgs) returns (stream ClientStatus); +} diff --git a/test/proto/benchmarks/stats.proto b/test/proto/benchmarks/stats.proto new file mode 100644 index 0000000000..7e02707dbb --- /dev/null +++ b/test/proto/benchmarks/stats.proto @@ -0,0 +1,70 @@ +// Copyright 2015, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package grpc.testing; + +message ServerStats { + // wall clock time change in seconds since last reset + double time_elapsed = 1; + + // change in user time (in seconds) used by the server since last reset + double time_user = 2; + + // change in server time (in seconds) used by the server process and all + // threads since last reset + double time_system = 3; +} + +// Histogram params based on grpc/support/histogram.c +message HistogramParams { + double resolution = 1; // first bucket is [0, 1 + resolution) + double max_possible = 2; // use enough buckets to allow this value +} + +// Histogram data based on grpc/support/histogram.c +message HistogramData { + repeated uint32 bucket = 1; + double min_seen = 2; + double max_seen = 3; + double sum = 4; + double sum_of_squares = 5; + double count = 6; +} + +message ClientStats { + // Latency histogram. Data points are in nanoseconds. + HistogramData latencies = 1; + + // See ServerStats for details. + double time_elapsed = 2; + double time_user = 3; + double time_system = 4; +} diff --git a/test/proto/metrics.proto b/test/proto/metrics.proto new file mode 100644 index 0000000000..f698620100 --- /dev/null +++ b/test/proto/metrics.proto @@ -0,0 +1,54 @@ + +// Copyright 2015, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// An integration test service that covers all the method signature permutations +// of unary/streaming requests/responses. +syntax = "proto3"; + +package grpc.testing; + +message GaugeResponse { + string name = 1; + oneof value { + int64 long_value = 2; + double double_vale = 3; + string string_value = 4; + } +} + +message GaugeRequest { string name = 1; } + +message EmptyMessage { +} + +service MetricsService { + rpc GetAllGauges(EmptyMessage) returns (stream GaugeResponse); + rpc GetGauge(GaugeRequest) returns (GaugeResponse); +} |