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