1 //
2 //
3 // Copyright 2015 gRPC authors.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17 //
18
19 #include "src/core/lib/channel/channel_stack.h"
20
21 #include "absl/status/status.h"
22 #include "absl/types/optional.h"
23 #include "gtest/gtest.h"
24
25 #include <grpc/support/alloc.h>
26
27 #include "src/core/lib/channel/channel_args.h"
28 #include "src/core/lib/channel/channel_args_preconditioning.h"
29 #include "src/core/lib/config/core_configuration.h"
30 #include "src/core/lib/gprpp/status_helper.h"
31 #include "src/core/lib/iomgr/exec_ctx.h"
32 #include "test/core/util/test_config.h"
33
channel_init_func(grpc_channel_element * elem,grpc_channel_element_args * args)34 static grpc_error_handle channel_init_func(grpc_channel_element* elem,
35 grpc_channel_element_args* args) {
36 int test_value = args->channel_args.GetInt("test_key").value_or(-1);
37 EXPECT_EQ(test_value, 42);
38 auto* ee = args->channel_args
39 .GetObject<grpc_event_engine::experimental::EventEngine>();
40 EXPECT_NE(ee, nullptr);
41 EXPECT_TRUE(args->is_first);
42 EXPECT_TRUE(args->is_last);
43 *static_cast<int*>(elem->channel_data) = 0;
44 return absl::OkStatus();
45 }
46
call_init_func(grpc_call_element * elem,const grpc_call_element_args *)47 static grpc_error_handle call_init_func(
48 grpc_call_element* elem, const grpc_call_element_args* /*args*/) {
49 ++*static_cast<int*>(elem->channel_data);
50 *static_cast<int*>(elem->call_data) = 0;
51 return absl::OkStatus();
52 }
53
channel_destroy_func(grpc_channel_element *)54 static void channel_destroy_func(grpc_channel_element* /*elem*/) {}
55
call_destroy_func(grpc_call_element * elem,const grpc_call_final_info *,grpc_closure *)56 static void call_destroy_func(grpc_call_element* elem,
57 const grpc_call_final_info* /*final_info*/,
58 grpc_closure* /*ignored*/) {
59 ++*static_cast<int*>(elem->channel_data);
60 }
61
call_func(grpc_call_element * elem,grpc_transport_stream_op_batch *)62 static void call_func(grpc_call_element* elem,
63 grpc_transport_stream_op_batch* /*op*/) {
64 ++*static_cast<int*>(elem->call_data);
65 }
66
channel_func(grpc_channel_element * elem,grpc_transport_op *)67 static void channel_func(grpc_channel_element* elem,
68 grpc_transport_op* /*op*/) {
69 ++*static_cast<int*>(elem->channel_data);
70 }
71
free_channel(void * arg,grpc_error_handle)72 static void free_channel(void* arg, grpc_error_handle /*error*/) {
73 grpc_channel_stack_destroy(static_cast<grpc_channel_stack*>(arg));
74 gpr_free(arg);
75 }
76
free_call(void * arg,grpc_error_handle)77 static void free_call(void* arg, grpc_error_handle /*error*/) {
78 grpc_call_stack_destroy(static_cast<grpc_call_stack*>(arg), nullptr, nullptr);
79 gpr_free(arg);
80 }
81
TEST(ChannelStackTest,CreateChannelStack)82 TEST(ChannelStackTest, CreateChannelStack) {
83 const grpc_channel_filter filter = {
84 call_func,
85 nullptr,
86 nullptr,
87 channel_func,
88 sizeof(int),
89 call_init_func,
90 grpc_call_stack_ignore_set_pollset_or_pollset_set,
91 call_destroy_func,
92 sizeof(int),
93 channel_init_func,
94 grpc_channel_stack_no_post_init,
95 channel_destroy_func,
96 grpc_channel_next_get_info,
97 "some_test_filter"};
98 const grpc_channel_filter* filters = &filter;
99 grpc_channel_stack* channel_stack;
100 grpc_call_stack* call_stack;
101 grpc_channel_element* channel_elem;
102 grpc_call_element* call_elem;
103 int* channel_data;
104 int* call_data;
105 grpc_core::ExecCtx exec_ctx;
106 grpc_slice path = grpc_slice_from_static_string("/service/method");
107
108 channel_stack = static_cast<grpc_channel_stack*>(
109 gpr_malloc(grpc_channel_stack_size(&filters, 1)));
110 auto channel_args = grpc_core::CoreConfiguration::Get()
111 .channel_args_preconditioning()
112 .PreconditionChannelArgs(nullptr)
113 .Set("test_key", 42);
114 ASSERT_TRUE(GRPC_LOG_IF_ERROR(
115 "grpc_channel_stack_init",
116 grpc_channel_stack_init(1, free_channel, channel_stack, &filters, 1,
117 channel_args, "test", channel_stack)));
118 EXPECT_EQ(channel_stack->count, 1);
119 channel_elem = grpc_channel_stack_element(channel_stack, 0);
120 channel_data = static_cast<int*>(channel_elem->channel_data);
121 EXPECT_EQ(*channel_data, 0);
122
123 call_stack =
124 static_cast<grpc_call_stack*>(gpr_malloc(channel_stack->call_stack_size));
125 const grpc_call_element_args args = {
126 call_stack, // call_stack
127 nullptr, // server_transport_data
128 nullptr, // context
129 path, // path
130 gpr_get_cycle_counter(), // start_time
131 grpc_core::Timestamp::InfFuture(), // deadline
132 nullptr, // arena
133 nullptr, // call_combiner
134 };
135 grpc_error_handle error =
136 grpc_call_stack_init(channel_stack, 1, free_call, call_stack, &args);
137 ASSERT_TRUE(error.ok()) << grpc_core::StatusToString(error);
138 EXPECT_EQ(call_stack->count, 1);
139 call_elem = grpc_call_stack_element(call_stack, 0);
140 EXPECT_EQ(call_elem->filter, channel_elem->filter);
141 EXPECT_EQ(call_elem->channel_data, channel_elem->channel_data);
142 call_data = static_cast<int*>(call_elem->call_data);
143 EXPECT_EQ(*call_data, 0);
144 EXPECT_EQ(*channel_data, 1);
145
146 GRPC_CALL_STACK_UNREF(call_stack, "done");
147 grpc_core::ExecCtx::Get()->Flush();
148 EXPECT_EQ(*channel_data, 2);
149
150 GRPC_CHANNEL_STACK_UNREF(channel_stack, "done");
151
152 grpc_slice_unref(path);
153 }
154
main(int argc,char ** argv)155 int main(int argc, char** argv) {
156 grpc::testing::TestEnvironment env(&argc, argv);
157 ::testing::InitGoogleTest(&argc, argv);
158 grpc::testing::TestGrpcScope grpc_scope;
159 return RUN_ALL_TESTS();
160 }
161