Merge commit 'b0bad8f^' into fix-stream-compression-config-interface

5 files changed, 46 insertions, 22 deletions

diff --git a/test/core/compression/BUILD b/test/core/compression/BUILD
index dbeb89a59f..3244b848d8 100644
--- a/test/core/compression/BUILD
+++ b/test/core/compression/BUILD
@@ -20,8 +20,8 @@ licenses(["notice"])  # Apache v2
 
 grpc_cc_test(
     name = "algorithm_test",
-    srcs = ["algorithm_test.c"],
-    language = "C",
+    srcs = ["algorithm_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -32,8 +32,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "compression_test",
-    srcs = ["compression_test.c"],
-    language = "C",
+    srcs = ["compression_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -44,8 +44,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "message_compress_test",
-    srcs = ["message_compress_test.c"],
-    language = "C",
+    srcs = ["message_compress_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/compression/algorithm_test.c b/test/core/compression/algorithm_test.cc
index b3d81d22c8..a0ed7dbc98 100644
--- a/test/core/compression/algorithm_test.c
+++ b/test/core/compression/algorithm_test.cc
@@ -88,8 +88,10 @@ static void test_algorithm_failure(void) {
 
   GPR_ASSERT(grpc_compression_algorithm_name(GRPC_COMPRESS_ALGORITHMS_COUNT,
                                              NULL) == 0);
-  GPR_ASSERT(grpc_compression_algorithm_name(GRPC_COMPRESS_ALGORITHMS_COUNT + 1,
-                                             NULL) == 0);
+  GPR_ASSERT(
+      grpc_compression_algorithm_name(static_cast<grpc_compression_algorithm>(
+                                          GRPC_COMPRESS_ALGORITHMS_COUNT + 1),
+                                      NULL) == 0);
   mdstr = grpc_slice_from_static_string("this-is-an-invalid-algorithm");
   GPR_ASSERT(grpc_compression_algorithm_from_slice(mdstr) ==
              GRPC_COMPRESS_ALGORITHMS_COUNT);
@@ -97,7 +99,8 @@ static void test_algorithm_failure(void) {
       grpc_compression_algorithm_slice(GRPC_COMPRESS_ALGORITHMS_COUNT),
       grpc_empty_slice()));
   GPR_ASSERT(grpc_slice_eq(
-      grpc_compression_algorithm_slice(GRPC_COMPRESS_ALGORITHMS_COUNT + 1),
+      grpc_compression_algorithm_slice(static_cast<grpc_compression_algorithm>(
+          static_cast<int>(GRPC_COMPRESS_ALGORITHMS_COUNT) + 1)),
       grpc_empty_slice()));
   grpc_slice_unref_internal(&exec_ctx, mdstr);
   grpc_exec_ctx_finish(&exec_ctx);
diff --git a/test/core/compression/compression_test.c b/test/core/compression/compression_test.cc
index 6c71658846..359fe8326b 100644
--- a/test/core/compression/compression_test.c
+++ b/test/core/compression/compression_test.cc
@@ -305,21 +305,27 @@ static void test_compression_enable_disable_algorithm(void) {
 
   grpc_compression_options_init(&options);
   for (algorithm = GRPC_COMPRESS_NONE;
-       algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; algorithm++) {
+       algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT;
+       algorithm = static_cast<grpc_compression_algorithm>(
+           static_cast<int>(algorithm) + 1)) {
     /* all algorithms are enabled by default */
     GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options,
                                                              algorithm) != 0);
   }
   /* disable one by one */
   for (algorithm = GRPC_COMPRESS_NONE;
-       algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; algorithm++) {
+       algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT;
+       algorithm = static_cast<grpc_compression_algorithm>(
+           static_cast<int>(algorithm) + 1)) {
     grpc_compression_options_disable_algorithm(&options, algorithm);
     GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options,
                                                              algorithm) == 0);
   }
   /* re-enable one by one */
   for (algorithm = GRPC_COMPRESS_NONE;
-       algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; algorithm++) {
+       algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT;
+       algorithm = static_cast<grpc_compression_algorithm>(
+           static_cast<int>(algorithm) + 1)) {
     grpc_compression_options_enable_algorithm(&options, algorithm);
     GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options,
                                                              algorithm) != 0);
