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 <grpcpp/support/channel_arguments.h>
20
21 #include <grpc/grpc.h>
22 #include <grpcpp/grpcpp.h>
23 #include <gtest/gtest.h>
24
25 #include "src/core/lib/gpr/useful.h"
26 #include "src/core/lib/iomgr/exec_ctx.h"
27 #include "src/core/lib/iomgr/socket_mutator.h"
28
29 namespace grpc {
30 namespace testing {
31
32 namespace {
33
34 // A simple grpc_socket_mutator to be used to test SetSocketMutator
35 class TestSocketMutator : public grpc_socket_mutator {
36 public:
37 TestSocketMutator();
38
MutateFd(int fd)39 bool MutateFd(int fd) {
40 // Do nothing on the fd
41 return true;
42 }
43 };
44
45 //
46 // C API for TestSocketMutator
47 //
48
test_mutator_mutate_fd(int fd,grpc_socket_mutator * mutator)49 bool test_mutator_mutate_fd(int fd, grpc_socket_mutator* mutator) {
50 TestSocketMutator* tsm = (TestSocketMutator*)mutator;
51 return tsm->MutateFd(fd);
52 }
53
test_mutator_compare(grpc_socket_mutator * a,grpc_socket_mutator * b)54 int test_mutator_compare(grpc_socket_mutator* a, grpc_socket_mutator* b) {
55 return GPR_ICMP(a, b);
56 }
57
test_mutator_destroy(grpc_socket_mutator * mutator)58 void test_mutator_destroy(grpc_socket_mutator* mutator) {
59 TestSocketMutator* tsm = (TestSocketMutator*)mutator;
60 delete tsm;
61 }
62
63 grpc_socket_mutator_vtable test_mutator_vtable = {
64 test_mutator_mutate_fd, test_mutator_compare, test_mutator_destroy};
65
66 //
67 // TestSocketMutator implementation
68 //
69
TestSocketMutator()70 TestSocketMutator::TestSocketMutator() {
71 grpc_socket_mutator_init(this, &test_mutator_vtable);
72 }
73 } // namespace
74
75 class ChannelArgumentsTest : public ::testing::Test {
76 protected:
ChannelArgumentsTest()77 ChannelArgumentsTest()
78 : pointer_vtable_({&ChannelArguments::PointerVtableMembers::Copy,
79 &ChannelArguments::PointerVtableMembers::Destroy,
80 &ChannelArguments::PointerVtableMembers::Compare}) {}
81
SetChannelArgs(const ChannelArguments & channel_args,grpc_channel_args * args)82 void SetChannelArgs(const ChannelArguments& channel_args,
83 grpc_channel_args* args) {
84 channel_args.SetChannelArgs(args);
85 }
86
SetUpTestCase()87 static void SetUpTestCase() { grpc_init(); }
88
TearDownTestCase()89 static void TearDownTestCase() { grpc_shutdown(); }
90
GetDefaultUserAgentPrefix()91 grpc::string GetDefaultUserAgentPrefix() {
92 std::ostringstream user_agent_prefix;
93 user_agent_prefix << "grpc-c++/" << Version();
94 return user_agent_prefix.str();
95 }
96
VerifyDefaultChannelArgs()97 void VerifyDefaultChannelArgs() {
98 grpc_channel_args args;
99 SetChannelArgs(channel_args_, &args);
100 EXPECT_EQ(static_cast<size_t>(1), args.num_args);
101 EXPECT_STREQ(GRPC_ARG_PRIMARY_USER_AGENT_STRING, args.args[0].key);
102 EXPECT_EQ(GetDefaultUserAgentPrefix(),
103 grpc::string(args.args[0].value.string));
104 }
105
HasArg(grpc_arg expected_arg)106 bool HasArg(grpc_arg expected_arg) {
107 grpc_channel_args args;
108 SetChannelArgs(channel_args_, &args);
109 for (size_t i = 0; i < args.num_args; i++) {
110 const grpc_arg& arg = args.args[i];
111 if (arg.type == expected_arg.type &&
112 grpc::string(arg.key) == expected_arg.key) {
113 if (arg.type == GRPC_ARG_INTEGER) {
114 return arg.value.integer == expected_arg.value.integer;
115 } else if (arg.type == GRPC_ARG_STRING) {
116 return grpc::string(arg.value.string) == expected_arg.value.string;
117 } else if (arg.type == GRPC_ARG_POINTER) {
118 return arg.value.pointer.p == expected_arg.value.pointer.p &&
119 arg.value.pointer.vtable->copy ==
120 expected_arg.value.pointer.vtable->copy &&
121 arg.value.pointer.vtable->destroy ==
122 expected_arg.value.pointer.vtable->destroy;
123 }
124 }
125 }
126 return false;
127 }
128 grpc_arg_pointer_vtable pointer_vtable_;
129 ChannelArguments channel_args_;
130 };
131
TEST_F(ChannelArgumentsTest,SetInt)132 TEST_F(ChannelArgumentsTest, SetInt) {
133 VerifyDefaultChannelArgs();
134 grpc::string key0("key0");
135 grpc_arg arg0;
136 arg0.type = GRPC_ARG_INTEGER;
137 arg0.key = const_cast<char*>(key0.c_str());
138 arg0.value.integer = 0;
139 grpc::string key1("key1");
140 grpc_arg arg1;
141 arg1.type = GRPC_ARG_INTEGER;
142 arg1.key = const_cast<char*>(key1.c_str());
143 arg1.value.integer = 1;
144
145 grpc::string arg_key0(key0);
146 channel_args_.SetInt(arg_key0, arg0.value.integer);
147 // Clear key early to make sure channel_args takes a copy
148 arg_key0.clear();
149 EXPECT_TRUE(HasArg(arg0));
150
151 grpc::string arg_key1(key1);
152 channel_args_.SetInt(arg_key1, arg1.value.integer);
153 arg_key1.clear();
154 EXPECT_TRUE(HasArg(arg0));
155 EXPECT_TRUE(HasArg(arg1));
156 }
157
TEST_F(ChannelArgumentsTest,SetString)158 TEST_F(ChannelArgumentsTest, SetString) {
159 VerifyDefaultChannelArgs();
160 grpc::string key0("key0");
161 grpc::string val0("val0");
162 grpc_arg arg0;
163 arg0.type = GRPC_ARG_STRING;
164 arg0.key = const_cast<char*>(key0.c_str());
165 arg0.value.string = const_cast<char*>(val0.c_str());
166 grpc::string key1("key1");
167 grpc::string val1("val1");
168 grpc_arg arg1;
169 arg1.type = GRPC_ARG_STRING;
170 arg1.key = const_cast<char*>(key1.c_str());
171 arg1.value.string = const_cast<char*>(val1.c_str());
172
173 grpc::string key(key0);
174 grpc::string val(val0);
175 channel_args_.SetString(key, val);
176 // Clear key/val early to make sure channel_args takes a copy
177 key = "";
178 val = "";
179 EXPECT_TRUE(HasArg(arg0));
180
181 key = key1;
182 val = val1;
183 channel_args_.SetString(key, val);
184 // Clear key/val early to make sure channel_args takes a copy
185 key = "";
186 val = "";
187 EXPECT_TRUE(HasArg(arg0));
188 EXPECT_TRUE(HasArg(arg1));
189 }
190
TEST_F(ChannelArgumentsTest,SetPointer)191 TEST_F(ChannelArgumentsTest, SetPointer) {
192 VerifyDefaultChannelArgs();
193 grpc::string key0("key0");
194 grpc_arg arg0;
195 arg0.type = GRPC_ARG_POINTER;
196 arg0.key = const_cast<char*>(key0.c_str());
197 arg0.value.pointer.p = &key0;
198 arg0.value.pointer.vtable = &pointer_vtable_;
199
200 grpc::string key(key0);
201 channel_args_.SetPointer(key, arg0.value.pointer.p);
202 EXPECT_TRUE(HasArg(arg0));
203 }
204
TEST_F(ChannelArgumentsTest,SetSocketMutator)205 TEST_F(ChannelArgumentsTest, SetSocketMutator) {
206 VerifyDefaultChannelArgs();
207 grpc_arg arg0, arg1;
208 TestSocketMutator* mutator0 = new TestSocketMutator();
209 TestSocketMutator* mutator1 = new TestSocketMutator();
210 arg0 = grpc_socket_mutator_to_arg(mutator0);
211 arg1 = grpc_socket_mutator_to_arg(mutator1);
212
213 channel_args_.SetSocketMutator(mutator0);
214 EXPECT_TRUE(HasArg(arg0));
215
216 // Exercise the copy constructor because we ran some sanity checks in it.
217 grpc::ChannelArguments new_args{channel_args_};
218
219 channel_args_.SetSocketMutator(mutator1);
220 EXPECT_TRUE(HasArg(arg1));
221 // arg0 is replaced by arg1
222 EXPECT_FALSE(HasArg(arg0));
223 }
224
TEST_F(ChannelArgumentsTest,SetUserAgentPrefix)225 TEST_F(ChannelArgumentsTest, SetUserAgentPrefix) {
226 VerifyDefaultChannelArgs();
227 grpc::string prefix("prefix");
228 grpc::string whole_prefix = prefix + " " + GetDefaultUserAgentPrefix();
229 grpc_arg arg0;
230 arg0.type = GRPC_ARG_STRING;
231 arg0.key = const_cast<char*>(GRPC_ARG_PRIMARY_USER_AGENT_STRING);
232 arg0.value.string = const_cast<char*>(whole_prefix.c_str());
233
234 channel_args_.SetUserAgentPrefix(prefix);
235 EXPECT_TRUE(HasArg(arg0));
236
237 // Test if the user agent string is copied correctly
238 ChannelArguments new_channel_args(channel_args_);
239 grpc_channel_args args;
240 SetChannelArgs(new_channel_args, &args);
241 bool found = false;
242 for (size_t i = 0; i < args.num_args; i++) {
243 const grpc_arg& arg = args.args[i];
244 if (arg.type == GRPC_ARG_STRING &&
245 grpc::string(arg.key) == GRPC_ARG_PRIMARY_USER_AGENT_STRING) {
246 EXPECT_FALSE(found);
247 EXPECT_EQ(0, strcmp(arg.value.string, arg0.value.string));
248 found = true;
249 }
250 }
251 EXPECT_TRUE(found);
252 }
253
254 } // namespace testing
255 } // namespace grpc
256
main(int argc,char ** argv)257 int main(int argc, char** argv) {
258 ::testing::InitGoogleTest(&argc, argv);
259 int ret = RUN_ALL_TESTS();
260 return ret;
261 }
262