Merge with master

5 files changed, 88 insertions, 68 deletions

diff --git a/test/core/compression/BUILD b/test/core/compression/BUILD
index 1ab6e35f0d..ee71eecfeb 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 9a771d9494..dea8e33030 100644
--- a/test/core/compression/algorithm_test.c
+++ b/test/core/compression/algorithm_test.cc
@@ -35,11 +35,11 @@ static void test_algorithm_mesh(void) {
   gpr_log(GPR_DEBUG, "test_algorithm_mesh");
 
   for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
-    const char *name;
+    const char* name;
     grpc_compression_algorithm parsed;
     grpc_slice mdstr;
     grpc_mdelem mdelem;
-    exec_ctx = GRPC_EXEC_CTX_INIT;
+    ExecCtx _local_exec_ctx;
     GPR_ASSERT(
         grpc_compression_algorithm_name((grpc_compression_algorithm)i, &name));
     GPR_ASSERT(grpc_compression_algorithm_parse(
@@ -62,15 +62,17 @@ static void test_algorithm_mesh(void) {
 }
 
 static void test_algorithm_failure(void) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   grpc_slice mdstr;
 
   gpr_log(GPR_DEBUG, "test_algorithm_failure");
 
   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);
@@ -78,13 +80,14 @@ 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(mdstr);
   grpc_exec_ctx_finish();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
 
diff --git a/test/core/compression/compression_test.c b/test/core/compression/compression_test.cc
index 326a800300..a1a9441c8d 100644
--- a/test/core/compression/compression_test.c
+++ b/test/core/compression/compression_test.cc
@@ -28,15 +28,15 @@
 
 static void test_compression_algorithm_parse(void) {
   size_t i;
-  const char *valid_names[] = {"identity", "gzip", "deflate"};
+  const char* valid_names[] = {"identity", "gzip", "deflate"};
   const grpc_compression_algorithm valid_algorithms[] = {
       GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE};
-  const char *invalid_names[] = {"gzip2", "foo", "", "2gzip"};
+  const char* invalid_names[] = {"gzip2", "foo", "", "2gzip"};
 
   gpr_log(GPR_DEBUG, "test_compression_algorithm_parse");
 
   for (i = 0; i < GPR_ARRAY_SIZE(valid_names); i++) {
-    const char *valid_name = valid_names[i];
+    const char* valid_name = valid_names[i];
     grpc_compression_algorithm algorithm;
     const int success = grpc_compression_algorithm_parse(
         grpc_slice_from_static_string(valid_name), &algorithm);
@@ -45,7 +45,7 @@ static void test_compression_algorithm_parse(void) {
   }
 
   for (i = 0; i < GPR_ARRAY_SIZE(invalid_names); i++) {
-    const char *invalid_name = invalid_names[i];
+    const char* invalid_name = invalid_names[i];
     grpc_compression_algorithm algorithm;
     int success;
     success = grpc_compression_algorithm_parse(
@@ -57,9 +57,9 @@ static void test_compression_algorithm_parse(void) {
 
 static void test_compression_algorithm_name(void) {
   int success;
-  const char *name;
+  const char* name;
   size_t i;
-  const char *valid_names[] = {"identity", "gzip", "deflate"};
+  const char* valid_names[] = {"identity", "gzip", "deflate"};
   const grpc_compression_algorithm valid_algorithms[] = {
       GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE};
 
@@ -181,28 +181,34 @@ 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);
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_init();
   test_compression_algorithm_parse();
   test_compression_algorithm_name();
diff --git a/test/core/compression/message_compress_test.c b/test/core/compression/message_compress_test.cc
index 641e8f8900..d642e056d8 100644
--- a/test/core/compression/message_compress_test.c
+++ b/test/core/compression/message_compress_test.cc
@@ -49,17 +49,18 @@ static void assert_passthrough(grpc_slice value,
   grpc_slice_buffer output;
   grpc_slice final;
   int was_compressed;
-  const char *algorithm_name;
+  const char* algorithm_name;
 
   GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algorithm_name) != 0);
-  gpr_log(
-      GPR_INFO, "assert_passthrough: value_length=%" PRIuPTR
-                " value_hash=0x%08x "
-                "algorithm='%s' uncompressed_split='%s' compressed_split='%s'",
-      GRPC_SLICE_LENGTH(value), gpr_murmur_hash3(GRPC_SLICE_START_PTR(value),
-                                                 GRPC_SLICE_LENGTH(value), 0),
-      algorithm_name, grpc_slice_split_mode_name(uncompressed_split_mode),
-      grpc_slice_split_mode_name(compressed_split_mode));
+  gpr_log(GPR_INFO,
+          "assert_passthrough: value_length=%" PRIuPTR
+          " value_hash=0x%08x "
+          "algorithm='%s' uncompressed_split='%s' compressed_split='%s'",
+          GRPC_SLICE_LENGTH(value),
+          gpr_murmur_hash3(GRPC_SLICE_START_PTR(value),
+                           GRPC_SLICE_LENGTH(value), 0),
+          algorithm_name, grpc_slice_split_mode_name(uncompressed_split_mode),
+          grpc_slice_split_mode_name(compressed_split_mode));
 
   grpc_slice_buffer_init(&input);
   grpc_slice_buffer_init(&compressed_raw);
@@ -69,7 +70,7 @@ static void assert_passthrough(grpc_slice value,
   grpc_split_slices_to_buffer(uncompressed_split_mode, &value, 1, &input);
 
   {
-    exec_ctx = GRPC_EXEC_CTX_INIT;
+    ExecCtx _local_exec_ctx;
     was_compressed = grpc_msg_compress(algorithm, &input, &compressed_raw);
     grpc_exec_ctx_finish();
   }
@@ -90,7 +91,7 @@ static void assert_passthrough(grpc_slice value,
   grpc_split_slice_buffer(compressed_split_mode, &compressed_raw, &compressed);
 
   {
-    exec_ctx = GRPC_EXEC_CTX_INIT;
+    ExecCtx _local_exec_ctx;
     GPR_ASSERT(grpc_msg_decompress(
         was_compressed ? algorithm : GRPC_COMPRESS_NONE, &compressed, &output));
     grpc_exec_ctx_finish();
@@ -146,16 +147,17 @@ 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_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_COMPRESS_ALGORITHMS_COUNT; i++) {
+  for (int i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
     if (i == GRPC_COMPRESS_NONE) continue;
-    exec_ctx = GRPC_EXEC_CTX_INIT;
-    GPR_ASSERT(0 == grpc_msg_compress(i, &input, &output));
+    ExecCtx _local_exec_ctx;
+    GPR_ASSERT(0 ==
+               grpc_msg_compress(static_cast<grpc_compression_algorithm>(i),
+                                 &input, &output));
     grpc_exec_ctx_finish();
     GPR_ASSERT(1 == output.count);
   }
@@ -176,7 +178,7 @@ static void test_bad_decompression_data_crc(void) {
   grpc_slice_buffer_init(&output);
   grpc_slice_buffer_add(&input, create_test_value(ONE_MB_A));
 
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   /* compress it */
   grpc_msg_compress(GRPC_COMPRESS_GZIP, &input, &corrupted);
   /* corrupt the output by smashing the CRC */
@@ -206,7 +208,7 @@ static void test_bad_decompression_data_trailing_garbage(void) {
                   "\x78\xda\x63\x60\x60\x60\x00\x00\x00\x04\x00\x01\x99", 13));
 
   /* try (and fail) to decompress the invalid compresed buffer */
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   GPR_ASSERT(0 == grpc_msg_decompress(GRPC_COMPRESS_DEFLATE, &input, &output));
   grpc_exec_ctx_finish();
 
@@ -224,7 +226,7 @@ static void test_bad_decompression_data_stream(void) {
                         grpc_slice_from_copied_buffer("\x78\xda\xff\xff", 4));
 
   /* try (and fail) to decompress the invalid compresed buffer */
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   GPR_ASSERT(0 == grpc_msg_decompress(GRPC_COMPRESS_DEFLATE, &input, &output));
   grpc_exec_ctx_finish();
 
@@ -242,13 +244,14 @@ static void test_bad_compression_algorithm(void) {
   grpc_slice_buffer_add(
       &input, grpc_slice_from_copied_string("Never gonna give you up"));
 
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   was_compressed =
       grpc_msg_compress(GRPC_COMPRESS_ALGORITHMS_COUNT, &input, &output);
   GPR_ASSERT(0 == was_compressed);
 
-  was_compressed =
-      grpc_msg_compress(GRPC_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output);
+  was_compressed = grpc_msg_compress(static_cast<grpc_compression_algorithm>(
+                                         GRPC_COMPRESS_ALGORITHMS_COUNT + 123),
+                                     &input, &output);
   GPR_ASSERT(0 == was_compressed);
   grpc_exec_ctx_finish();
 
@@ -266,13 +269,15 @@ static void test_bad_decompression_algorithm(void) {
   grpc_slice_buffer_add(&input,
                         grpc_slice_from_copied_string(
                             "I'm not really compressed but it doesn't matter"));
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   was_decompressed =
       grpc_msg_decompress(GRPC_COMPRESS_ALGORITHMS_COUNT, &input, &output);
   GPR_ASSERT(0 == was_decompressed);
 
-  was_decompressed = grpc_msg_decompress(GRPC_COMPRESS_ALGORITHMS_COUNT + 123,
-                                         &input, &output);
+  was_decompressed =
+      grpc_msg_decompress(static_cast<grpc_compression_algorithm>(
+                              GRPC_COMPRESS_ALGORITHMS_COUNT + 123),
+                          &input, &output);
   GPR_ASSERT(0 == was_decompressed);
   grpc_exec_ctx_finish();
 
@@ -280,7 +285,7 @@ static void test_bad_decompression_algorithm(void) {
   grpc_slice_buffer_destroy(&output);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   unsigned i, j, k, m;
   grpc_slice_split_mode uncompressed_split_modes[] = {
       GRPC_SLICE_SPLIT_IDENTITY, GRPC_SLICE_SPLIT_ONE_BYTE};
@@ -295,8 +300,13 @@ 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_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_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 afed6cd6b5..7cb583b88d 100644
--- a/test/core/compression/stream_compression_test.c
+++ b/test/core/compression/stream_compression_test.cc
@@ -25,7 +25,7 @@
 
 #include "src/core/lib/compression/stream_compression.h"
 
-static void generate_random_payload(char *payload, size_t size) {
+static void generate_random_payload(char* payload, size_t size) {
   size_t i;
   static const char chars[] = "abcdefghijklmnopqrstuvwxyz1234567890";
   for (i = 0; i < size - 1; ++i) {
@@ -34,8 +34,8 @@ static void generate_random_payload(char *payload, size_t size) {
   payload[size - 1] = '\0';
 }
 
-static bool slice_buffer_equals_string(grpc_slice_buffer *buf,
-                                       const char *str) {
+static bool slice_buffer_equals_string(grpc_slice_buffer* buf,
+                                       const char* str) {
   size_t i;
   if (buf->length != strlen(str)) {
     return false;
@@ -43,8 +43,8 @@ static bool slice_buffer_equals_string(grpc_slice_buffer *buf,
   size_t pointer = 0;
   for (i = 0; i < buf->count; i++) {
     size_t slice_len = GRPC_SLICE_LENGTH(buf->slices[i]);
-    if (0 != strncmp(str + pointer,
-                     (char *)GRPC_SLICE_START_PTR(buf->slices[i]), slice_len)) {
+    if (0 != strncmp(str + pointer, (char*)GRPC_SLICE_START_PTR(buf->slices[i]),
+                     slice_len)) {
       return false;
     }
     pointer += slice_len;
@@ -58,10 +58,10 @@ static void test_stream_compression_simple_compress_decompress() {
   grpc_slice_buffer_init(&source);
   grpc_slice_buffer_init(&relay);
   grpc_slice_buffer_init(&sink);
-  grpc_stream_compression_context *compress_ctx =
+  grpc_stream_compression_context* compress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_COMPRESS);
-  grpc_stream_compression_context *decompress_ctx =
+  grpc_stream_compression_context* decompress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
   grpc_slice slice = grpc_slice_from_static_string(test_str);
@@ -91,10 +91,10 @@ test_stream_compression_simple_compress_decompress_with_output_size_constraint()
   grpc_slice_buffer_init(&source);
   grpc_slice_buffer_init(&relay);
   grpc_slice_buffer_init(&sink);
-  grpc_stream_compression_context *compress_ctx =
+  grpc_stream_compression_context* compress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_COMPRESS);
-  grpc_stream_compression_context *decompress_ctx =
+  grpc_stream_compression_context* decompress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
   grpc_slice slice = grpc_slice_from_static_string(test_str);
@@ -112,7 +112,7 @@ test_stream_compression_simple_compress_decompress_with_output_size_constraint()
   GPR_ASSERT(output_size == max_output_size);
   GPR_ASSERT(end_of_context == false);
   grpc_slice slice_recv = grpc_slice_buffer_take_first(&sink);
-  char *str_recv = (char *)GRPC_SLICE_START_PTR(slice_recv);
+  char* str_recv = (char*)GRPC_SLICE_START_PTR(slice_recv);
   GPR_ASSERT(GRPC_SLICE_LENGTH(slice_recv) == max_output_size);
   GPR_ASSERT(0 == strncmp(test_str, str_recv, max_output_size));
   grpc_slice_unref(slice_recv);
@@ -134,16 +134,17 @@ 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);
   grpc_slice_buffer_init(&relay);
   grpc_slice_buffer_init(&sink);
-  grpc_stream_compression_context *compress_ctx =
+  grpc_stream_compression_context* compress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_COMPRESS);
-  grpc_stream_compression_context *decompress_ctx =
+  grpc_stream_compression_context* decompress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
   grpc_slice slice = grpc_slice_from_static_string(test_str);
@@ -174,7 +175,7 @@ static void test_stream_compression_drop_context() {
   grpc_slice_buffer_init(&source);
   grpc_slice_buffer_init(&relay);
   grpc_slice_buffer_init(&sink);
-  grpc_stream_compression_context *compress_ctx =
+  grpc_stream_compression_context* compress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_COMPRESS);
   grpc_slice slice = grpc_slice_from_static_string(test_str);
@@ -207,7 +208,7 @@ static void test_stream_compression_drop_context() {
   grpc_slice_unref(slice2);
   grpc_slice_buffer_add(&relay, slice3);
 
-  grpc_stream_compression_context *decompress_ctx =
+  grpc_stream_compression_context* decompress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
   bool end_of_context;
@@ -243,7 +244,7 @@ static void test_stream_compression_sync_flush() {
   grpc_slice_buffer_init(&source);
   grpc_slice_buffer_init(&relay);
   grpc_slice_buffer_init(&sink);
-  grpc_stream_compression_context *compress_ctx =
+  grpc_stream_compression_context* compress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_COMPRESS);
   grpc_slice slice = grpc_slice_from_static_string(test_str);
@@ -252,7 +253,7 @@ static void test_stream_compression_sync_flush() {
                                   ~(size_t)0,
                                   GRPC_STREAM_COMPRESSION_FLUSH_SYNC));
 
-  grpc_stream_compression_context *decompress_ctx =
+  grpc_stream_compression_context* decompress_ctx =
       grpc_stream_compression_context_create(
           GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS);
   bool end_of_context;
@@ -284,7 +285,7 @@ static void test_stream_compression_sync_flush() {
   grpc_slice_buffer_destroy(&sink);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_init();
   test_stream_compression_simple_compress_decompress();
   test_stream_compression_simple_compress_decompress_with_output_size_constraint();