diff --git a/test/core/compression/message_compress_test.c b/test/core/compression/message_compress_test.cc
index 53ef371b72..6fa3a4d2c3 100644
--- a/test/core/compression/message_compress_test.c
+++ b/test/core/compression/message_compress_test.cc
@@ -150,16 +150,18 @@ static grpc_slice create_test_value(test_value id) {
 static void test_tiny_data_compress(void) {
   grpc_slice_buffer input;
   grpc_slice_buffer output;
-  grpc_message_compression_algorithm i;
 
   grpc_slice_buffer_init(&input);
   grpc_slice_buffer_init(&output);
   grpc_slice_buffer_add(&input, create_test_value(ONE_A));
 
-  for (i = 0; i < GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT; i++) {
+  for (int i = 0; i < GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT; i++) {
     if (i == GRPC_MESSAGE_COMPRESS_NONE) continue;
     grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-    GPR_ASSERT(0 == grpc_msg_compress(&exec_ctx, i, &input, &output));
+    GPR_ASSERT(0 == grpc_msg_compress(
+                        &exec_ctx,
+                        static_cast<grpc_message_compression_algorithm>(i),
+                        &input, &output));
     grpc_exec_ctx_finish(&exec_ctx);
     GPR_ASSERT(1 == output.count);
   }
@@ -254,8 +256,11 @@ static void test_bad_compression_algorithm(void) {
       &exec_ctx, GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT, &input, &output);
   GPR_ASSERT(0 == was_compressed);
 
-  was_compressed = grpc_msg_compress(
-      &exec_ctx, GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
+  was_compressed =
+      grpc_msg_compress(&exec_ctx,
+                        static_cast<grpc_message_compression_algorithm>(
+                            GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT + 123),
+                        &input, &output);
   GPR_ASSERT(0 == was_compressed);
   grpc_exec_ctx_finish(&exec_ctx);
 
@@ -278,8 +283,11 @@ static void test_bad_decompression_algorithm(void) {
       &exec_ctx, GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT, &input, &output);
   GPR_ASSERT(0 == was_decompressed);
 
-  was_decompressed = grpc_msg_decompress(
-      &exec_ctx, GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
+  was_decompressed =
+      grpc_msg_decompress(&exec_ctx,
+                          static_cast<grpc_message_compression_algorithm>(
+                              GRPC_MESSAGE_COMPRESS_ALGORITHMS_COUNT + 123),
+                          &input, &output);
   GPR_ASSERT(0 == was_decompressed);
   grpc_exec_ctx_finish(&exec_ctx);
 
@@ -302,8 +310,14 @@ int main(int argc, char** argv) {
     for (j = 0; j < GPR_ARRAY_SIZE(uncompressed_split_modes); j++) {
       for (k = 0; k < GPR_ARRAY_SIZE(compressed_split_modes); k++) {
         for (m = 0; m < TEST_VALUE_COUNT; m++) {
-          grpc_slice slice = create_test_value(m);
-          assert_passthrough(slice, i, j, k, get_compressability(m, i));
+          grpc_slice slice = create_test_value(static_cast<test_value>(m));
+          assert_passthrough(
+              slice, static_cast<grpc_message_compression_algorithm>(i),
+              static_cast<grpc_slice_split_mode>(j),
+              static_cast<grpc_slice_split_mode>(k),
+              get_compressability(
+                  static_cast<test_value>(m),
+                  static_cast<grpc_message_compression_algorithm>(i)));
           grpc_slice_unref(slice);
         }
       }
diff --git a/test/core/compression/stream_compression_test.c b/test/core/compression/stream_compression_test.cc
index 568f9f5f6a..7cb583b88d 100644
--- a/test/core/compression/stream_compression_test.c
+++ b/test/core/compression/stream_compression_test.cc
@@ -134,7 +134,8 @@ test_stream_compression_simple_compress_decompress_with_output_size_constraint()
 #define LARGE_DATA_SIZE (1024 * 1024)
 static void
 test_stream_compression_simple_compress_decompress_with_large_data() {
-  char* test_str = gpr_malloc(LARGE_DATA_SIZE * sizeof(char));
+  char* test_str =
+      static_cast<char*>(gpr_malloc(LARGE_DATA_SIZE * sizeof(char)));
   generate_random_payload(test_str, LARGE_DATA_SIZE);
   grpc_slice_buffer source, relay, sink;
   grpc_slice_buffer_init(&source);