test/core/end2end/tests/compressed_payload.cc

   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
  39 static void* tag(intptr_t t) { return (void*)t; }
  40
  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
  53 static gpr_timespec n_seconds_from_now(int n) {
  54   return grpc_timeout_seconds_to_deadline(n);
  55 }
  56
  57 static gpr_timespec five_seconds_from_now(void) {
  58   return n_seconds_from_now(5);
  59 }
  60
  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
  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
  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
  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
  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_compression_algorithm(
 128       nullptr, requested_client_compression_algorithm);
 129   server_args =
 130       grpc_channel_args_set_compression_algorithm(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
 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_algorithm_from_client,
 273     grpc_compression_algorithm expected_algorithm_from_server,
 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   grpc_call* c;
 278   grpc_call* s;
 279   grpc_slice request_payload_slice;
 280   grpc_byte_buffer* request_payload = nullptr;
 281   grpc_channel_args* client_args;
 282   grpc_channel_args* server_args;
 283   grpc_end2end_test_fixture f;
 284   grpc_op ops[6];
 285   grpc_op* op;
 286   grpc_metadata_array initial_metadata_recv;
 287   grpc_metadata_array trailing_metadata_recv;
 288   grpc_metadata_array request_metadata_recv;
 289   grpc_byte_buffer* request_payload_recv = nullptr;
 290   grpc_byte_buffer* response_payload;
 291   grpc_byte_buffer* response_payload_recv;
 292   grpc_call_details call_details;
 293   grpc_status_code status;
 294   grpc_call_error error;
 295   grpc_slice details;
 296   int was_cancelled = 2;
 297   cq_verifier* cqv;
 298   char request_str[1024];
 299   char response_str[1024];
 300
 301   memset(request_str, 'x', 1023);
 302   request_str[1023] = '\0';
 303
 304   memset(response_str, 'y', 1023);
 305   response_str[1023] = '\0';
 306
 307   request_payload_slice = grpc_slice_from_copied_string(request_str);
 308   grpc_slice response_payload_slice =
 309       grpc_slice_from_copied_string(response_str);
 310
 311   client_args = grpc_channel_args_set_compression_algorithm(
 312       nullptr, default_client_channel_compression_algorithm);
 313   server_args = grpc_channel_args_set_compression_algorithm(
 314       nullptr, default_server_channel_compression_algorithm);
 315
 316   f = begin_test(config, test_name, client_args, server_args);
 317   cqv = cq_verifier_create(f.cq);
 318
 319   gpr_timespec deadline = five_seconds_from_now();
 320   c = grpc_channel_create_call(f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
 321                                grpc_slice_from_static_string("/foo"), nullptr,
 322                                deadline, nullptr);
 323   GPR_ASSERT(c);
 324
 325   grpc_metadata_array_init(&initial_metadata_recv);
 326   grpc_metadata_array_init(&trailing_metadata_recv);
 327   grpc_metadata_array_init(&request_metadata_recv);
 328   grpc_call_details_init(&call_details);
 329
 330   if (send_message_before_initial_metadata) {
 331     request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1);
 332     memset(ops, 0, sizeof(ops));
 333     op = ops;
 334     op->op = GRPC_OP_SEND_MESSAGE;
 335     op->data.send_message.send_message = request_payload;
 336     op->flags = client_send_flags_bitmask;
 337     op->reserved = nullptr;
 338     op++;
 339     error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(2),
 340                                   nullptr);
 341     GPR_ASSERT(GRPC_CALL_OK == error);
 342     CQ_EXPECT_COMPLETION(cqv, tag(2), true);
 343   }
 344
 345   memset(ops, 0, sizeof(ops));
 346   op = ops;
 347   op->op = GRPC_OP_SEND_INITIAL_METADATA;
 348   if (client_init_metadata != nullptr) {
 349     op->data.send_initial_metadata.count = 1;
 350     op->data.send_initial_metadata.metadata = client_init_metadata;
 351   } else {
 352     op->data.send_initial_metadata.count = 0;
 353   }
 354   op->flags = 0;
 355   op->reserved = nullptr;
 356   op++;
 357   op->op = GRPC_OP_RECV_INITIAL_METADATA;
 358   op->data.recv_initial_metadata.recv_initial_metadata = &initial_metadata_recv;
 359   op->flags = 0;
 360   op->reserved = nullptr;
 361   op++;
 362   op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
 363   op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
 364   op->data.recv_status_on_client.status = &status;
 365   op->data.recv_status_on_client.status_details = &details;
 366   op->flags = 0;
 367   op->reserved = nullptr;
 368   op++;
 369   error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(1),
 370                                 nullptr);
 371   GPR_ASSERT(GRPC_CALL_OK == error);
 372
 373   error =
 374       grpc_server_request_call(f.server, &s, &call_details,
 375                                &request_metadata_recv, f.cq, f.cq, tag(100));
 376   GPR_ASSERT(GRPC_CALL_OK == error);
 377   CQ_EXPECT_COMPLETION(cqv, tag(100), true);
 378   cq_verify(cqv);
 379
 380   GPR_ASSERT(GPR_BITCOUNT(grpc_call_test_only_get_encodings_accepted_by_peer(
 381                  s)) == GRPC_COMPRESS_ALGORITHMS_COUNT);
 382   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
 383                         GRPC_COMPRESS_NONE) != 0);
 384   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
 385                         GRPC_COMPRESS_DEFLATE) != 0);
 386   GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
 387                         GRPC_COMPRESS_GZIP) != 0);
 388
 389   memset(ops, 0, sizeof(ops));
 390   op = ops;
 391   op->op = GRPC_OP_SEND_INITIAL_METADATA;
 392   op->data.send_initial_metadata.count = 0;
 393   if (set_server_level) {
 394     op->data.send_initial_metadata.maybe_compression_level.is_set = true;
 395     op->data.send_initial_metadata.maybe_compression_level.level =
 396         server_compression_level;
 397   }
 398   op->flags = 0;
 399   op->reserved = nullptr;
 400   op++;
 401   op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
 402   op->data.recv_close_on_server.cancelled = &was_cancelled;
 403   op->flags = 0;
 404   op->reserved = nullptr;
 405   op++;
 406   error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops), tag(101),
 407                                 nullptr);
 408   GPR_ASSERT(GRPC_CALL_OK == error);
 409
 410   for (int i = 0; i < 2; i++) {
 411     response_payload = grpc_raw_byte_buffer_create(&response_payload_slice, 1);
 412
 413     if (i > 0 || !send_message_before_initial_metadata) {
 414       request_payload = grpc_raw_byte_buffer_create(&request_payload_slice, 1);
 415       memset(ops, 0, sizeof(ops));
 416       op = ops;
 417       op->op = GRPC_OP_SEND_MESSAGE;
 418       op->data.send_message.send_message = request_payload;
 419       op->flags = client_send_flags_bitmask;
 420       op->reserved = nullptr;
 421       op++;
 422       error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops),
 423                                     tag(2), nullptr);
 424       GPR_ASSERT(GRPC_CALL_OK == error);
 425       CQ_EXPECT_COMPLETION(cqv, tag(2), 1);
 426     }
 427
 428     memset(ops, 0, sizeof(ops));
 429     op = ops;
 430     op->op = GRPC_OP_RECV_MESSAGE;
 431     op->data.recv_message.recv_message = &request_payload_recv;
 432     op->flags = 0;
 433     op->reserved = nullptr;
 434     op++;
 435     error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops),
 436                                   tag(102), nullptr);
 437     GPR_ASSERT(GRPC_CALL_OK == error);
 438
 439     CQ_EXPECT_COMPLETION(cqv, tag(102), 1);
 440     cq_verify(cqv);
 441
 442     GPR_ASSERT(request_payload_recv->type == GRPC_BB_RAW);
 443     GPR_ASSERT(byte_buffer_eq_string(request_payload_recv, request_str));
 444     GPR_ASSERT(request_payload_recv->data.raw.compression ==
 445                expected_algorithm_from_client);
 446
 447     memset(ops, 0, sizeof(ops));
 448     op = ops;
 449     op->op = GRPC_OP_SEND_MESSAGE;
 450     op->data.send_message.send_message = response_payload;
 451     op->flags = 0;
 452     op->reserved = nullptr;
 453     op++;
 454     error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops),
 455                                   tag(103), nullptr);
 456     GPR_ASSERT(GRPC_CALL_OK == error);
 457
 458     memset(ops, 0, sizeof(ops));
 459     op = ops;
 460     op->op = GRPC_OP_RECV_MESSAGE;
 461     op->data.recv_message.recv_message = &response_payload_recv;
 462     op->flags = 0;
 463     op->reserved = nullptr;
 464     op++;
 465     error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(3),
 466                                   nullptr);
 467     GPR_ASSERT(GRPC_CALL_OK == error);
 468
 469     CQ_EXPECT_COMPLETION(cqv, tag(103), 1);
 470     CQ_EXPECT_COMPLETION(cqv, tag(3), 1);
 471     cq_verify(cqv);
 472
 473     GPR_ASSERT(response_payload_recv->type == GRPC_BB_RAW);
 474     GPR_ASSERT(byte_buffer_eq_string(response_payload_recv, response_str));
 475     if (server_compression_level > GRPC_COMPRESS_LEVEL_NONE) {
 476       const grpc_compression_algorithm algo_for_server_level =
 477           grpc_call_compression_for_level(s, server_compression_level);
 478       GPR_ASSERT(response_payload_recv->data.raw.compression ==
 479                  algo_for_server_level);
 480     } else {
 481       GPR_ASSERT(response_payload_recv->data.raw.compression ==
 482                  expected_algorithm_from_server);
 483     }
 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
 550 static void test_invoke_request_with_exceptionally_uncompressed_payload(
 551     grpc_end2end_test_config config) {
 552   request_with_payload_template(
 553       config, "test_invoke_request_with_exceptionally_uncompressed_payload",
 554       GRPC_WRITE_NO_COMPRESS, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
 555       GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, nullptr, false,
 556       /* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
 557 }
 558
 559 static void test_invoke_request_with_uncompressed_payload(
 560     grpc_end2end_test_config config) {
 561   request_with_payload_template(
 562       config, "test_invoke_request_with_uncompressed_payload", 0,
 563       GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
 564       GRPC_COMPRESS_NONE, nullptr, false,
 565       /* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
 566 }
 567
 568 static void test_invoke_request_with_compressed_payload(
 569     grpc_end2end_test_config config) {
 570   request_with_payload_template(
 571       config, "test_invoke_request_with_compressed_payload", 0,
 572       GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
 573       GRPC_COMPRESS_GZIP, nullptr, false,
 574       /* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
 575 }
 576
 577 static void test_invoke_request_with_send_message_before_initial_metadata(
 578     grpc_end2end_test_config config) {
 579   request_with_payload_template(
 580       config, "test_invoke_request_with_compressed_payload", 0,
 581       GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
 582       GRPC_COMPRESS_GZIP, nullptr, false,
 583       /* ignored */ GRPC_COMPRESS_LEVEL_NONE, true);
 584 }
 585
 586 static void test_invoke_request_with_server_level(
 587     grpc_end2end_test_config config) {
 588   request_with_payload_template(
 589       config, "test_invoke_request_with_server_level", 0, GRPC_COMPRESS_NONE,
 590       GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE /* ignored */,
 591       nullptr, true, GRPC_COMPRESS_LEVEL_HIGH, false);
 592 }
 593
 594 static void test_invoke_request_with_compressed_payload_md_override(
 595     grpc_end2end_test_config config) {
 596   grpc_metadata gzip_compression_override;
 597   grpc_metadata identity_compression_override;
 598
 599   gzip_compression_override.key = GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST;
 600   gzip_compression_override.value = grpc_slice_from_static_string("gzip");
 601   memset(&gzip_compression_override.internal_data, 0,
 602          sizeof(gzip_compression_override.internal_data));
 603
 604   identity_compression_override.key = GRPC_MDSTR_GRPC_INTERNAL_ENCODING_REQUEST;
 605   identity_compression_override.value =
 606       grpc_slice_from_static_string("identity");
 607   memset(&identity_compression_override.internal_data, 0,
 608          sizeof(identity_compression_override.internal_data));
 609
 610   /* Channel default NONE (aka IDENTITY), call override to GZIP */
 611   request_with_payload_template(
 612       config, "test_invoke_request_with_compressed_payload_md_override_1", 0,
 613       GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP,
 614       GRPC_COMPRESS_NONE, &gzip_compression_override, false,
 615       /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false);
 616
 617   /* Channel default DEFLATE, call override to GZIP */
 618   request_with_payload_template(
 619       config, "test_invoke_request_with_compressed_payload_md_override_2", 0,
 620       GRPC_COMPRESS_DEFLATE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP,
 621       GRPC_COMPRESS_NONE, &gzip_compression_override, false,
 622       /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false);
 623
 624   /* Channel default DEFLATE, call override to NONE (aka IDENTITY) */
 625   request_with_payload_template(
 626       config, "test_invoke_request_with_compressed_payload_md_override_3", 0,
 627       GRPC_COMPRESS_DEFLATE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
 628       GRPC_COMPRESS_NONE, &identity_compression_override, false,
 629       /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false);
 630 }
 631
 632 static void test_invoke_request_with_disabled_algorithm(
 633     grpc_end2end_test_config config) {
 634   request_for_disabled_algorithm(config,
 635                                  "test_invoke_request_with_disabled_algorithm",
 636                                  0, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
 637                                  GRPC_STATUS_UNIMPLEMENTED, nullptr);
 638 }
 639
 640 void compressed_payload(grpc_end2end_test_config config) {
 641   test_invoke_request_with_exceptionally_uncompressed_payload(config);
 642   test_invoke_request_with_uncompressed_payload(config);
 643   test_invoke_request_with_compressed_payload(config);
 644   test_invoke_request_with_send_message_before_initial_metadata(config);
 645   test_invoke_request_with_server_level(config);
 646   test_invoke_request_with_compressed_payload_md_override(config);
 647   test_invoke_request_with_disabled_algorithm(config);
 648 }
 649
 650 void compressed_payload_pre_init(void) {}