Chiebot-Mirror
/
grpc
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Replace GRPC_COMPRESS_MESSAGE_* with GRPC_COMPRESS_*

Browse Source
pull/14343/head
Muxi Yan 7 years ago
parent 3629f1f3bc
commit 6f0b195d20
19 changed files with 91 additions and 95 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      include/grpc/impl/codegen/compression_types.h
  2. 23
      src/core/lib/compression/compression.cc
  3. 8
      src/core/lib/compression/compression_internal.cc
  4. 8
      src/core/lib/compression/compression_ruby.cc
  5. 4
      src/objective-c/GRPCClient/GRPCCall+ChannelArg.m
  6. 4
      src/python/grpcio/grpc/_cython/_cygrpc/grpc.pxi
  7. 4
      src/python/grpcio/grpc/_cython/_cygrpc/records.pyx.pxi
  8. 14
      test/core/channel/channel_args_test.cc
  9. 44
      test/core/compression/compression_test.cc
  10. 4
      test/core/end2end/fixtures/h2_compress.cc
  11. 34
      test/core/end2end/tests/compressed_payload.cc
  12. 4
      test/core/end2end/tests/stream_compression_compressed_payload.cc
  13. 13
      test/core/end2end/tests/workaround_cronet_compression.cc
  14. 6
      test/core/surface/byte_buffer_reader_test.cc
  15. 2
      test/cpp/end2end/end2end_test.cc
  16. 2
      test/cpp/end2end/filter_end2end_test.cc
  17. 2
      test/cpp/end2end/generic_end2end_test.cc
  18. 2
      test/cpp/end2end/server_builder_plugin_test.cc
  19. 4
      test/cpp/interop/interop_client.cc

4
include/grpc/impl/codegen/compression_types.h
Unescape View File

