diff options
Diffstat (limited to 'test/core/channel')
| -rw-r--r-- | test/core/channel/BUILD | 12 | ||||
| -rw-r--r-- | test/core/channel/channel_args_test.cc (renamed from test/core/channel/channel_args_test.c) | 72 | ||||
| -rw-r--r-- | test/core/channel/channel_stack_builder_test.cc (renamed from test/core/channel/channel_stack_builder_test.c) | 61 | ||||
| -rw-r--r-- | test/core/channel/channel_stack_test.c | 157 | ||||
| -rw-r--r-- | test/core/channel/channel_stack_test.cc | 155 | ||||
| -rw-r--r-- | test/core/channel/minimal_stack_is_minimal_test.cc (renamed from test/core/channel/minimal_stack_is_minimal_test.c) | 102 |
6 files changed, 279 insertions, 280 deletions
diff --git a/test/core/channel/BUILD b/test/core/channel/BUILD index 5ac77c449b..92f5907aac 100644 --- a/test/core/channel/BUILD +++ b/test/core/channel/BUILD @@ -20,8 +20,8 @@ licenses(["notice"]) # Apache v2 grpc_cc_test( name = "channel_args_test", - srcs = ["channel_args_test.c"], - language = "C", + srcs = ["channel_args_test.cc"], + language = "C++", deps = [ "//:gpr", "//:grpc", @@ -32,8 +32,8 @@ grpc_cc_test( grpc_cc_test( name = "channel_stack_test", - srcs = ["channel_stack_test.c"], - language = "C", + srcs = ["channel_stack_test.cc"], + language = "C++", deps = [ "//:gpr", "//:grpc", @@ -44,8 +44,8 @@ grpc_cc_test( grpc_cc_test( name = "channel_stack_builder_test", - srcs = ["channel_stack_builder_test.c"], - language = "C", + srcs = ["channel_stack_builder_test.cc"], + language = "C++", deps = [ "//:gpr", "//:grpc", diff --git a/test/core/channel/channel_args_test.c b/test/core/channel/channel_args_test.cc index deaf2933ec..5b0a770c84 100644 --- a/test/core/channel/channel_args_test.c +++ b/test/core/channel/channel_args_test.cc @@ -26,24 +26,24 @@ #include "test/core/util/test_config.h" static void test_create(void) { - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + grpc_core::ExecCtx exec_ctx; grpc_arg arg_int; grpc_arg arg_string; grpc_arg to_add[2]; - grpc_channel_args *ch_args; + grpc_channel_args* ch_args; - arg_int.key = "int_arg"; + arg_int.key = const_cast<char*>("int_arg"); arg_int.type = GRPC_ARG_INTEGER; arg_int.value.integer = 123; - arg_string.key = "str key"; + arg_string.key = const_cast<char*>("str key"); arg_string.type = GRPC_ARG_STRING; - arg_string.value.string = "str value"; + arg_string.value.string = const_cast<char*>("str value"); to_add[0] = arg_int; to_add[1] = arg_string; - ch_args = grpc_channel_args_copy_and_add(NULL, to_add, 2); + ch_args = grpc_channel_args_copy_and_add(nullptr, to_add, 2); GPR_ASSERT(ch_args->num_args == 2); GPR_ASSERT(strcmp(ch_args->args[0].key, arg_int.key) == 0); @@ -55,32 +55,31 @@ static void test_create(void) { GPR_ASSERT(strcmp(ch_args->args[1].value.string, arg_string.value.string) == 0); - grpc_channel_args_destroy(&exec_ctx, ch_args); - grpc_exec_ctx_finish(&exec_ctx); + grpc_channel_args_destroy(ch_args); } static void test_set_compression_algorithm(void) { - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_channel_args *ch_args; + grpc_core::ExecCtx exec_ctx; + grpc_channel_args* ch_args; - ch_args = - grpc_channel_args_set_compression_algorithm(NULL, GRPC_COMPRESS_GZIP); + ch_args = grpc_channel_args_set_compression_algorithm( + nullptr, GRPC_COMPRESS_MESSAGE_GZIP); GPR_ASSERT(ch_args->num_args == 1); GPR_ASSERT(strcmp(ch_args->args[0].key, GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM) == 0); GPR_ASSERT(ch_args->args[0].type == GRPC_ARG_INTEGER); - grpc_channel_args_destroy(&exec_ctx, ch_args); - grpc_exec_ctx_finish(&exec_ctx); + grpc_channel_args_destroy(ch_args); } static void test_compression_algorithm_states(void) { - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_channel_args *ch_args, *ch_args_wo_gzip, *ch_args_wo_gzip_deflate; + grpc_core::ExecCtx exec_ctx; + grpc_channel_args *ch_args, *ch_args_wo_gzip, *ch_args_wo_gzip_deflate, + *ch_args_wo_gzip_deflate_gzip; unsigned states_bitset; size_t i; - ch_args = grpc_channel_args_copy_and_add(NULL, NULL, 0); + ch_args = grpc_channel_args_copy_and_add(nullptr, nullptr, 0); /* by default, all enabled */ states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states(ch_args); @@ -89,61 +88,66 @@ static void test_compression_algorithm_states(void) { GPR_ASSERT(GPR_BITGET(states_bitset, i)); } - /* disable gzip and deflate */ + /* disable message/gzip and message/deflate and stream/gzip */ ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state( - &exec_ctx, &ch_args, GRPC_COMPRESS_GZIP, 0); + &ch_args, GRPC_COMPRESS_MESSAGE_GZIP, 0); GPR_ASSERT(ch_args == ch_args_wo_gzip); ch_args_wo_gzip_deflate = grpc_channel_args_compression_algorithm_set_state( - &exec_ctx, &ch_args_wo_gzip, GRPC_COMPRESS_DEFLATE, 0); + &ch_args_wo_gzip, GRPC_COMPRESS_MESSAGE_DEFLATE, 0); GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate); + ch_args_wo_gzip_deflate_gzip = + grpc_channel_args_compression_algorithm_set_state( + &ch_args_wo_gzip_deflate, GRPC_COMPRESS_STREAM_GZIP, 0); + GPR_ASSERT(ch_args_wo_gzip_deflate == ch_args_wo_gzip_deflate_gzip); states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states( ch_args_wo_gzip_deflate); for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) { - if (i == GRPC_COMPRESS_GZIP || i == GRPC_COMPRESS_DEFLATE) { + if (i == GRPC_COMPRESS_MESSAGE_GZIP || i == GRPC_COMPRESS_MESSAGE_DEFLATE || + i == GRPC_COMPRESS_STREAM_GZIP) { GPR_ASSERT(GPR_BITGET(states_bitset, i) == 0); } else { GPR_ASSERT(GPR_BITGET(states_bitset, i) != 0); } } - /* re-enabled gzip only */ + /* re-enabled message/gzip and stream/gzip only */ ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state( - &exec_ctx, &ch_args_wo_gzip_deflate, GRPC_COMPRESS_GZIP, 1); - GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate); + &ch_args_wo_gzip_deflate_gzip, GRPC_COMPRESS_MESSAGE_GZIP, 1); + ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state( + &ch_args_wo_gzip, GRPC_COMPRESS_STREAM_GZIP, 1); + GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate_gzip); states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states( ch_args_wo_gzip); for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) { - if (i == GRPC_COMPRESS_DEFLATE) { + if (i == GRPC_COMPRESS_MESSAGE_DEFLATE) { GPR_ASSERT(GPR_BITGET(states_bitset, i) == 0); } else { GPR_ASSERT(GPR_BITGET(states_bitset, i) != 0); } } - grpc_channel_args_destroy(&exec_ctx, ch_args); - grpc_exec_ctx_finish(&exec_ctx); + grpc_channel_args_destroy(ch_args); } static void test_set_socket_mutator(void) { - grpc_channel_args *ch_args; + grpc_channel_args* ch_args; grpc_socket_mutator mutator; - grpc_socket_mutator_init(&mutator, NULL); + grpc_socket_mutator_init(&mutator, nullptr); - ch_args = grpc_channel_args_set_socket_mutator(NULL, &mutator); + ch_args = grpc_channel_args_set_socket_mutator(nullptr, &mutator); GPR_ASSERT(ch_args->num_args == 1); GPR_ASSERT(strcmp(ch_args->args[0].key, GRPC_ARG_SOCKET_MUTATOR) == 0); GPR_ASSERT(ch_args->args[0].type == GRPC_ARG_POINTER); { - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_channel_args_destroy(&exec_ctx, ch_args); - grpc_exec_ctx_finish(&exec_ctx); + grpc_core::ExecCtx exec_ctx; + grpc_channel_args_destroy(ch_args); } } -int main(int argc, char **argv) { +int main(int argc, char** argv) { grpc_test_init(argc, argv); grpc_init(); test_create(); diff --git a/test/core/channel/channel_stack_builder_test.c b/test/core/channel/channel_stack_builder_test.cc index 682efd1438..ef6db81b0b 100644 --- a/test/core/channel/channel_stack_builder_test.c +++ b/test/core/channel/channel_stack_builder_test.cc @@ -29,50 +29,46 @@ #include "src/core/lib/surface/channel_init.h" #include "test/core/util/test_config.h" -static grpc_error *channel_init_func(grpc_exec_ctx *exec_ctx, - grpc_channel_element *elem, - grpc_channel_element_args *args) { +static grpc_error* channel_init_func(grpc_channel_element* elem, + grpc_channel_element_args* args) { return GRPC_ERROR_NONE; } -static grpc_error *call_init_func(grpc_exec_ctx *exec_ctx, - grpc_call_element *elem, - const grpc_call_element_args *args) { +static grpc_error* call_init_func(grpc_call_element* elem, + const grpc_call_element_args* args) { return GRPC_ERROR_NONE; } -static void channel_destroy_func(grpc_exec_ctx *exec_ctx, - grpc_channel_element *elem) {} +static void channel_destroy_func(grpc_channel_element* elem) {} -static void call_destroy_func(grpc_exec_ctx *exec_ctx, grpc_call_element *elem, - const grpc_call_final_info *final_info, - grpc_closure *ignored) {} +static void call_destroy_func(grpc_call_element* elem, + const grpc_call_final_info* final_info, + grpc_closure* ignored) {} -static void call_func(grpc_exec_ctx *exec_ctx, grpc_call_element *elem, - grpc_transport_stream_op_batch *op) {} +static void call_func(grpc_call_element* elem, + grpc_transport_stream_op_batch* op) {} -static void channel_func(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem, - grpc_transport_op *op) { +static void channel_func(grpc_channel_element* elem, grpc_transport_op* op) { if (op->disconnect_with_error != GRPC_ERROR_NONE) { GRPC_ERROR_UNREF(op->disconnect_with_error); } - GRPC_CLOSURE_SCHED(exec_ctx, op->on_consumed, GRPC_ERROR_NONE); + GRPC_CLOSURE_SCHED(op->on_consumed, GRPC_ERROR_NONE); } bool g_replacement_fn_called = false; bool g_original_fn_called = false; -void set_arg_once_fn(grpc_channel_stack *channel_stack, - grpc_channel_element *elem, void *arg) { - bool *called = arg; +void set_arg_once_fn(grpc_channel_stack* channel_stack, + grpc_channel_element* elem, void* arg) { + bool* called = static_cast<bool*>(arg); // Make sure this function is only called once per arg. GPR_ASSERT(*called == false); *called = true; } static void test_channel_stack_builder_filter_replace(void) { - grpc_channel *channel = - grpc_insecure_channel_create("target name isn't used", NULL, NULL); - GPR_ASSERT(channel != NULL); + grpc_channel* channel = + grpc_insecure_channel_create("target name isn't used", nullptr, nullptr); + GPR_ASSERT(channel != nullptr); // Make sure the high priority filter has been created. GPR_ASSERT(g_replacement_fn_called); // ... and that the low priority one hasn't. @@ -106,10 +102,10 @@ const grpc_channel_filter original_filter = { grpc_channel_next_get_info, "filter_name"}; -static bool add_replacement_filter(grpc_exec_ctx *exec_ctx, - grpc_channel_stack_builder *builder, - void *arg) { - const grpc_channel_filter *filter = arg; +static bool add_replacement_filter(grpc_channel_stack_builder* builder, + void* arg) { + const grpc_channel_filter* filter = + static_cast<const grpc_channel_filter*>(arg); // Get rid of any other version of the filter, as determined by having the // same name. GPR_ASSERT(grpc_channel_stack_builder_remove_filter(builder, filter->name)); @@ -117,26 +113,25 @@ static bool add_replacement_filter(grpc_exec_ctx *exec_ctx, builder, filter, set_arg_once_fn, &g_replacement_fn_called); } -static bool add_original_filter(grpc_exec_ctx *exec_ctx, - grpc_channel_stack_builder *builder, - void *arg) { +static bool add_original_filter(grpc_channel_stack_builder* builder, + void* arg) { return grpc_channel_stack_builder_prepend_filter( - builder, (const grpc_channel_filter *)arg, set_arg_once_fn, + builder, (const grpc_channel_filter*)arg, set_arg_once_fn, &g_original_fn_called); } static void init_plugin(void) { grpc_channel_init_register_stage(GRPC_CLIENT_CHANNEL, INT_MAX, add_original_filter, - (void *)&original_filter); + (void*)&original_filter); grpc_channel_init_register_stage(GRPC_CLIENT_CHANNEL, INT_MAX, add_replacement_filter, - (void *)&replacement_filter); + (void*)&replacement_filter); } static void destroy_plugin(void) {} -int main(int argc, char **argv) { +int main(int argc, char** argv) { grpc_test_init(argc, argv); grpc_register_plugin(init_plugin, destroy_plugin); grpc_init(); diff --git a/test/core/channel/channel_stack_test.c b/test/core/channel/channel_stack_test.c deleted file mode 100644 index 7c3614b4a2..0000000000 --- a/test/core/channel/channel_stack_test.c +++ /dev/null @@ -1,157 +0,0 @@ -/* - * - * Copyright 2015 gRPC authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -#include "src/core/lib/channel/channel_stack.h" - -#include <string.h> - -#include <grpc/support/alloc.h> -#include <grpc/support/log.h> -#include <grpc/support/string_util.h> - -#include "src/core/lib/slice/slice_internal.h" -#include "test/core/util/test_config.h" - -static grpc_error *channel_init_func(grpc_exec_ctx *exec_ctx, - 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; - return GRPC_ERROR_NONE; -} - -static grpc_error *call_init_func(grpc_exec_ctx *exec_ctx, - grpc_call_element *elem, - const grpc_call_element_args *args) { - ++*(int *)(elem->channel_data); - *(int *)(elem->call_data) = 0; - return GRPC_ERROR_NONE; -} - -static void channel_destroy_func(grpc_exec_ctx *exec_ctx, - grpc_channel_element *elem) {} - -static void call_destroy_func(grpc_exec_ctx *exec_ctx, grpc_call_element *elem, - const grpc_call_final_info *final_info, - grpc_closure *ignored) { - ++*(int *)(elem->channel_data); -} - -static void call_func(grpc_exec_ctx *exec_ctx, grpc_call_element *elem, - grpc_transport_stream_op_batch *op) { - ++*(int *)(elem->call_data); -} - -static void channel_func(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem, - grpc_transport_op *op) { - ++*(int *)(elem->channel_data); -} - -static void free_channel(grpc_exec_ctx *exec_ctx, void *arg, - grpc_error *error) { - grpc_channel_stack_destroy(exec_ctx, arg); - gpr_free(arg); -} - -static void free_call(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) { - grpc_call_stack_destroy(exec_ctx, arg, NULL, NULL); - gpr_free(arg); -} - -static void test_create_channel_stack(void) { - const grpc_channel_filter filter = { - call_func, - channel_func, - sizeof(int), - call_init_func, - grpc_call_stack_ignore_set_pollset_or_pollset_set, - call_destroy_func, - sizeof(int), - channel_init_func, - channel_destroy_func, - grpc_channel_next_get_info, - "some_test_filter"}; - const grpc_channel_filter *filters = &filter; - grpc_channel_stack *channel_stack; - grpc_call_stack *call_stack; - grpc_channel_element *channel_elem; - grpc_call_element *call_elem; - grpc_arg arg; - grpc_channel_args chan_args; - int *channel_data; - int *call_data; - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_slice path = grpc_slice_from_static_string("/service/method"); - - arg.type = GRPC_ARG_INTEGER; - arg.key = "test_key"; - arg.value.integer = 42; - - chan_args.num_args = 1; - chan_args.args = &arg; - - channel_stack = gpr_malloc(grpc_channel_stack_size(&filters, 1)); - grpc_channel_stack_init(&exec_ctx, 1, free_channel, channel_stack, &filters, - 1, &chan_args, NULL, "test", 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); - const grpc_call_element_args args = { - .call_stack = call_stack, - .server_transport_data = NULL, - .context = NULL, - .path = path, - .start_time = gpr_now(GPR_CLOCK_MONOTONIC), - .deadline = gpr_inf_future(GPR_CLOCK_MONOTONIC), - .arena = NULL}; - grpc_error *error = grpc_call_stack_init(&exec_ctx, channel_stack, 1, - free_call, call_stack, &args); - GPR_ASSERT(error == GRPC_ERROR_NONE); - GPR_ASSERT(call_stack->count == 1); - call_elem = grpc_call_stack_element(call_stack, 0); - GPR_ASSERT(call_elem->filter == channel_elem->filter); - GPR_ASSERT(call_elem->channel_data == channel_elem->channel_data); - call_data = (int *)call_elem->call_data; - GPR_ASSERT(*call_data == 0); - GPR_ASSERT(*channel_data == 1); - - GRPC_CALL_STACK_UNREF(&exec_ctx, call_stack, "done"); - grpc_exec_ctx_flush(&exec_ctx); - GPR_ASSERT(*channel_data == 2); - - GRPC_CHANNEL_STACK_UNREF(&exec_ctx, channel_stack, "done"); - - grpc_slice_unref_internal(&exec_ctx, path); - 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/channel/channel_stack_test.cc b/test/core/channel/channel_stack_test.cc new file mode 100644 index 0000000000..ef43facd6e --- /dev/null +++ b/test/core/channel/channel_stack_test.cc @@ -0,0 +1,155 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include "src/core/lib/channel/channel_stack.h" + +#include <string.h> + +#include <grpc/support/alloc.h> +#include <grpc/support/log.h> +#include <grpc/support/string_util.h> + +#include "src/core/lib/slice/slice_internal.h" +#include "test/core/util/test_config.h" + +static grpc_error* channel_init_func(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; + return GRPC_ERROR_NONE; +} + +static grpc_error* call_init_func(grpc_call_element* elem, + const grpc_call_element_args* args) { + ++*(int*)(elem->channel_data); + *(int*)(elem->call_data) = 0; + return GRPC_ERROR_NONE; +} + +static void channel_destroy_func(grpc_channel_element* elem) {} + +static void call_destroy_func(grpc_call_element* elem, + const grpc_call_final_info* final_info, + grpc_closure* ignored) { + ++*(int*)(elem->channel_data); +} + +static void call_func(grpc_call_element* elem, + grpc_transport_stream_op_batch* op) { + ++*(int*)(elem->call_data); +} + +static void channel_func(grpc_channel_element* elem, grpc_transport_op* op) { + ++*(int*)(elem->channel_data); +} + +static void free_channel(void* arg, grpc_error* error) { + grpc_channel_stack_destroy(static_cast<grpc_channel_stack*>(arg)); + gpr_free(arg); +} + +static void free_call(void* arg, grpc_error* error) { + grpc_call_stack_destroy(static_cast<grpc_call_stack*>(arg), nullptr, nullptr); + gpr_free(arg); +} + +static void test_create_channel_stack(void) { + const grpc_channel_filter filter = { + call_func, + channel_func, + sizeof(int), + call_init_func, + grpc_call_stack_ignore_set_pollset_or_pollset_set, + call_destroy_func, + sizeof(int), + channel_init_func, + channel_destroy_func, + grpc_channel_next_get_info, + "some_test_filter"}; + const grpc_channel_filter* filters = &filter; + grpc_channel_stack* channel_stack; + grpc_call_stack* call_stack; + grpc_channel_element* channel_elem; + grpc_call_element* call_elem; + grpc_arg arg; + grpc_channel_args chan_args; + int* channel_data; + int* call_data; + grpc_core::ExecCtx exec_ctx; + grpc_slice path = grpc_slice_from_static_string("/service/method"); + + arg.type = GRPC_ARG_INTEGER; + arg.key = const_cast<char*>("test_key"); + arg.value.integer = 42; + + chan_args.num_args = 1; + chan_args.args = &arg; + + channel_stack = static_cast<grpc_channel_stack*>( + gpr_malloc(grpc_channel_stack_size(&filters, 1))); + grpc_channel_stack_init(1, free_channel, channel_stack, &filters, 1, + &chan_args, nullptr, "test", 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 = + static_cast<grpc_call_stack*>(gpr_malloc(channel_stack->call_stack_size)); + const grpc_call_element_args args = { + call_stack, /* call_stack */ + nullptr, /* server_transport_data */ + nullptr, /* context */ + path, /* path */ + gpr_now(GPR_CLOCK_MONOTONIC), /* start_time */ + GRPC_MILLIS_INF_FUTURE, /* deadline */ + nullptr, /* arena */ + nullptr /* call_combiner */ + }; + grpc_error* error = + grpc_call_stack_init(channel_stack, 1, free_call, call_stack, &args); + GPR_ASSERT(error == GRPC_ERROR_NONE); + GPR_ASSERT(call_stack->count == 1); + call_elem = grpc_call_stack_element(call_stack, 0); + GPR_ASSERT(call_elem->filter == channel_elem->filter); + GPR_ASSERT(call_elem->channel_data == channel_elem->channel_data); + call_data = (int*)call_elem->call_data; + GPR_ASSERT(*call_data == 0); + GPR_ASSERT(*channel_data == 1); + + GRPC_CALL_STACK_UNREF(call_stack, "done"); + grpc_core::ExecCtx::Get()->Flush(); + GPR_ASSERT(*channel_data == 2); + + GRPC_CHANNEL_STACK_UNREF(channel_stack, "done"); + + grpc_slice_unref_internal(path); +} + +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/channel/minimal_stack_is_minimal_test.c b/test/core/channel/minimal_stack_is_minimal_test.cc index b4528346f7..f02c8180f2 100644 --- a/test/core/channel/minimal_stack_is_minimal_test.c +++ b/test/core/channel/minimal_stack_is_minimal_test.cc @@ -35,15 +35,15 @@ #include <string.h> #include "src/core/lib/channel/channel_stack_builder.h" -#include "src/core/lib/support/string.h" +#include "src/core/lib/gpr/string.h" #include "src/core/lib/surface/channel_init.h" #include "src/core/lib/surface/channel_stack_type.h" #include "src/core/lib/transport/transport_impl.h" #include "test/core/util/test_config.h" // use CHECK_STACK instead -static int check_stack(const char *file, int line, const char *transport_name, - grpc_channel_args *init_args, +static int check_stack(const char* file, int line, const char* transport_name, + grpc_channel_args* init_args, unsigned channel_stack_type, ...); // arguments: const char *transport_name - the name of the transport type to @@ -55,17 +55,17 @@ static int check_stack(const char *file, int line, const char *transport_name, // filters to instantiate, terminated with NULL #define CHECK_STACK(...) check_stack(__FILE__, __LINE__, __VA_ARGS__) -int main(int argc, char **argv) { +int main(int argc, char** argv) { grpc_test_init(argc, argv); grpc_init(); int errors = 0; // tests with a minimal stack - grpc_arg minimal_stack_arg = {.type = GRPC_ARG_INTEGER, - .key = GRPC_ARG_MINIMAL_STACK, - .value.integer = 1}; - grpc_channel_args minimal_stack_args = {.num_args = 1, - .args = &minimal_stack_arg}; + grpc_arg minimal_stack_arg; + minimal_stack_arg.type = GRPC_ARG_INTEGER; + minimal_stack_arg.key = const_cast<char*>(GRPC_ARG_MINIMAL_STACK); + minimal_stack_arg.value.integer = 1; + grpc_channel_args minimal_stack_args = {1, &minimal_stack_arg}; errors += CHECK_STACK("unknown", &minimal_stack_args, GRPC_CLIENT_DIRECT_CHANNEL, "connected", NULL); errors += CHECK_STACK("unknown", &minimal_stack_args, GRPC_CLIENT_SUBCHANNEL, @@ -79,26 +79,27 @@ int main(int argc, char **argv) { "http-client", "connected", NULL); errors += CHECK_STACK("chttp2", &minimal_stack_args, GRPC_SERVER_CHANNEL, "server", "http-server", "connected", NULL); - errors += CHECK_STACK(NULL, &minimal_stack_args, GRPC_CLIENT_CHANNEL, + errors += CHECK_STACK(nullptr, &minimal_stack_args, GRPC_CLIENT_CHANNEL, "client-channel", NULL); // tests with a default stack - errors += CHECK_STACK("unknown", NULL, GRPC_CLIENT_DIRECT_CHANNEL, + errors += CHECK_STACK("unknown", nullptr, GRPC_CLIENT_DIRECT_CHANNEL, "message_size", "deadline", "connected", NULL); - errors += CHECK_STACK("unknown", NULL, GRPC_CLIENT_SUBCHANNEL, "message_size", - "connected", NULL); - errors += CHECK_STACK("unknown", NULL, GRPC_SERVER_CHANNEL, "server", + errors += CHECK_STACK("unknown", nullptr, GRPC_CLIENT_SUBCHANNEL, + "message_size", "connected", NULL); + errors += CHECK_STACK("unknown", nullptr, GRPC_SERVER_CHANNEL, "server", "message_size", "deadline", "connected", NULL); - errors += CHECK_STACK("chttp2", NULL, GRPC_CLIENT_DIRECT_CHANNEL, + errors += CHECK_STACK("chttp2", nullptr, GRPC_CLIENT_DIRECT_CHANNEL, "message_size", "deadline", "http-client", "message_compress", "connected", NULL); - errors += CHECK_STACK("chttp2", NULL, GRPC_CLIENT_SUBCHANNEL, "message_size", - "http-client", "message_compress", "connected", NULL); - errors += CHECK_STACK("chttp2", NULL, GRPC_SERVER_CHANNEL, "server", + errors += + CHECK_STACK("chttp2", nullptr, GRPC_CLIENT_SUBCHANNEL, "message_size", + "http-client", "message_compress", "connected", NULL); + errors += CHECK_STACK("chttp2", nullptr, GRPC_SERVER_CHANNEL, "server", "message_size", "deadline", "http-server", "message_compress", "connected", NULL); - errors += - CHECK_STACK(NULL, NULL, GRPC_CLIENT_CHANNEL, "client-channel", NULL); + errors += CHECK_STACK(nullptr, nullptr, GRPC_CLIENT_CHANNEL, "client-channel", + NULL); GPR_ASSERT(errors == 0); grpc_shutdown(); @@ -109,25 +110,25 @@ int main(int argc, char **argv) { * End of tests definitions, start of test infrastructure */ -static int check_stack(const char *file, int line, const char *transport_name, - grpc_channel_args *init_args, +static int check_stack(const char* file, int line, const char* transport_name, + grpc_channel_args* init_args, unsigned channel_stack_type, ...) { // create dummy channel stack - grpc_channel_stack_builder *builder = grpc_channel_stack_builder_create(); - grpc_transport_vtable fake_transport_vtable = {.name = transport_name}; - grpc_transport fake_transport = {.vtable = &fake_transport_vtable}; + grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create(); + grpc_transport_vtable fake_transport_vtable; + memset(&fake_transport_vtable, 0, sizeof(grpc_transport_vtable)); + fake_transport_vtable.name = transport_name; + grpc_transport fake_transport = {&fake_transport_vtable}; grpc_channel_stack_builder_set_target(builder, "foo.test.google.fr"); - grpc_channel_args *channel_args = grpc_channel_args_copy(init_args); - if (transport_name != NULL) { + grpc_channel_args* channel_args = grpc_channel_args_copy(init_args); + if (transport_name != nullptr) { grpc_channel_stack_builder_set_transport(builder, &fake_transport); } { - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_channel_stack_builder_set_channel_arguments(&exec_ctx, builder, - channel_args); + grpc_core::ExecCtx exec_ctx; + grpc_channel_stack_builder_set_channel_arguments(builder, channel_args); GPR_ASSERT(grpc_channel_init_create_stack( - &exec_ctx, builder, (grpc_channel_stack_type)channel_stack_type)); - grpc_exec_ctx_finish(&exec_ctx); + builder, (grpc_channel_stack_type)channel_stack_type)); } // build up our expectation list @@ -136,26 +137,26 @@ static int check_stack(const char *file, int line, const char *transport_name, va_list args; va_start(args, channel_stack_type); for (;;) { - char *a = va_arg(args, char *); - if (a == NULL) break; + char* a = va_arg(args, char*); + if (a == nullptr) break; if (v.count != 0) gpr_strvec_add(&v, gpr_strdup(", ")); gpr_strvec_add(&v, gpr_strdup(a)); } va_end(args); - char *expect = gpr_strvec_flatten(&v, NULL); + char* expect = gpr_strvec_flatten(&v, nullptr); gpr_strvec_destroy(&v); // build up our "got" list gpr_strvec_init(&v); - grpc_channel_stack_builder_iterator *it = + grpc_channel_stack_builder_iterator* it = grpc_channel_stack_builder_create_iterator_at_first(builder); while (grpc_channel_stack_builder_move_next(it)) { - const char *name = grpc_channel_stack_builder_iterator_filter_name(it); - if (name == NULL) continue; + const char* name = grpc_channel_stack_builder_iterator_filter_name(it); + if (name == nullptr) continue; if (v.count != 0) gpr_strvec_add(&v, gpr_strdup(", ")); gpr_strvec_add(&v, gpr_strdup(name)); } - char *got = gpr_strvec_flatten(&v, NULL); + char* got = gpr_strvec_flatten(&v, nullptr); gpr_strvec_destroy(&v); grpc_channel_stack_builder_iterator_destroy(it); @@ -170,7 +171,7 @@ static int check_stack(const char *file, int line, const char *transport_name, gpr_strvec_add(&v, gpr_strdup("=")); switch (channel_args->args[i].type) { case GRPC_ARG_INTEGER: { - char *tmp; + char* tmp; gpr_asprintf(&tmp, "%d", channel_args->args[i].value.integer); gpr_strvec_add(&v, tmp); break; @@ -179,7 +180,7 @@ static int check_stack(const char *file, int line, const char *transport_name, gpr_strvec_add(&v, gpr_strdup(channel_args->args[i].value.string)); break; case GRPC_ARG_POINTER: { - char *tmp; + char* tmp; gpr_asprintf(&tmp, "%p", channel_args->args[i].value.pointer.p); gpr_strvec_add(&v, tmp); break; @@ -187,15 +188,17 @@ static int check_stack(const char *file, int line, const char *transport_name, } } gpr_strvec_add(&v, gpr_strdup("}")); - char *args_str = gpr_strvec_flatten(&v, NULL); + char* args_str = gpr_strvec_flatten(&v, nullptr); gpr_strvec_destroy(&v); gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, "**************************************************"); - gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, - "FAILED transport=%s; stack_type=%s; channel_args=%s:", - transport_name, grpc_channel_stack_type_string(channel_stack_type), - args_str); + gpr_log( + file, line, GPR_LOG_SEVERITY_ERROR, + "FAILED transport=%s; stack_type=%s; channel_args=%s:", transport_name, + grpc_channel_stack_type_string( + static_cast<grpc_channel_stack_type>(channel_stack_type)), + args_str); gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, "EXPECTED: %s", expect); gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, "GOT: %s", got); result = 1; @@ -207,10 +210,9 @@ static int check_stack(const char *file, int line, const char *transport_name, gpr_free(expect); { - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_channel_stack_builder_destroy(&exec_ctx, builder); - grpc_channel_args_destroy(&exec_ctx, channel_args); - grpc_exec_ctx_finish(&exec_ctx); + grpc_core::ExecCtx exec_ctx; + grpc_channel_stack_builder_destroy(builder); + grpc_channel_args_destroy(channel_args); } return result; |