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 "test/core/end2end/end2end_tests.h"
20 
21 #include <stdio.h>
22 #include <string.h>
23 
24 #include <grpc/byte_buffer.h>
25 #include <grpc/byte_buffer_reader.h>
26 #include <grpc/compression.h>
27 #include <grpc/support/alloc.h>
28 #include <grpc/support/log.h>
29 #include <grpc/support/string_util.h>
30 #include <grpc/support/time.h>
31 
32 #include "src/core/lib/channel/channel_args.h"
33 #include "src/core/lib/compression/compression_args.h"
34 #include "src/core/lib/surface/call.h"
35 #include "src/core/lib/surface/call_test_only.h"
36 #include "src/core/lib/transport/static_metadata.h"
37 #include "test/core/end2end/cq_verifier.h"
38 
tag(intptr_t t)39 static void* tag(intptr_t t) { return (void*)t; }
40 
begin_test(grpc_end2end_test_config config,const char * test_name,grpc_channel_args * client_args,grpc_channel_args * server_args)41 static grpc_end2end_test_fixture begin_test(grpc_end2end_test_config config,
42                                             const char* test_name,
43                                             grpc_channel_args* client_args,
44                                             grpc_channel_args* server_args) {
45   grpc_end2end_test_fixture f;
46   gpr_log(GPR_INFO, "Running test: %s/%s", test_name, config.name);
47   f = config.create_fixture(client_args, server_args);
48   config.init_server(&f, server_args);
49   config.init_client(&f, client_args);
50   return f;
51 }
52 
n_seconds_from_now(int n)53 static gpr_timespec n_seconds_from_now(int n) {
54   return grpc_timeout_seconds_to_deadline(n);
55 }
56 
five_seconds_from_now(void)57 static gpr_timespec five_seconds_from_now(void) {
58   return n_seconds_from_now(5);
59 }
60 
drain_cq(grpc_completion_queue * cq)61 static void drain_cq(grpc_completion_queue* cq) {
62   grpc_event ev;
63   do {
64     ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
65   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
66 }
67 
shutdown_server(grpc_end2end_test_fixture * f)68 static void shutdown_server(grpc_end2end_test_fixture* f) {
69   if (!f->server) return;
70   grpc_server_shutdown_and_notify(f->server, f->shutdown_cq, tag(1000));
71   GPR_ASSERT(grpc_completion_queue_pluck(f->shutdown_cq, tag(1000),
72                                          grpc_timeout_seconds_to_deadline(5),
73                                          nullptr)
74                  .type == GRPC_OP_COMPLETE);
75   grpc_server_destroy(f->server);
76   f->server = nullptr;
77 }
78 
shutdown_client(grpc_end2end_test_fixture * f)79 static void shutdown_client(grpc_end2end_test_fixture* f) {
80   if (!f->client) return;
81   grpc_channel_destroy(f->client);
82   f->client = nullptr;
83 }
84 
end_test(grpc_end2end_test_fixture * f)85 static void end_test(grpc_end2end_test_fixture* f) {
86   shutdown_server(f);
87   shutdown_client(f);
88 
89   grpc_completion_queue_shutdown(f->cq);
90   drain_cq(f->cq);
91   grpc_completion_queue_destroy(f->cq);
92   grpc_completion_queue_destroy(f->shutdown_cq);
93 }
94 
request_for_disabled_algorithm(grpc_end2end_test_config config,const char * test_name,uint32_t send_flags_bitmask,grpc_compression_algorithm algorithm_to_disable,grpc_compression_algorithm requested_client_compression_algorithm,grpc_status_code expected_error,grpc_metadata * client_metadata)95 static void request_for_disabled_algorithm(
96     grpc_end2end_test_config config, const char* test_name,
97     uint32_t send_flags_bitmask,
98     grpc_compression_algorithm algorithm_to_disable,
99     grpc_compression_algorithm requested_client_compression_algorithm,
100     grpc_status_code expected_error, grpc_metadata* client_metadata) {
101   grpc_call* c;
102   grpc_call* s;
103   grpc_slice request_payload_slice;
104   grpc_byte_buffer* request_payload;
105   grpc_channel_args* client_args;
106   grpc_channel_args* server_args;
107   grpc_end2end_test_fixture f;
108   grpc_op ops[6];
109   grpc_op* op;
110   grpc_metadata_array initial_metadata_recv;
111   grpc_metadata_array trailing_metadata_recv;
112   grpc_metadata_array request_metadata_recv;
113   grpc_byte_buffer* request_payload_recv = nullptr;
114   grpc_call_details call_details;
115   grpc_status_code status;
116   grpc_call_error error;
117   grpc_slice details;
118   int was_cancelled = 2;
119   cq_verifier* cqv;
120   char str[1024];
121 
122   memset(str, 'x', 1023);
123   str[1023] = '\0';
124   request_payload_slice = grpc_slice_from_copied_string(str);
125   request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1);
126 
127   client_args = grpc_channel_args_set_channel_default_compression_algorithm(
128       nullptr, requested_client_compression_algorithm);
129   server_args = grpc_channel_args_set_channel_default_compression_algorithm(
130       nullptr, GRPC_COMPRESS_NONE);
131   {
132     grpc_core::ExecCtx exec_ctx;
133     server_args = grpc_channel_args_compression_algorithm_set_state(
134         &server_args, algorithm_to_disable, false);
135   }
136 
137   f = begin_test(config, test_name, client_args, server_args);
138   cqv = cq_verifier_create(f.cq);
139 
140   gpr_timespec deadline = five_seconds_from_now();
141   c = grpc_channel_create_call(f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
142                                grpc_slice_from_static_string("/foo"), nullptr,
143                                deadline, nullptr);
144   GPR_ASSERT(c);
145 
146   grpc_metadata_array_init(&initial_metadata_recv);
147   grpc_metadata_array_init(&trailing_metadata_recv);
148   grpc_metadata_array_init(&request_metadata_recv);
149   grpc_call_details_init(&call_details);
150 
151   error =
152       grpc_server_request_call(f.server, &s, &call_details,
153                                &request_metadata_recv, f.cq, f.cq, tag(101));
154   GPR_ASSERT(GRPC_CALL_OK == error);
155 
156   memset(ops, 0, sizeof(ops));
157   op = ops;
158   op->op = GRPC_OP_SEND_INITIAL_METADATA;
159   if (client_metadata != nullptr) {
160     op->data.send_initial_metadata.count = 1;
161     op->data.send_initial_metadata.metadata = client_metadata;
162   } else {
163     op->data.send_initial_metadata.count = 0;
164   }
165   op->flags = 0;
166   op->reserved = nullptr;
167   op++;
168   op->op = GRPC_OP_SEND_MESSAGE;
169   op->data.send_message.send_message = request_payload;
170   op->flags = send_flags_bitmask;
171   op->reserved = nullptr;
172   op++;
173   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
174   op->flags = 0;
175   op->reserved = nullptr;
176   op++;
177   op->op = GRPC_OP_RECV_INITIAL_METADATA;
178   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
179   op->flags = 0;
180   op->reserved = nullptr;
181   op++;
182   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
183   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
184   op->data.recv_status_on_client.status = &status;
185   op->data.recv_status_on_client.status_details = &details;
186   op->flags = 0;
187   op->reserved = nullptr;
188   op++;
189   error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(1),
190                                 nullptr);
191   GPR_ASSERT(GRPC_CALL_OK == error);
192 
193   CQ_EXPECT_COMPLETION(cqv, tag(101), true);
194   CQ_EXPECT_COMPLETION(cqv, tag(1), true);
195   cq_verify(cqv);
196 
197   op = ops;
198   op->op = GRPC_OP_SEND_INITIAL_METADATA;
199   op->data.send_initial_metadata.count = 0;
200   op->flags = 0;
201   op->reserved = nullptr;
202   op++;
203   op->op = GRPC_OP_RECV_MESSAGE;
204   op->data.recv_message.recv_message = &request_payload_recv;
205   op->flags = 0;
206   op->reserved = nullptr;
207   op++;
208   error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops), tag(102),
209                                 nullptr);
210   GPR_ASSERT(GRPC_CALL_OK == error);
211 
212   CQ_EXPECT_COMPLETION(cqv, tag(102), false);
213 
214   op = ops;
215   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
216   op->data.recv_close_on_server.cancelled = &was_cancelled;
217   op->flags = 0;
218   op->reserved = nullptr;
219   op++;
220   error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops), tag(103),
221                                 nullptr);
222   GPR_ASSERT(GRPC_CALL_OK == error);
223 
224   CQ_EXPECT_COMPLETION(cqv, tag(103), true);
225   cq_verify(cqv);
226 
227   /* call was cancelled (closed) ... */
228   GPR_ASSERT(was_cancelled != 0);
229   /* with a certain error */
230   GPR_ASSERT(status == expected_error);
231 
232   const char* algo_name = nullptr;
233   GPR_ASSERT(grpc_compression_algorithm_name(algorithm_to_disable, &algo_name));
234   char* expected_details = nullptr;
235   gpr_asprintf(&expected_details, "Compression algorithm '%s' is disabled.",
236                algo_name);
237   /* and we expect a specific reason for it */
238   GPR_ASSERT(0 == grpc_slice_str_cmp(details, expected_details));
239   gpr_free(expected_details);
240   GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.method, "/foo"));
241 
242   grpc_slice_unref(details);
243   grpc_metadata_array_destroy(&initial_metadata_recv);
244   grpc_metadata_array_destroy(&trailing_metadata_recv);
245   grpc_metadata_array_destroy(&request_metadata_recv);
246   grpc_call_details_destroy(&call_details);
247 
248   grpc_call_unref(c);
249   grpc_call_unref(s);
250 
251   cq_verifier_destroy(cqv);
252 
253   grpc_slice_unref(request_payload_slice);
254   grpc_byte_buffer_destroy(request_payload);
255   grpc_byte_buffer_destroy(request_payload_recv);
256 
257   {
258     grpc_core::ExecCtx exec_ctx;
259     grpc_channel_args_destroy(client_args);
260     grpc_channel_args_destroy(server_args);
261   }
262 
263   end_test(&f);
264   config.tear_down_data(&f);
265 }
266 
request_with_payload_template(grpc_end2end_test_config config,const char * test_name,uint32_t client_send_flags_bitmask,grpc_compression_algorithm default_client_channel_compression_algorithm,grpc_compression_algorithm default_server_channel_compression_algorithm,grpc_compression_algorithm,grpc_compression_algorithm,grpc_metadata * client_init_metadata,bool set_server_level,grpc_compression_level server_compression_level,bool send_message_before_initial_metadata,bool set_default_server_message_compression_algorithm,grpc_compression_algorithm default_server_message_compression_algorithm)267 static void request_with_payload_template(
268     grpc_end2end_test_config config, const char* test_name,
269     uint32_t client_send_flags_bitmask,
270     grpc_compression_algorithm default_client_channel_compression_algorithm,
271     grpc_compression_algorithm default_server_channel_compression_algorithm,
272     grpc_compression_algorithm /*expected_client_compression_algorithm*/,
273     grpc_compression_algorithm /*expected_server_compression_algorithm*/,
274     grpc_metadata* client_init_metadata, bool set_server_level,
275     grpc_compression_level server_compression_level,
276     bool send_message_before_initial_metadata,
277     bool set_default_server_message_compression_algorithm,
278     grpc_compression_algorithm default_server_message_compression_algorithm) {
279   grpc_call* c;
280   grpc_call* s;
281   grpc_slice request_payload_slice;
282   grpc_byte_buffer* request_payload = nullptr;
283   grpc_channel_args* client_args;
284   grpc_channel_args* server_args;
285   grpc_end2end_test_fixture f;
286   grpc_op ops[6];
287   grpc_op* op;
288   grpc_metadata_array initial_metadata_recv;
289   grpc_metadata_array trailing_metadata_recv;
290   grpc_metadata_array request_metadata_recv;
291   grpc_byte_buffer* request_payload_recv = nullptr;
292   grpc_byte_buffer* response_payload;
293   grpc_byte_buffer* response_payload_recv;
294   grpc_call_details call_details;
295   grpc_status_code status;
296   grpc_call_error error;
297   grpc_slice details;
298   int was_cancelled = 2;
299   cq_verifier* cqv;
300   char request_str[1024];
301   char response_str[1024];
302 
303   memset(request_str, 'x', 1023);
304   request_str[1023] = '\0';
305 
306   memset(response_str, 'y', 1023);
307   response_str[1023] = '\0';
308 
309   request_payload_slice = grpc_slice_from_copied_string(request_str);
310   grpc_slice response_payload_slice =
311       grpc_slice_from_copied_string(response_str);
312 
313   client_args = grpc_channel_args_set_channel_default_compression_algorithm(
314       nullptr, default_client_channel_compression_algorithm);
315   if (set_default_server_message_compression_algorithm) {
316     server_args = grpc_channel_args_set_channel_default_compression_algorithm(
317         nullptr, default_server_message_compression_algorithm);
318   } else {
319     server_args = grpc_channel_args_set_channel_default_compression_algorithm(
320         nullptr, default_server_channel_compression_algorithm);
321   }
322 
323   f = begin_test(config, test_name, client_args, server_args);
324   cqv = cq_verifier_create(f.cq);
325 
326   gpr_timespec deadline = five_seconds_from_now();
327   c = grpc_channel_create_call(f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
328                                grpc_slice_from_static_string("/foo"), nullptr,
329                                deadline, nullptr);
330   GPR_ASSERT(c);
331 
332   grpc_metadata_array_init(&initial_metadata_recv);
333   grpc_metadata_array_init(&trailing_metadata_recv);
334   grpc_metadata_array_init(&request_metadata_recv);
335   grpc_call_details_init(&call_details);
336 
337   if (send_message_before_initial_metadata) {
338     request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1);
339     memset(ops, 0, sizeof(ops));
340     op = ops;
341     op->op = GRPC_OP_SEND_MESSAGE;
342     op->data.send_message.send_message = request_payload;
343     op->flags = client_send_flags_bitmask;
344     op->reserved = nullptr;
345     op++;
346     error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(2),
347                                   nullptr);
348     GPR_ASSERT(GRPC_CALL_OK == error);
349     CQ_EXPECT_COMPLETION(cqv, tag(2), true);
350   }
351 
352   memset(ops, 0, sizeof(ops));
353   op = ops;
354   op->op = GRPC_OP_SEND_INITIAL_METADATA;
355   if (client_init_metadata != nullptr) {
356     op->data.send_initial_metadata.count = 1;
357     op->data.send_initial_metadata.metadata = client_init_metadata;
358   } else {
359     op->data.send_initial_metadata.count = 0;
360   }
361   op->flags = 0;
362   op->reserved = nullptr;
363   op++;
364   op->op = GRPC_OP_RECV_INITIAL_METADATA;
365   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
366   op->flags = 0;
367   op->reserved = nullptr;
368   op++;
369   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
370   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
371   op->data.recv_status_on_client.status = &status;
372   op->data.recv_status_on_client.status_details = &details;
373   op->flags = 0;
374   op->reserved = nullptr;
375   op++;
376   error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(1),
377                                 nullptr);
378   GPR_ASSERT(GRPC_CALL_OK == error);
379 
380   error =
381       grpc_server_request_call(f.server, &s, &call_details,
382                                &request_metadata_recv, f.cq, f.cq, tag(100));
383   GPR_ASSERT(GRPC_CALL_OK == error);
384   CQ_EXPECT_COMPLETION(cqv, tag(100), true);
385   cq_verify(cqv);
386 
387   GPR_ASSERT(GPR_BITCOUNT(grpc_call_test_only_get_encodings_accepted_by_peer(
388                  s)) == GRPC_COMPRESS_ALGORITHMS_COUNT);
389   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
390                         GRPC_COMPRESS_NONE) != 0);
391   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
392                         GRPC_COMPRESS_DEFLATE) != 0);
393   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
394                         GRPC_COMPRESS_GZIP) != 0);
395   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
396                         GRPC_COMPRESS_STREAM_GZIP) != 0);
397   GPR_ASSERT(GPR_BITCOUNT(grpc_call_test_only_get_encodings_accepted_by_peer(
398                  s)) == GRPC_COMPRESS_ALGORITHMS_COUNT);
399 
400   memset(ops, 0, sizeof(ops));
401   op = ops;
402   op->op = GRPC_OP_SEND_INITIAL_METADATA;
403   op->data.send_initial_metadata.count = 0;
404   if (set_server_level) {
405     op->data.send_initial_metadata.maybe_compression_level.is_set = true;
406     op->data.send_initial_metadata.maybe_compression_level.level =
407         server_compression_level;
408   }
409   op->flags = 0;
410   op->reserved = nullptr;
411   op++;
412   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
413   op->data.recv_close_on_server.cancelled = &was_cancelled;
414   op->flags = 0;
415   op->reserved = nullptr;
416   op++;
417   error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops), tag(101),
418                                 nullptr);
419   GPR_ASSERT(GRPC_CALL_OK == error);
420 
421   for (int i = 0; i < 2; i++) {
422     response_payload = grpc_raw_byte_buffer_create(&response_payload_slice, 1);
423 
424     if (i > 0 || !send_message_before_initial_metadata) {
425       request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1);
426       memset(ops, 0, sizeof(ops));
427       op = ops;
428       op->op = GRPC_OP_SEND_MESSAGE;
429       op->data.send_message.send_message = request_payload;
430       op->flags = client_send_flags_bitmask;
431       op->reserved = nullptr;
432       op++;
433       error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops),
434                                     tag(2), nullptr);
435       GPR_ASSERT(GRPC_CALL_OK == error);
436       CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
437     }
438 
439     memset(ops, 0, sizeof(ops));
440     op = ops;
441     op->op = GRPC_OP_RECV_MESSAGE;
442     op->data.recv_message.recv_message = &request_payload_recv;
443     op->flags = 0;
444     op->reserved = nullptr;
445     op++;
446     error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops),
447                                   tag(102), nullptr);
448     GPR_ASSERT(GRPC_CALL_OK == error);
449 
450     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
451     cq_verify(cqv);
452 
453     GPR_ASSERT(request_payload_recv->type == GRPC_BB_RAW);
454     GPR_ASSERT(byte_buffer_eq_string(request_payload_recv, request_str));
455 
456     memset(ops, 0, sizeof(ops));
457     op = ops;
458     op->op = GRPC_OP_SEND_MESSAGE;
459     op->data.send_message.send_message = response_payload;
460     op->flags = 0;
461     op->reserved = nullptr;
462     op++;
463     error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops),
464                                   tag(103), nullptr);
465     GPR_ASSERT(GRPC_CALL_OK == error);
466 
467     memset(ops, 0, sizeof(ops));
468     op = ops;
469     op->op = GRPC_OP_RECV_MESSAGE;
470     op->data.recv_message.recv_message = &response_payload_recv;
471     op->flags = 0;
472     op->reserved = nullptr;
473     op++;
474     error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(3),
475                                   nullptr);
476     GPR_ASSERT(GRPC_CALL_OK == error);
477 
478     CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
479     CQ_EXPECT_COMPLETION(cqv, tag(3), 1);
480     cq_verify(cqv);
481 
482     GPR_ASSERT(response_payload_recv->type == GRPC_BB_RAW);
483     GPR_ASSERT(byte_buffer_eq_string(response_payload_recv, response_str));
484 
485     grpc_byte_buffer_destroy(request_payload);
486     grpc_byte_buffer_destroy(response_payload);
487     grpc_byte_buffer_destroy(request_payload_recv);
488     grpc_byte_buffer_destroy(response_payload_recv);
489   }
490 
491   grpc_slice_unref(request_payload_slice);
492   grpc_slice_unref(response_payload_slice);
493 
494   memset(ops, 0, sizeof(ops));
495   op = ops;
496   op->op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
497   op->flags = 0;
498   op->reserved = nullptr;
499   op++;
500   error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(4),
501                                 nullptr);
502   GPR_ASSERT(GRPC_CALL_OK == error);
503 
504   memset(ops, 0, sizeof(ops));
505   op = ops;
506   op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
507   op->data.send_status_from_server.trailing_metadata_count = 0;
508   op->data.send_status_from_server.status = GRPC_STATUS_OK;
509   grpc_slice status_details = grpc_slice_from_static_string("xyz");
510   op->data.send_status_from_server.status_details = &status_details;
511   op->flags = 0;
512   op->reserved = nullptr;
513   op++;
514   error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops), tag(104),
515                                 nullptr);
516   GPR_ASSERT(GRPC_CALL_OK == error);
517 
518   CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
519   CQ_EXPECT_COMPLETION(cqv, tag(4), 1);
520   CQ_EXPECT_COMPLETION(cqv, tag(101), 1);
521   CQ_EXPECT_COMPLETION(cqv, tag(104), 1);
522   cq_verify(cqv);
523 
524   GPR_ASSERT(status == GRPC_STATUS_OK);
525   GPR_ASSERT(0 == grpc_slice_str_cmp(details, "xyz"));
526   GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.method, "/foo"));
527   GPR_ASSERT(was_cancelled == 0);
528 
529   grpc_slice_unref(details);
530   grpc_metadata_array_destroy(&initial_metadata_recv);
531   grpc_metadata_array_destroy(&trailing_metadata_recv);
532   grpc_metadata_array_destroy(&request_metadata_recv);
533   grpc_call_details_destroy(&call_details);
534 
535   grpc_call_unref(c);
536   grpc_call_unref(s);
537 
538   cq_verifier_destroy(cqv);
539 
540   {
541     grpc_core::ExecCtx exec_ctx;
542     grpc_channel_args_destroy(client_args);
543     grpc_channel_args_destroy(server_args);
544   }
545 
546   end_test(&f);
547   config.tear_down_data(&f);
548 }
549 
test_invoke_request_with_compressed_payload(grpc_end2end_test_config config)550 static void test_invoke_request_with_compressed_payload(
551     grpc_end2end_test_config config) {
552   request_with_payload_template(
553       config, "test_invoke_request_with_compressed_payload", 0,
554       GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP,
555       GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP, nullptr,
556       false, /* ignored */
557       GRPC_COMPRESS_LEVEL_NONE, false, false, GRPC_COMPRESS_NONE);
558 }
559 
test_invoke_request_with_send_message_before_initial_metadata(grpc_end2end_test_config config)560 static void test_invoke_request_with_send_message_before_initial_metadata(
561     grpc_end2end_test_config config) {
562   request_with_payload_template(
563       config, "test_invoke_request_with_send_message_before_initial_metadata",
564       0, GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP,
565       GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP, nullptr,
566       false, /* ignored */
567       GRPC_COMPRESS_LEVEL_NONE, true, false, GRPC_COMPRESS_NONE);
568 }
569 
test_invoke_request_with_compressed_payload_md_override(grpc_end2end_test_config config)570 static void test_invoke_request_with_compressed_payload_md_override(
571     grpc_end2end_test_config config) {
572   grpc_metadata gzip_compression_override;
573   grpc_metadata identity_compression_override;
574 
575   gzip_compression_override.key =
576       GRPC_MDSTR_GRPC_INTERNAL_STREAM_ENCODING_REQUEST;
577   gzip_compression_override.value =
578       grpc_slice_from_static_string("stream/gzip");
579   memset(&gzip_compression_override.internal_data, 0,
580          sizeof(gzip_compression_override.internal_data));
581 
582   identity_compression_override.key =
583       GRPC_MDSTR_GRPC_INTERNAL_STREAM_ENCODING_REQUEST;
584   identity_compression_override.value =
585       grpc_slice_from_static_string("identity");
586   memset(&identity_compression_override.internal_data, 0,
587          sizeof(identity_compression_override.internal_data));
588 
589   /* Channel default NONE (aka IDENTITY), call override to stream GZIP */
590   request_with_payload_template(
591       config, "test_invoke_request_with_compressed_payload_md_override_1", 0,
592       GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_STREAM_GZIP,
593       GRPC_COMPRESS_NONE, &gzip_compression_override, false,
594       /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false, false, GRPC_COMPRESS_NONE);
595 
596   /* Channel default stream GZIP, call override to NONE (aka IDENTITY) */
597   request_with_payload_template(
598       config, "test_invoke_request_with_compressed_payload_md_override_3", 0,
599       GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
600       GRPC_COMPRESS_NONE, &identity_compression_override, false,
601       /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false, false, GRPC_COMPRESS_NONE);
602 }
603 
test_invoke_request_with_disabled_algorithm(grpc_end2end_test_config config)604 static void test_invoke_request_with_disabled_algorithm(
605     grpc_end2end_test_config config) {
606   request_for_disabled_algorithm(
607       config, "test_invoke_request_with_disabled_algorithm", 0,
608       GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP,
609       GRPC_STATUS_UNIMPLEMENTED, nullptr);
610 }
611 
stream_compression_compressed_payload(grpc_end2end_test_config config)612 void stream_compression_compressed_payload(grpc_end2end_test_config config) {
613   test_invoke_request_with_compressed_payload(config);
614   test_invoke_request_with_send_message_before_initial_metadata(config);
615   test_invoke_request_with_compressed_payload_md_override(config);
616   test_invoke_request_with_disabled_algorithm(config);
617 }
618 
stream_compression_compressed_payload_pre_init(void)619 void stream_compression_compressed_payload_pre_init(void) {}
620