@ -55,8 +55,8 @@ extern "C" {
/** The various compression algorithms supported by gRPC */ /** The various compression algorithms supported by gRPC */
typedef enum { typedef enum {
GRPC_COMPRESS_NONE = 0, GRPC_COMPRESS_NONE = 0,
GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_DEFLATE,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_STREAM_GZIP, GRPC_COMPRESS_STREAM_GZIP,
/* TODO(ctiller): snappy */ /* TODO(ctiller): snappy */
GRPC_COMPRESS_ALGORITHMS_COUNT GRPC_COMPRESS_ALGORITHMS_COUNT

23
src/core/lib/compression/compression.cc
Unescape View File

@ -29,8 +29,7 @@
int grpc_compression_algorithm_is_message( int grpc_compression_algorithm_is_message(
grpc_compression_algorithm algorithm) { grpc_compression_algorithm algorithm) {
return (algorithm >= GRPC_COMPRESS_MESSAGE_DEFLATE && return (algorithm >= GRPC_COMPRESS_DEFLATE && algorithm <= GRPC_COMPRESS_GZIP)
algorithm <= GRPC_COMPRESS_MESSAGE_GZIP)
? 1 ? 1
: 0; : 0;
} }
@ -45,10 +44,10 @@ int grpc_compression_algorithm_parse(grpc_slice name,
*algorithm = GRPC_COMPRESS_NONE; *algorithm = GRPC_COMPRESS_NONE;
return 1; return 1;
} else if (grpc_slice_eq(name, GRPC_MDSTR_MESSAGE_SLASH_DEFLATE)) { } else if (grpc_slice_eq(name, GRPC_MDSTR_MESSAGE_SLASH_DEFLATE)) {
*algorithm = GRPC_COMPRESS_MESSAGE_DEFLATE; *algorithm = GRPC_COMPRESS_DEFLATE;
return 1; return 1;
} else if (grpc_slice_eq(name, GRPC_MDSTR_MESSAGE_SLASH_GZIP)) { } else if (grpc_slice_eq(name, GRPC_MDSTR_MESSAGE_SLASH_GZIP)) {
*algorithm = GRPC_COMPRESS_MESSAGE_GZIP; *algorithm = GRPC_COMPRESS_GZIP;
return 1; return 1;
} else if (grpc_slice_eq(name, GRPC_MDSTR_STREAM_SLASH_GZIP)) { } else if (grpc_slice_eq(name, GRPC_MDSTR_STREAM_SLASH_GZIP)) {
*algorithm = GRPC_COMPRESS_STREAM_GZIP; *algorithm = GRPC_COMPRESS_STREAM_GZIP;
@ -67,10 +66,10 @@ int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
case GRPC_COMPRESS_NONE: case GRPC_COMPRESS_NONE:
*name = "identity"; *name = "identity";
return 1; return 1;
case GRPC_COMPRESS_MESSAGE_DEFLATE: case GRPC_COMPRESS_DEFLATE:
*name = "message/deflate"; *name = "message/deflate";
return 1; return 1;
case GRPC_COMPRESS_MESSAGE_GZIP: case GRPC_COMPRESS_GZIP:
*name = "message/gzip"; *name = "message/gzip";
return 1; return 1;
case GRPC_COMPRESS_STREAM_GZIP: case GRPC_COMPRESS_STREAM_GZIP:
@ -133,9 +132,9 @@ grpc_slice grpc_compression_algorithm_slice(
switch (algorithm) { switch (algorithm) {
case GRPC_COMPRESS_NONE: case GRPC_COMPRESS_NONE:
return GRPC_MDSTR_IDENTITY; return GRPC_MDSTR_IDENTITY;
case GRPC_COMPRESS_MESSAGE_DEFLATE: case GRPC_COMPRESS_DEFLATE:
return GRPC_MDSTR_MESSAGE_SLASH_DEFLATE; return GRPC_MDSTR_MESSAGE_SLASH_DEFLATE;
case GRPC_COMPRESS_MESSAGE_GZIP: case GRPC_COMPRESS_GZIP:
return GRPC_MDSTR_MESSAGE_SLASH_GZIP; return GRPC_MDSTR_MESSAGE_SLASH_GZIP;
case GRPC_COMPRESS_STREAM_GZIP: case GRPC_COMPRESS_STREAM_GZIP:
return GRPC_MDSTR_STREAM_SLASH_GZIP; return GRPC_MDSTR_STREAM_SLASH_GZIP;
@ -149,9 +148,9 @@ grpc_compression_algorithm grpc_compression_algorithm_from_slice(
grpc_slice str) { grpc_slice str) {
if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_COMPRESS_NONE; if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_COMPRESS_NONE;
if (grpc_slice_eq(str, GRPC_MDSTR_MESSAGE_SLASH_DEFLATE)) if (grpc_slice_eq(str, GRPC_MDSTR_MESSAGE_SLASH_DEFLATE))
return GRPC_COMPRESS_MESSAGE_DEFLATE; return GRPC_COMPRESS_DEFLATE;
if (grpc_slice_eq(str, GRPC_MDSTR_MESSAGE_SLASH_GZIP)) if (grpc_slice_eq(str, GRPC_MDSTR_MESSAGE_SLASH_GZIP))
return GRPC_COMPRESS_MESSAGE_GZIP; return GRPC_COMPRESS_GZIP;
if (grpc_slice_eq(str, GRPC_MDSTR_STREAM_SLASH_GZIP)) if (grpc_slice_eq(str, GRPC_MDSTR_STREAM_SLASH_GZIP))
return GRPC_COMPRESS_STREAM_GZIP; return GRPC_COMPRESS_STREAM_GZIP;
return GRPC_COMPRESS_ALGORITHMS_COUNT; return GRPC_COMPRESS_ALGORITHMS_COUNT;
@ -162,9 +161,9 @@ grpc_mdelem grpc_compression_encoding_mdelem(
switch (algorithm) { switch (algorithm) {
case GRPC_COMPRESS_NONE: case GRPC_COMPRESS_NONE:
return GRPC_MDELEM_GRPC_ENCODING_IDENTITY; return GRPC_MDELEM_GRPC_ENCODING_IDENTITY;
case GRPC_COMPRESS_MESSAGE_DEFLATE: case GRPC_COMPRESS_DEFLATE:
return GRPC_MDELEM_GRPC_ENCODING_DEFLATE; return GRPC_MDELEM_GRPC_ENCODING_DEFLATE;
case GRPC_COMPRESS_MESSAGE_GZIP: case GRPC_COMPRESS_GZIP:
return GRPC_MDELEM_GRPC_ENCODING_GZIP; return GRPC_MDELEM_GRPC_ENCODING_GZIP;
case GRPC_COMPRESS_STREAM_GZIP: case GRPC_COMPRESS_STREAM_GZIP:
return GRPC_MDELEM_GRPC_ENCODING_GZIP; return GRPC_MDELEM_GRPC_ENCODING_GZIP;

8
src/core/lib/compression/compression_internal.cc
Unescape View File

@ -80,9 +80,9 @@ grpc_message_compression_algorithm
grpc_compression_algorithm_to_message_compression_algorithm( grpc_compression_algorithm_to_message_compression_algorithm(
grpc_compression_algorithm algo) { grpc_compression_algorithm algo) {
switch (algo) { switch (algo) {
case GRPC_COMPRESS_MESSAGE_DEFLATE: case GRPC_COMPRESS_DEFLATE:
return GRPC_MESSAGE_COMPRESS_DEFLATE; return GRPC_MESSAGE_COMPRESS_DEFLATE;
case GRPC_COMPRESS_MESSAGE_GZIP: case GRPC_COMPRESS_GZIP:
return GRPC_MESSAGE_COMPRESS_GZIP; return GRPC_MESSAGE_COMPRESS_GZIP;
default: default:
return GRPC_MESSAGE_COMPRESS_NONE; return GRPC_MESSAGE_COMPRESS_NONE;
@ -147,10 +147,10 @@ int grpc_compression_algorithm_from_message_stream_compression_algorithm(
*algorithm = GRPC_COMPRESS_NONE; *algorithm = GRPC_COMPRESS_NONE;
return 1; return 1;
case GRPC_MESSAGE_COMPRESS_DEFLATE: case GRPC_MESSAGE_COMPRESS_DEFLATE:
*algorithm = GRPC_COMPRESS_MESSAGE_DEFLATE; *algorithm = GRPC_COMPRESS_DEFLATE;
return 1; return 1;
case GRPC_MESSAGE_COMPRESS_GZIP: case GRPC_MESSAGE_COMPRESS_GZIP:
*algorithm = GRPC_COMPRESS_MESSAGE_GZIP; *algorithm = GRPC_COMPRESS_GZIP;
return 1; return 1;
default: default:
*algorithm = GRPC_COMPRESS_NONE; *algorithm = GRPC_COMPRESS_NONE;

8
src/core/lib/compression/compression_ruby.cc
Unescape View File

@ -28,10 +28,10 @@ int grpc_compression_algorithm_parse_ruby(
*algorithm = GRPC_COMPRESS_NONE; *algorithm = GRPC_COMPRESS_NONE;
return 1; return 1;
} else if (grpc_slice_eq(name, GRPC_MDSTR_DEFLATE)) { } else if (grpc_slice_eq(name, GRPC_MDSTR_DEFLATE)) {
*algorithm = GRPC_COMPRESS_MESSAGE_DEFLATE; *algorithm = GRPC_COMPRESS_DEFLATE;
return 1; return 1;
} else if (grpc_slice_eq(name, GRPC_MDSTR_GZIP)) { } else if (grpc_slice_eq(name, GRPC_MDSTR_GZIP)) {
*algorithm = GRPC_COMPRESS_MESSAGE_GZIP; *algorithm = GRPC_COMPRESS_GZIP;
return 1; return 1;
} else if (grpc_slice_eq(name, GRPC_MDSTR_STREAM_SLASH_GZIP)) { } else if (grpc_slice_eq(name, GRPC_MDSTR_STREAM_SLASH_GZIP)) {
*algorithm = GRPC_COMPRESS_STREAM_GZIP; *algorithm = GRPC_COMPRESS_STREAM_GZIP;
@ -50,10 +50,10 @@ int grpc_compression_algorithm_name_ruby(grpc_compression_algorithm algorithm,
case GRPC_COMPRESS_NONE: case GRPC_COMPRESS_NONE:
*name = "identity"; *name = "identity";
return 1; return 1;
case GRPC_COMPRESS_MESSAGE_DEFLATE: case GRPC_COMPRESS_DEFLATE:
*name = "deflate"; *name = "deflate";
return 1; return 1;
case GRPC_COMPRESS_MESSAGE_GZIP: case GRPC_COMPRESS_GZIP:
*name = "gzip"; *name = "gzip";
return 1; return 1;
case GRPC_COMPRESS_STREAM_GZIP: case GRPC_COMPRESS_STREAM_GZIP:

4
src/objective-c/GRPCClient/GRPCCall+ChannelArg.m
Unescape View File

@ -46,10 +46,10 @@
hostConfig.compressAlgorithm = GRPC_COMPRESS_NONE; hostConfig.compressAlgorithm = GRPC_COMPRESS_NONE;
break; break;
case GRPCCompressDeflate: case GRPCCompressDeflate:
hostConfig.compressAlgorithm = GRPC_COMPRESS_MESSAGE_DEFLATE; hostConfig.compressAlgorithm = GRPC_COMPRESS_DEFLATE;
break; break;
case GRPCCompressGzip: case GRPCCompressGzip:
hostConfig.compressAlgorithm = GRPC_COMPRESS_MESSAGE_GZIP; hostConfig.compressAlgorithm = GRPC_COMPRESS_GZIP;
break; break;
default: default:
NSLog(@"Invalid compression algorithm"); NSLog(@"Invalid compression algorithm");

4
src/python/grpcio/grpc/_cython/_cygrpc/grpc.pxi
Unescape View File

@ -557,8 +557,8 @@ cdef extern from "grpc/compression.h":
ctypedef enum grpc_compression_algorithm: ctypedef enum grpc_compression_algorithm:
GRPC_COMPRESS_NONE GRPC_COMPRESS_NONE
GRPC_COMPRESS_MESSAGE_DEFLATE GRPC_COMPRESS_DEFLATE
GRPC_COMPRESS_MESSAGE_GZIP GRPC_COMPRESS_GZIP
GRPC_COMPRESS_STREAM_GZIP GRPC_COMPRESS_STREAM_GZIP
GRPC_COMPRESS_ALGORITHMS_COUNT GRPC_COMPRESS_ALGORITHMS_COUNT

4
src/python/grpcio/grpc/_cython/_cygrpc/records.pyx.pxi
Unescape View File

@ -112,8 +112,8 @@ class OperationType:
class CompressionAlgorithm: class CompressionAlgorithm:
none = GRPC_COMPRESS_NONE none = GRPC_COMPRESS_NONE
deflate = GRPC_COMPRESS_MESSAGE_DEFLATE deflate = GRPC_COMPRESS_DEFLATE
gzip = GRPC_COMPRESS_MESSAGE_GZIP gzip = GRPC_COMPRESS_GZIP
class CompressionLevel: class CompressionLevel:

14
test/core/channel/channel_args_test.cc
Unescape View File

@ -62,8 +62,8 @@ static void test_set_compression_algorithm(void) {
grpc_core::ExecCtx exec_ctx; grpc_core::ExecCtx exec_ctx;
grpc_channel_args* ch_args; grpc_channel_args* ch_args;
ch_args = grpc_channel_args_set_compression_algorithm( ch_args =
nullptr, GRPC_COMPRESS_MESSAGE_GZIP); grpc_channel_args_set_compression_algorithm(nullptr, GRPC_COMPRESS_GZIP);
GPR_ASSERT(ch_args->num_args == 1); GPR_ASSERT(ch_args->num_args == 1);
GPR_ASSERT(strcmp(ch_args->args[0].key, GPR_ASSERT(strcmp(ch_args->args[0].key,
GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM) == 0); GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM) == 0);
@ -90,10 +90,10 @@ static void test_compression_algorithm_states(void) {
/* disable message/gzip and message/deflate and stream/gzip */ /* disable message/gzip and message/deflate and stream/gzip */
ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state( ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state(
&ch_args, GRPC_COMPRESS_MESSAGE_GZIP, 0); &ch_args, GRPC_COMPRESS_GZIP, 0);
GPR_ASSERT(ch_args == ch_args_wo_gzip); GPR_ASSERT(ch_args == ch_args_wo_gzip);
ch_args_wo_gzip_deflate = grpc_channel_args_compression_algorithm_set_state( ch_args_wo_gzip_deflate = grpc_channel_args_compression_algorithm_set_state(
&ch_args_wo_gzip, GRPC_COMPRESS_MESSAGE_DEFLATE, 0); &ch_args_wo_gzip, GRPC_COMPRESS_DEFLATE, 0);
GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate); GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate);
ch_args_wo_gzip_deflate_gzip = ch_args_wo_gzip_deflate_gzip =
grpc_channel_args_compression_algorithm_set_state( grpc_channel_args_compression_algorithm_set_state(
@ -103,7 +103,7 @@ static void test_compression_algorithm_states(void) {
states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states( states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states(
ch_args_wo_gzip_deflate); ch_args_wo_gzip_deflate);
for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) { for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
if (i == GRPC_COMPRESS_MESSAGE_GZIP || i == GRPC_COMPRESS_MESSAGE_DEFLATE || if (i == GRPC_COMPRESS_GZIP || i == GRPC_COMPRESS_DEFLATE ||
i == GRPC_COMPRESS_STREAM_GZIP) { i == GRPC_COMPRESS_STREAM_GZIP) {
GPR_ASSERT(GPR_BITGET(states_bitset, i) == 0); GPR_ASSERT(GPR_BITGET(states_bitset, i) == 0);
} else { } else {
@ -113,7 +113,7 @@ static void test_compression_algorithm_states(void) {
/* re-enabled message/gzip and stream/gzip only */ /* re-enabled message/gzip and stream/gzip only */
ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state( ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state(
&ch_args_wo_gzip_deflate_gzip, GRPC_COMPRESS_MESSAGE_GZIP, 1); &ch_args_wo_gzip_deflate_gzip, GRPC_COMPRESS_GZIP, 1);
ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state( ch_args_wo_gzip = grpc_channel_args_compression_algorithm_set_state(
&ch_args_wo_gzip, GRPC_COMPRESS_STREAM_GZIP, 1); &ch_args_wo_gzip, GRPC_COMPRESS_STREAM_GZIP, 1);
GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate_gzip); GPR_ASSERT(ch_args_wo_gzip == ch_args_wo_gzip_deflate_gzip);
@ -121,7 +121,7 @@ static void test_compression_algorithm_states(void) {
states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states( states_bitset = (unsigned)grpc_channel_args_compression_algorithm_get_states(
ch_args_wo_gzip); ch_args_wo_gzip);
for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) { for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
if (i == GRPC_COMPRESS_MESSAGE_DEFLATE) { if (i == GRPC_COMPRESS_DEFLATE) {
GPR_ASSERT(GPR_BITGET(states_bitset, i) == 0); GPR_ASSERT(GPR_BITGET(states_bitset, i) == 0);
} else { } else {
GPR_ASSERT(GPR_BITGET(states_bitset, i) != 0); GPR_ASSERT(GPR_BITGET(states_bitset, i) != 0);

44
test/core/compression/compression_test.cc
Unescape View File

@ -31,8 +31,8 @@ static void test_compression_algorithm_parse(void) {
const char* valid_names[] = {"identity", "message/gzip", "message/deflate", const char* valid_names[] = {"identity", "message/gzip", "message/deflate",
"stream/gzip"}; "stream/gzip"};
const grpc_compression_algorithm valid_algorithms[] = { const grpc_compression_algorithm valid_algorithms[] = {
GRPC_COMPRESS_NONE, GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE,
GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_STREAM_GZIP}; GRPC_COMPRESS_STREAM_GZIP};
const char* invalid_names[] = {"gzip2", "foo", "", "2gzip"}; const char* invalid_names[] = {"gzip2", "foo", "", "2gzip"};
gpr_log(GPR_DEBUG, "test_compression_algorithm_parse"); gpr_log(GPR_DEBUG, "test_compression_algorithm_parse");
@ -64,8 +64,8 @@ static void test_compression_algorithm_name(void) {
const char* valid_names[] = {"identity", "message/gzip", "message/deflate", const char* valid_names[] = {"identity", "message/gzip", "message/deflate",
"stream/gzip"}; "stream/gzip"};
const grpc_compression_algorithm valid_algorithms[] = { const grpc_compression_algorithm valid_algorithms[] = {
GRPC_COMPRESS_NONE, GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE,
GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_STREAM_GZIP}; GRPC_COMPRESS_STREAM_GZIP};
gpr_log(GPR_DEBUG, "test_compression_algorithm_name"); gpr_log(GPR_DEBUG, "test_compression_algorithm_name");
@ -110,21 +110,21 @@ static void test_compression_algorithm_for_level(void) {
/* accept only gzip */ /* accept only gzip */
uint32_t accepted_encodings = 0; uint32_t accepted_encodings = 0;
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */ GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_GZIP); GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_GZIP);
GPR_ASSERT(GRPC_COMPRESS_NONE == GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
accepted_encodings)); accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP == GPR_ASSERT(GRPC_COMPRESS_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW,
accepted_encodings)); accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP == GPR_ASSERT(GRPC_COMPRESS_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED,
accepted_encodings)); accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP == GPR_ASSERT(GRPC_COMPRESS_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH,
accepted_encodings)); accepted_encodings));
} }
@ -133,21 +133,21 @@ static void test_compression_algorithm_for_level(void) {
/* accept only deflate */ /* accept only deflate */
uint32_t accepted_encodings = 0; uint32_t accepted_encodings = 0;
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */ GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_DEFLATE); GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_DEFLATE);
GPR_ASSERT(GRPC_COMPRESS_NONE == GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
accepted_encodings)); accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE == GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW,
accepted_encodings)); accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE == GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED,
accepted_encodings)); accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE == GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH,
accepted_encodings)); accepted_encodings));
} }
@ -156,22 +156,22 @@ static void test_compression_algorithm_for_level(void) {
/* accept gzip and deflate */ /* accept gzip and deflate */
uint32_t accepted_encodings = 0; uint32_t accepted_encodings = 0;
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */ GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_GZIP); GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_GZIP);
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_DEFLATE); GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_DEFLATE);
GPR_ASSERT(GRPC_COMPRESS_NONE == GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
accepted_encodings)); accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP == GPR_ASSERT(GRPC_COMPRESS_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW,
accepted_encodings)); accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE == GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED,
accepted_encodings)); accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE == GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH,
accepted_encodings)); accepted_encodings));
} }
@ -203,23 +203,23 @@ static void test_compression_algorithm_for_level(void) {
/* accept all algorithms */ /* accept all algorithms */
uint32_t accepted_encodings = 0; uint32_t accepted_encodings = 0;
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */ GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_GZIP); GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_GZIP);
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_MESSAGE_DEFLATE); GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_DEFLATE);
GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_STREAM_GZIP); GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_STREAM_GZIP);
GPR_ASSERT(GRPC_COMPRESS_NONE == GPR_ASSERT(GRPC_COMPRESS_NONE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE,
accepted_encodings)); accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_GZIP == GPR_ASSERT(GRPC_COMPRESS_GZIP ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW,
accepted_encodings)); accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE == GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED,
accepted_encodings)); accepted_encodings));
GPR_ASSERT(GRPC_COMPRESS_MESSAGE_DEFLATE == GPR_ASSERT(GRPC_COMPRESS_DEFLATE ==
grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH, grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH,
accepted_encodings)); accepted_encodings));
} }

4
test/core/end2end/fixtures/h2_compress.cc
Unescape View File

@ -70,7 +70,7 @@ void chttp2_init_client_fullstack_compression(grpc_end2end_test_fixture* f,
grpc_channel_args_destroy(ffd->client_args_compression); grpc_channel_args_destroy(ffd->client_args_compression);
} }
ffd->client_args_compression = grpc_channel_args_set_compression_algorithm( ffd->client_args_compression = grpc_channel_args_set_compression_algorithm(
client_args, GRPC_COMPRESS_MESSAGE_GZIP); client_args, GRPC_COMPRESS_GZIP);
f->client = grpc_insecure_channel_create( f->client = grpc_insecure_channel_create(
ffd->localaddr, ffd->client_args_compression, nullptr); ffd->localaddr, ffd->client_args_compression, nullptr);
} }
@ -84,7 +84,7 @@ void chttp2_init_server_fullstack_compression(grpc_end2end_test_fixture* f,
grpc_channel_args_destroy(ffd->server_args_compression); grpc_channel_args_destroy(ffd->server_args_compression);
} }
ffd->server_args_compression = grpc_channel_args_set_compression_algorithm( ffd->server_args_compression = grpc_channel_args_set_compression_algorithm(
server_args, GRPC_COMPRESS_MESSAGE_GZIP); server_args, GRPC_COMPRESS_GZIP);
if (f->server) { if (f->server) {
grpc_server_destroy(f->server); grpc_server_destroy(f->server);
} }

34
test/core/end2end/tests/compressed_payload.cc
Unescape View File

@ -383,9 +383,9 @@ static void request_with_payload_template(
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s), GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_NONE) != 0); GRPC_COMPRESS_NONE) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s), GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_MESSAGE_DEFLATE) != 0); GRPC_COMPRESS_DEFLATE) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s), GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_MESSAGE_GZIP) != 0); GRPC_COMPRESS_GZIP) != 0);
memset(ops, 0, sizeof(ops)); memset(ops, 0, sizeof(ops));
op = ops; op = ops;
@ -550,9 +550,8 @@ static void test_invoke_request_with_exceptionally_uncompressed_payload(
grpc_end2end_test_config config) { grpc_end2end_test_config config) {
request_with_payload_template( request_with_payload_template(
config, "test_invoke_request_with_exceptionally_uncompressed_payload", config, "test_invoke_request_with_exceptionally_uncompressed_payload",
GRPC_WRITE_NO_COMPRESS, GRPC_COMPRESS_MESSAGE_GZIP, GRPC_WRITE_NO_COMPRESS, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, nullptr, false,
GRPC_COMPRESS_MESSAGE_GZIP, nullptr, false,
/* ignored */ GRPC_COMPRESS_LEVEL_NONE, false); /* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
} }
@ -569,8 +568,8 @@ static void test_invoke_request_with_compressed_payload(
grpc_end2end_test_config config) { grpc_end2end_test_config config) {
request_with_payload_template( request_with_payload_template(
config, "test_invoke_request_with_compressed_payload", 0, config, "test_invoke_request_with_compressed_payload", 0,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP, nullptr, false, GRPC_COMPRESS_GZIP, nullptr, false,
/* ignored */ GRPC_COMPRESS_LEVEL_NONE, false); /* ignored */ GRPC_COMPRESS_LEVEL_NONE, false);
} }
@ -578,8 +577,8 @@ static void test_invoke_request_with_send_message_before_initial_metadata(
grpc_end2end_test_config config) { grpc_end2end_test_config config) {
request_with_payload_template( request_with_payload_template(
config, "test_invoke_request_with_compressed_payload", 0, config, "test_invoke_request_with_compressed_payload", 0,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP, nullptr, false, GRPC_COMPRESS_GZIP, nullptr, false,
/* ignored */ GRPC_COMPRESS_LEVEL_NONE, true); /* ignored */ GRPC_COMPRESS_LEVEL_NONE, true);
} }
@ -611,32 +610,31 @@ static void test_invoke_request_with_compressed_payload_md_override(
/* Channel default NONE (aka IDENTITY), call override to GZIP */ /* Channel default NONE (aka IDENTITY), call override to GZIP */
request_with_payload_template( request_with_payload_template(
config, "test_invoke_request_with_compressed_payload_md_override_1", 0, config, "test_invoke_request_with_compressed_payload_md_override_1", 0,
GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_NONE, &gzip_compression_override, false, GRPC_COMPRESS_NONE, &gzip_compression_override, false,
/*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false); /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false);
/* Channel default DEFLATE, call override to GZIP */ /* Channel default DEFLATE, call override to GZIP */
request_with_payload_template( request_with_payload_template(
config, "test_invoke_request_with_compressed_payload_md_override_2", 0, config, "test_invoke_request_with_compressed_payload_md_override_2", 0,
GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_DEFLATE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, &gzip_compression_override, false,
&gzip_compression_override, false,
/*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false); /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false);
/* Channel default DEFLATE, call override to NONE (aka IDENTITY) */ /* Channel default DEFLATE, call override to NONE (aka IDENTITY) */
request_with_payload_template( request_with_payload_template(
config, "test_invoke_request_with_compressed_payload_md_override_3", 0, config, "test_invoke_request_with_compressed_payload_md_override_3", 0,
GRPC_COMPRESS_MESSAGE_DEFLATE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_DEFLATE, GRPC_COMPRESS_NONE, GRPC_COMPRESS_NONE,
GRPC_COMPRESS_NONE, &identity_compression_override, false, GRPC_COMPRESS_NONE, &identity_compression_override, false,
/*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false); /*ignored*/ GRPC_COMPRESS_LEVEL_NONE, false);
} }
static void test_invoke_request_with_disabled_algorithm( static void test_invoke_request_with_disabled_algorithm(
grpc_end2end_test_config config) { grpc_end2end_test_config config) {
request_for_disabled_algorithm( request_for_disabled_algorithm(config,
config, "test_invoke_request_with_disabled_algorithm", 0, "test_invoke_request_with_disabled_algorithm",
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP, 0, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
GRPC_STATUS_UNIMPLEMENTED, nullptr); GRPC_STATUS_UNIMPLEMENTED, nullptr);
} }
void compressed_payload(grpc_end2end_test_config config) { void compressed_payload(grpc_end2end_test_config config) {

4
test/core/end2end/tests/stream_compression_compressed_payload.cc
Unescape View File

@ -390,9 +390,9 @@ static void request_with_payload_template(
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s), GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_NONE) != 0); GRPC_COMPRESS_NONE) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s), GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_MESSAGE_DEFLATE) != 0); GRPC_COMPRESS_DEFLATE) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s), GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_MESSAGE_GZIP) != 0); GRPC_COMPRESS_GZIP) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s), GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_STREAM_GZIP) != 0); GRPC_COMPRESS_STREAM_GZIP) != 0);
GPR_ASSERT(GPR_BITCOUNT(grpc_call_test_only_get_encodings_accepted_by_peer( GPR_ASSERT(GPR_BITCOUNT(grpc_call_test_only_get_encodings_accepted_by_peer(

13
test/core/end2end/tests/workaround_cronet_compression.cc
Unescape View File

@ -207,9 +207,9 @@ static void request_with_payload_template(
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s), GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_NONE) != 0); GRPC_COMPRESS_NONE) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s), GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_MESSAGE_DEFLATE) != 0); GRPC_COMPRESS_DEFLATE) != 0);
GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s), GPR_ASSERT(GPR_BITGET(grpc_call_test_only_get_encodings_accepted_by_peer(s),
GRPC_COMPRESS_MESSAGE_GZIP) != 0); GRPC_COMPRESS_GZIP) != 0);
memset(ops, 0, sizeof(ops)); memset(ops, 0, sizeof(ops));
op = ops; op = ops;
@ -365,16 +365,16 @@ typedef struct workaround_cronet_compression_config {
} workaround_cronet_compression_config; } workaround_cronet_compression_config;
static workaround_cronet_compression_config workaround_configs[] = { static workaround_cronet_compression_config workaround_configs[] = {
{nullptr, GRPC_COMPRESS_MESSAGE_GZIP}, {nullptr, GRPC_COMPRESS_GZIP},
{const_cast<char*>( {const_cast<char*>(
"grpc-objc/1.3.0-dev grpc-c/3.0.0-dev (ios; cronet_http; gentle)"), "grpc-objc/1.3.0-dev grpc-c/3.0.0-dev (ios; cronet_http; gentle)"),
GRPC_COMPRESS_NONE}, GRPC_COMPRESS_NONE},
{const_cast<char*>( {const_cast<char*>(
"grpc-objc/1.3.0-dev grpc-c/3.0.0-dev (ios; chttp2; gentle)"), "grpc-objc/1.3.0-dev grpc-c/3.0.0-dev (ios; chttp2; gentle)"),
GRPC_COMPRESS_MESSAGE_GZIP}, GRPC_COMPRESS_GZIP},
{const_cast<char*>( {const_cast<char*>(
"grpc-objc/1.4.0 grpc-c/3.0.0-dev (ios; cronet_http; gentle)"), "grpc-objc/1.4.0 grpc-c/3.0.0-dev (ios; cronet_http; gentle)"),
GRPC_COMPRESS_MESSAGE_GZIP}}; GRPC_COMPRESS_GZIP}};
static const size_t workaround_configs_num = static const size_t workaround_configs_num =
sizeof(workaround_configs) / sizeof(*workaround_configs); sizeof(workaround_configs) / sizeof(*workaround_configs);
@ -383,8 +383,7 @@ static void test_workaround_cronet_compression(
for (uint32_t i = 0; i < workaround_configs_num; i++) { for (uint32_t i = 0; i < workaround_configs_num; i++) {
request_with_payload_template( request_with_payload_template(
config, "test_invoke_request_with_compressed_payload", 0, config, "test_invoke_request_with_compressed_payload", 0,
GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_MESSAGE_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_GZIP,
GRPC_COMPRESS_MESSAGE_GZIP,
workaround_configs[i].expected_algorithm_from_server, nullptr, false, workaround_configs[i].expected_algorithm_from_server, nullptr, false,
/* ignored */ GRPC_COMPRESS_LEVEL_NONE, /* ignored */ GRPC_COMPRESS_LEVEL_NONE,
workaround_configs[i].user_agent_override); workaround_configs[i].user_agent_override);

6
test/core/surface/byte_buffer_reader_test.cc
Unescape View File

@ -109,7 +109,7 @@ static void test_read_corrupted_slice(void) {
LOG_TEST("test_read_corrupted_slice"); LOG_TEST("test_read_corrupted_slice");
slice = grpc_slice_from_copied_string("test"); slice = grpc_slice_from_copied_string("test");
buffer = grpc_raw_byte_buffer_create(&slice, 1); buffer = grpc_raw_byte_buffer_create(&slice, 1);
buffer->data.raw.compression = GRPC_COMPRESS_MESSAGE_GZIP; /* lies! */ buffer->data.raw.compression = GRPC_COMPRESS_GZIP; /* lies! */
grpc_slice_unref(slice); grpc_slice_unref(slice);
GPR_ASSERT(!grpc_byte_buffer_reader_init(&reader, buffer)); GPR_ASSERT(!grpc_byte_buffer_reader_init(&reader, buffer));
grpc_byte_buffer_destroy(buffer); grpc_byte_buffer_destroy(buffer);
@ -161,13 +161,13 @@ static void read_compressed_slice(grpc_compression_algorithm algorithm,
static void test_read_gzip_compressed_slice(void) { static void test_read_gzip_compressed_slice(void) {
const size_t INPUT_SIZE = 2048; const size_t INPUT_SIZE = 2048;
LOG_TEST("test_read_gzip_compressed_slice"); LOG_TEST("test_read_gzip_compressed_slice");
read_compressed_slice(GRPC_COMPRESS_MESSAGE_GZIP, INPUT_SIZE); read_compressed_slice(GRPC_COMPRESS_GZIP, INPUT_SIZE);
} }
static void test_read_deflate_compressed_slice(void) { static void test_read_deflate_compressed_slice(void) {
const size_t INPUT_SIZE = 2048; const size_t INPUT_SIZE = 2048;
LOG_TEST("test_read_deflate_compressed_slice"); LOG_TEST("test_read_deflate_compressed_slice");
read_compressed_slice(GRPC_COMPRESS_MESSAGE_DEFLATE, INPUT_SIZE); read_compressed_slice(GRPC_COMPRESS_DEFLATE, INPUT_SIZE);
} }
static void test_byte_buffer_from_reader(void) { static void test_byte_buffer_from_reader(void) {

2
test/cpp/end2end/end2end_test.cc
Unescape View File

@ -350,7 +350,7 @@ static void SendRpc(grpc::testing::EchoTestService::Stub* stub, int num_rpcs,
char bytes[8] = {'\0', '\1', '\2', '\3', '\4', '\5', '\6', (char)i}; char bytes[8] = {'\0', '\1', '\2', '\3', '\4', '\5', '\6', (char)i};
context.AddMetadata("custom-bin", grpc::string(bytes, 8)); context.AddMetadata("custom-bin", grpc::string(bytes, 8));
} }
context.set_compression_algorithm(GRPC_COMPRESS_MESSAGE_GZIP); context.set_compression_algorithm(GRPC_COMPRESS_GZIP);
Status s = stub->Echo(&context, request, &response); Status s = stub->Echo(&context, request, &response);
EXPECT_EQ(response.message(), request.message()); EXPECT_EQ(response.message(), request.message());
EXPECT_TRUE(s.ok()); EXPECT_TRUE(s.ok());

2
test/cpp/end2end/filter_end2end_test.cc
Unescape View File

@ -266,7 +266,7 @@ TEST_F(FilterEnd2endTest, SimpleBidiStreaming) {
GenericServerContext srv_ctx; GenericServerContext srv_ctx;
GenericServerAsyncReaderWriter srv_stream(&srv_ctx); GenericServerAsyncReaderWriter srv_stream(&srv_ctx);
cli_ctx.set_compression_algorithm(GRPC_COMPRESS_MESSAGE_GZIP); cli_ctx.set_compression_algorithm(GRPC_COMPRESS_GZIP);
send_request.set_message("Hello"); send_request.set_message("Hello");
std::unique_ptr<GenericClientAsyncReaderWriter> cli_stream = std::unique_ptr<GenericClientAsyncReaderWriter> cli_stream =
generic_stub_->PrepareCall(&cli_ctx, kMethodName, &cli_cq_); generic_stub_->PrepareCall(&cli_ctx, kMethodName, &cli_cq_);

2
test/cpp/end2end/generic_end2end_test.cc
Unescape View File

@ -269,7 +269,7 @@ TEST_F(GenericEnd2endTest, SimpleBidiStreaming) {
GenericServerContext srv_ctx; GenericServerContext srv_ctx;
GenericServerAsyncReaderWriter srv_stream(&srv_ctx); GenericServerAsyncReaderWriter srv_stream(&srv_ctx);
cli_ctx.set_compression_algorithm(GRPC_COMPRESS_MESSAGE_GZIP); cli_ctx.set_compression_algorithm(GRPC_COMPRESS_GZIP);
send_request.set_message("Hello"); send_request.set_message("Hello");
std::unique_ptr<GenericClientAsyncReaderWriter> cli_stream = std::unique_ptr<GenericClientAsyncReaderWriter> cli_stream =
generic_stub_->PrepareCall(&cli_ctx, kMethodName, &cli_cq_); generic_stub_->PrepareCall(&cli_ctx, kMethodName, &cli_cq_);

2
test/cpp/end2end/server_builder_plugin_test.cc
Unescape View File

@ -251,7 +251,7 @@ TEST_P(ServerBuilderPluginTest, PluginWithServiceTest) {
EchoResponse response; EchoResponse response;
request.set_message("Hello hello hello hello"); request.set_message("Hello hello hello hello");
ClientContext context; ClientContext context;
context.set_compression_algorithm(GRPC_COMPRESS_MESSAGE_GZIP); context.set_compression_algorithm(GRPC_COMPRESS_GZIP);
Status s = stub_->Echo(&context, request, &response); Status s = stub_->Echo(&context, request, &response);
EXPECT_EQ(response.message(), request.message()); EXPECT_EQ(response.message(), request.message());
EXPECT_TRUE(s.ok()); EXPECT_TRUE(s.ok());

4
test/cpp/interop/interop_client.cc
Unescape View File

@ -189,7 +189,7 @@ bool InteropClient::PerformLargeUnary(SimpleRequest* request,
request->mutable_payload()->set_body(payload.c_str(), kLargeRequestSize); request->mutable_payload()->set_body(payload.c_str(), kLargeRequestSize);
if (request->has_expect_compressed()) { if (request->has_expect_compressed()) {
if (request->expect_compressed().value()) { if (request->expect_compressed().value()) {
context.set_compression_algorithm(GRPC_COMPRESS_MESSAGE_GZIP); context.set_compression_algorithm(GRPC_COMPRESS_GZIP);
} else { } else {
context.set_compression_algorithm(GRPC_COMPRESS_NONE); context.set_compression_algorithm(GRPC_COMPRESS_NONE);
} }
@ -497,7 +497,7 @@ bool InteropClient::DoClientCompressedStreaming() {
StreamingInputCallRequest request; StreamingInputCallRequest request;
StreamingInputCallResponse response; StreamingInputCallResponse response;
context.set_compression_algorithm(GRPC_COMPRESS_MESSAGE_GZIP); context.set_compression_algorithm(GRPC_COMPRESS_GZIP);
std::unique_ptr<ClientWriter<StreamingInputCallRequest>> stream( std::unique_ptr<ClientWriter<StreamingInputCallRequest>> stream(
serviceStub_.Get()->StreamingInputCall(&context, &response)); serviceStub_.Get()->StreamingInputCall(&context, &response));

Write Preview
Loading…
Cancel
Save