Merge with master

21 files changed, 421 insertions, 505 deletions

diff --git a/test/core/transport/BUILD b/test/core/transport/BUILD
index ea5e577bd8..b31d4ff899 100644
--- a/test/core/transport/BUILD
+++ b/test/core/transport/BUILD
@@ -35,8 +35,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "byte_stream_test",
-    srcs = ["byte_stream_test.c"],
-    language = "C",
+    srcs = ["byte_stream_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -47,8 +47,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "connectivity_state_test",
-    srcs = ["connectivity_state_test.c"],
-    language = "C",
+    srcs = ["connectivity_state_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -59,8 +59,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "metadata_test",
-    srcs = ["metadata_test.c"],
-    language = "C",
+    srcs = ["metadata_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -71,20 +71,23 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "pid_controller_test",
-    srcs = ["pid_controller_test.c"],
-    language = "C",
+    srcs = ["pid_controller_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
         "//test/core/util:gpr_test_util",
         "//test/core/util:grpc_test_util",
     ],
+    external_deps = [
+        "gtest",
+    ],
 )
 
 grpc_cc_test(
     name = "status_conversion_test",
-    srcs = ["status_conversion_test.c"],
-    language = "C",
+    srcs = ["status_conversion_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -95,8 +98,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "stream_owned_slice_test",
-    srcs = ["stream_owned_slice_test.c"],
-    language = "C",
+    srcs = ["stream_owned_slice_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -107,8 +110,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "timeout_encoding_test",
-    srcs = ["timeout_encoding_test.c"],
-    language = "C",
+    srcs = ["timeout_encoding_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/transport/bdp_estimator_test.cc b/test/core/transport/bdp_estimator_test.cc
index cf1b422043..ca29b82616 100644
--- a/test/core/transport/bdp_estimator_test.cc
+++ b/test/core/transport/bdp_estimator_test.cc
@@ -23,97 +23,82 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/useful.h>
+#include <gtest/gtest.h>
 #include <limits.h>
 #include "src/core/lib/iomgr/timer_manager.h"
 #include "src/core/lib/support/string.h"
 #include "test/core/util/test_config.h"
 
-extern gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type);
+extern "C" gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type);
 
-static int g_clock = 0;
+namespace grpc_core {
+namespace testing {
+namespace {
+int g_clock = 0;
 
-static gpr_timespec fake_gpr_now(gpr_clock_type clock_type) {
-  return (gpr_timespec){
-      .tv_sec = g_clock, .tv_nsec = 0, .clock_type = clock_type,
-  };
+gpr_timespec fake_gpr_now(gpr_clock_type clock_type) {
+  gpr_timespec ts;
+  ts.tv_sec = g_clock;
+  ts.tv_nsec = 0;
+  ts.clock_type = clock_type;
+  return ts;
 }
 
-static void inc_time(void) { g_clock += 30; }
+void inc_time(void) { g_clock += 30; }
+}  // namespace
 
-static void test_noop(void) {
-  gpr_log(GPR_INFO, "test_noop");
-  grpc_bdp_estimator est;
-  grpc_bdp_estimator_init(&est, "test");
-}
+TEST(BdpEstimatorTest, NoOp) { BdpEstimator est("test"); }
 
-static void test_get_estimate_no_samples(void) {
-  gpr_log(GPR_INFO, "test_get_estimate_no_samples");
-  grpc_bdp_estimator est;
-  grpc_bdp_estimator_init(&est, "test");
-  int64_t estimate;
-  grpc_bdp_estimator_get_estimate(&est, &estimate);
+TEST(BdpEstimatorTest, EstimateBdpNoSamples) {
+  BdpEstimator est("test");
+  est.EstimateBdp();
 }
 
-static void add_samples(grpc_bdp_estimator *estimator, int64_t *samples,
-                        size_t n) {
-  grpc_bdp_estimator_add_incoming_bytes(estimator, 1234567);
+namespace {
+void AddSamples(BdpEstimator* estimator, int64_t* samples, size_t n) {
+  estimator->AddIncomingBytes(1234567);
   inc_time();
-
-  GPR_ASSERT(grpc_bdp_estimator_need_ping(estimator) == true);
-  grpc_bdp_estimator_schedule_ping(estimator);
-  grpc_bdp_estimator_start_ping(estimator);
-
+  ExecCtx _local_exec_ctx;
+  estimator->SchedulePing();
+  estimator->StartPing();
   for (size_t i = 0; i < n; i++) {
-    grpc_bdp_estimator_add_incoming_bytes(estimator, samples[i]);
-    GPR_ASSERT(grpc_bdp_estimator_need_ping(estimator) == false);
+    estimator->AddIncomingBytes(samples[i]);
   }
   gpr_sleep_until(gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
                                gpr_time_from_millis(1, GPR_TIMESPAN)));
-  grpc_bdp_estimator_complete_ping(estimator);
+  grpc_exec_ctx_invalidate_now();
+  estimator->CompletePing();
   grpc_exec_ctx_finish();
 }
 
-static void add_sample(grpc_bdp_estimator *estimator, int64_t sample) {
-  add_samples(estimator, &sample, 1);
-}
-
-static void test_get_estimate_1_sample(void) {
-  gpr_log(GPR_INFO, "test_get_estimate_1_sample");
-  grpc_bdp_estimator est;
-  grpc_bdp_estimator_init(&est, "test");
-  add_sample(&est, 100);
-  int64_t estimate;
-  grpc_bdp_estimator_get_estimate(&est, &estimate);
+void AddSample(BdpEstimator* estimator, int64_t sample) {
+  AddSamples(estimator, &sample, 1);
 }
+}  // namespace
 
-static void test_get_estimate_2_samples(void) {
-  gpr_log(GPR_INFO, "test_get_estimate_2_samples");
-  grpc_bdp_estimator est;
-  grpc_bdp_estimator_init(&est, "test");
-  add_sample(&est, 100);
-  add_sample(&est, 100);
-  int64_t estimate;
-  grpc_bdp_estimator_get_estimate(&est, &estimate);
+TEST(BdpEstimatorTest, GetEstimate1Sample) {
+  BdpEstimator est("test");
+  AddSample(&est, 100);
+  est.EstimateBdp();
 }
 
-static int64_t get_estimate(grpc_bdp_estimator *estimator) {
-  int64_t out;
-  GPR_ASSERT(grpc_bdp_estimator_get_estimate(estimator, &out));
-  return out;
+TEST(BdpEstimatorTest, GetEstimate2Samples) {
+  BdpEstimator est("test");
+  AddSample(&est, 100);
+  AddSample(&est, 100);
+  est.EstimateBdp();
 }
 
-static void test_get_estimate_3_samples(void) {
-  gpr_log(GPR_INFO, "test_get_estimate_3_samples");
-  grpc_bdp_estimator est;
-  grpc_bdp_estimator_init(&est, "test");
-  add_sample(&est, 100);
-  add_sample(&est, 100);
-  add_sample(&est, 100);
-  int64_t estimate;
-  grpc_bdp_estimator_get_estimate(&est, &estimate);
+TEST(BdpEstimatorTest, GetEstimate3Samples) {
+  BdpEstimator est("test");
+  AddSample(&est, 100);
+  AddSample(&est, 100);
+  AddSample(&est, 100);
+  est.EstimateBdp();
 }
 
-static int64_t next_pow_2(int64_t v) {
+namespace {
+int64_t NextPow2(int64_t v) {
   v--;
   v |= v >> 1;
   v |= v >> 2;
@@ -124,40 +109,41 @@ static int64_t next_pow_2(int64_t v) {
   v++;
   return v;
 }
+}  // namespace
 
-static void test_get_estimate_random_values(size_t n) {
-  gpr_log(GPR_INFO, "test_get_estimate_random_values(%" PRIdPTR ")", n);
-  grpc_bdp_estimator est;
-  grpc_bdp_estimator_init(&est, "test");
+class BdpEstimatorRandomTest : public ::testing::TestWithParam<size_t> {};
+
+TEST_P(BdpEstimatorRandomTest, GetEstimateRandomValues) {
+  BdpEstimator est("test");
   const int kMaxSample = 65535;
   int min = kMaxSample;
   int max = 0;
-  for (size_t i = 0; i < n; i++) {
+  for (size_t i = 0; i < GetParam(); i++) {
     int sample = rand() % (kMaxSample + 1);
     if (sample < min) min = sample;
     if (sample > max) max = sample;
-    add_sample(&est, sample);
+    AddSample(&est, sample);
     if (i >= 3) {
-      gpr_log(GPR_DEBUG, "est:%" PRId64 " min:%d max:%d", get_estimate(&est),
-              min, max);
-      GPR_ASSERT(get_estimate(&est) <= GPR_MAX(65536, 2 * next_pow_2(max)));
+      EXPECT_LE(est.EstimateBdp(), GPR_MAX(65536, 2 * NextPow2(max)))
+          << " min:" << min << " max:" << max << " sample:" << sample;
     }
   }
 }
 
-int main(int argc, char **argv) {
+INSTANTIATE_TEST_CASE_P(TooManyNames, BdpEstimatorRandomTest,
+                        ::testing::Values(3, 4, 6, 9, 13, 19, 28, 42, 63, 94,
+                                          141, 211, 316, 474, 711));
+
+}  // namespace testing
+}  // namespace grpc_core
+
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
-  gpr_now_impl = fake_gpr_now;
+  gpr_now_impl = grpc_core::testing::fake_gpr_now;
   grpc_init();
   grpc_timer_manager_set_threading(false);
-  test_noop();
-  test_get_estimate_no_samples();
-  test_get_estimate_1_sample();
-  test_get_estimate_2_samples();
-  test_get_estimate_3_samples();
-  for (size_t i = 3; i < 1000; i = i * 3 / 2) {
-    test_get_estimate_random_values(i);
-  }
+  ::testing::InitGoogleTest(&argc, argv);
+  int ret = RUN_ALL_TESTS();
   grpc_shutdown();
-  return 0;
+  return ret;
 }
diff --git a/test/core/transport/byte_stream_test.c b/test/core/transport/byte_stream_test.cc
index 3516c191e2..af6abaeeed 100644
--- a/test/core/transport/byte_stream_test.c
+++ b/test/core/transport/byte_stream_test.cc
@@ -30,13 +30,13 @@
 // grpc_slice_buffer_stream tests
 //
 
-static void not_called_closure(void *arg, grpc_error *error) {
+static void not_called_closure(void* arg, grpc_error* error) {
   GPR_ASSERT(false);
 }
 
 static void test_slice_buffer_stream_basic(void) {
   gpr_log(GPR_DEBUG, "test_slice_buffer_stream_basic");
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   // Create and populate slice buffer.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -58,7 +58,7 @@ static void test_slice_buffer_stream_basic(void) {
   for (size_t i = 0; i < GPR_ARRAY_SIZE(input); ++i) {
     GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
     grpc_slice output;
-    grpc_error *error = grpc_byte_stream_pull(&stream.base, &output);
+    grpc_error* error = grpc_byte_stream_pull(&stream.base, &output);
     GPR_ASSERT(error == GRPC_ERROR_NONE);
     GPR_ASSERT(grpc_slice_eq(input[i], output));
     grpc_slice_unref_internal(output);
@@ -71,7 +71,7 @@ static void test_slice_buffer_stream_basic(void) {
 
 static void test_slice_buffer_stream_shutdown(void) {
   gpr_log(GPR_DEBUG, "test_slice_buffer_stream_shutdown");
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   // Create and populate slice buffer.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -92,12 +92,12 @@ static void test_slice_buffer_stream_shutdown(void) {
   // Read the first slice.
   GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
   grpc_slice output;
-  grpc_error *error = grpc_byte_stream_pull(&stream.base, &output);
+  grpc_error* error = grpc_byte_stream_pull(&stream.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[0], output));
   grpc_slice_unref_internal(output);
   // Now shutdown.
-  grpc_error *shutdown_error =
+  grpc_error* shutdown_error =
       GRPC_ERROR_CREATE_FROM_STATIC_STRING("shutdown error");
   grpc_byte_stream_shutdown(&stream.base, GRPC_ERROR_REF(shutdown_error));
   // After shutdown, the next pull() should return the error.
@@ -118,7 +118,7 @@ static void test_slice_buffer_stream_shutdown(void) {
 
 static void test_caching_byte_stream_basic(void) {
   gpr_log(GPR_DEBUG, "test_caching_byte_stream_basic");
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   // Create and populate slice buffer byte stream.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -144,7 +144,7 @@ static void test_caching_byte_stream_basic(void) {
   for (size_t i = 0; i < GPR_ARRAY_SIZE(input); ++i) {
     GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
     grpc_slice output;
-    grpc_error *error = grpc_byte_stream_pull(&stream.base, &output);
+    grpc_error* error = grpc_byte_stream_pull(&stream.base, &output);
     GPR_ASSERT(error == GRPC_ERROR_NONE);
     GPR_ASSERT(grpc_slice_eq(input[i], output));
     grpc_slice_unref_internal(output);
@@ -158,7 +158,7 @@ static void test_caching_byte_stream_basic(void) {
 
 static void test_caching_byte_stream_reset(void) {
   gpr_log(GPR_DEBUG, "test_caching_byte_stream_reset");
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   // Create and populate slice buffer byte stream.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -182,7 +182,7 @@ static void test_caching_byte_stream_reset(void) {
   // Read one slice.
   GPR_ASSERT(grpc_byte_stream_next(&stream.base, ~(size_t)0, &closure));
   grpc_slice output;
-  grpc_error *error = grpc_byte_stream_pull(&stream.base, &output);
+  grpc_error* error = grpc_byte_stream_pull(&stream.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[0], output));
   grpc_slice_unref_internal(output);
@@ -205,7 +205,7 @@ static void test_caching_byte_stream_reset(void) {
 
 static void test_caching_byte_stream_shared_cache(void) {
   gpr_log(GPR_DEBUG, "test_caching_byte_stream_shared_cache");
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   // Create and populate slice buffer byte stream.
   grpc_slice_buffer buffer;
   grpc_slice_buffer_init(&buffer);
@@ -231,7 +231,7 @@ static void test_caching_byte_stream_shared_cache(void) {
   // Read one slice from stream1.
   GPR_ASSERT(grpc_byte_stream_next(&stream1.base, ~(size_t)0, &closure));
   grpc_slice output;
-  grpc_error *error = grpc_byte_stream_pull(&stream1.base, &output);
+  grpc_error* error = grpc_byte_stream_pull(&stream1.base, &output);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(grpc_slice_eq(input[0], output));
   grpc_slice_unref_internal(output);
@@ -257,7 +257,7 @@ static void test_caching_byte_stream_shared_cache(void) {
   grpc_exec_ctx_finish();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_slice_buffer_stream_basic();
   test_slice_buffer_stream_shutdown();
diff --git a/test/core/transport/chttp2/BUILD b/test/core/transport/chttp2/BUILD
index 6081940243..1ea7d0341d 100644
--- a/test/core/transport/chttp2/BUILD
+++ b/test/core/transport/chttp2/BUILD
@@ -22,7 +22,7 @@ load("//test/core/util:grpc_fuzzer.bzl", "grpc_fuzzer")
 
 grpc_fuzzer(
     name = "hpack_parser_fuzzer",
-    srcs = ["hpack_parser_fuzzer_test.c"],
+    srcs = ["hpack_parser_fuzzer_test.cc"],
     corpus = "hpack_parser_corpus",
     deps = [
         "//:grpc",
@@ -32,8 +32,8 @@ grpc_fuzzer(
 
 grpc_cc_test(
     name = "alpn_test",
-    srcs = ["alpn_test.c"],
-    language = "C",
+    srcs = ["alpn_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -44,8 +44,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "bin_decoder_test",
-    srcs = ["bin_decoder_test.c"],
-    language = "C",
+    srcs = ["bin_decoder_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -56,8 +56,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "bin_encoder_test",
-    srcs = ["bin_encoder_test.c"],
-    language = "C",
+    srcs = ["bin_encoder_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -68,8 +68,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "hpack_encoder_test",
-    srcs = ["hpack_encoder_test.c"],
-    language = "C",
+    srcs = ["hpack_encoder_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -80,8 +80,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "hpack_parser_test",
-    srcs = ["hpack_parser_test.c"],
-    language = "C",
+    srcs = ["hpack_parser_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -92,8 +92,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "hpack_table_test",
-    srcs = ["hpack_table_test.c"],
-    language = "C",
+    srcs = ["hpack_table_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -104,8 +104,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "stream_map_test",
-    srcs = ["stream_map_test.c"],
-    language = "C",
+    srcs = ["stream_map_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
@@ -116,8 +116,8 @@ grpc_cc_test(
 
 grpc_cc_test(
     name = "varint_test",
-    srcs = ["varint_test.c"],
-    language = "C",
+    srcs = ["varint_test.cc"],
+    language = "C++",
     deps = [
         "//:gpr",
         "//:grpc",
diff --git a/test/core/transport/chttp2/alpn_test.c b/test/core/transport/chttp2/alpn_test.cc
index 72c30c40eb..a43377393e 100644
--- a/test/core/transport/chttp2/alpn_test.c
+++ b/test/core/transport/chttp2/alpn_test.cc
@@ -33,7 +33,7 @@ static void test_alpn_failure(void) {
 
 // First index in ALPN supported version list of a given protocol. Returns a
 // value one beyond the last valid element index if not found.
-static size_t alpn_version_index(const char *version, size_t size) {
+static size_t alpn_version_index(const char* version, size_t size) {
   size_t i;
   for (i = 0; i < grpc_chttp2_num_alpn_versions(); ++i) {
     if (!strncmp(version, grpc_chttp2_get_alpn_version_index(i), size)) {
@@ -48,7 +48,7 @@ static void test_alpn_grpc_before_h2(void) {
   GPR_ASSERT(alpn_version_index("grpc-exp", 8) < alpn_version_index("h2", 2));
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_alpn_success();
   test_alpn_failure();
diff --git a/test/core/transport/chttp2/bin_decoder_test.c b/test/core/transport/chttp2/bin_decoder_test.c
deleted file mode 100644
index 824b756398..0000000000
--- a/test/core/transport/chttp2/bin_decoder_test.c
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "src/core/ext/transport/chttp2/transport/bin_decoder.h"
-
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include "src/core/ext/transport/chttp2/transport/bin_encoder.h"
-#include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
-#include "src/core/lib/support/string.h"
-
-static int all_ok = 1;
-
-static void expect_slice_eq(grpc_slice expected, grpc_slice slice, char *debug,
-                            int line) {
-  if (!grpc_slice_eq(slice, expected)) {
-    char *hs = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    char *he = grpc_dump_slice(expected, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    gpr_log(GPR_ERROR, "FAILED:%d: %s\ngot:  %s\nwant: %s", line, debug, hs,
-            he);
-    gpr_free(hs);
-    gpr_free(he);
-    all_ok = 0;
-  }
-  grpc_slice_unref_internal(expected);
-  grpc_slice_unref_internal(slice);
-}
-
-static grpc_slice base64_encode(const char *s) {
-  grpc_slice ss = grpc_slice_from_copied_string(s);
-  grpc_slice out = grpc_chttp2_base64_encode(ss);
-  grpc_slice_unref_internal(ss);
-  return out;
-}
-
-static grpc_slice base64_decode(const char *s) {
-  grpc_slice ss = grpc_slice_from_copied_string(s);
-  grpc_slice out = grpc_chttp2_base64_decode(ss);
-  grpc_slice_unref_internal(ss);
-  return out;
-}
-
-static grpc_slice base64_decode_with_length(const char *s,
-                                            size_t output_length) {
-  grpc_slice ss = grpc_slice_from_copied_string(s);
-  grpc_slice out = grpc_chttp2_base64_decode_with_length(ss, output_length);
-  grpc_slice_unref_internal(ss);
-  return out;
-}
-
-#define EXPECT_SLICE_EQ(expected, slice)                                    \
-  expect_slice_eq(                                                          \
-      grpc_slice_from_copied_buffer(expected, sizeof(expected) - 1), slice, \
-      #slice, __LINE__);
-
-#define ENCODE_AND_DECODE(s) \
-  EXPECT_SLICE_EQ(           \
-      s, grpc_chttp2_base64_decode_with_length(base64_encode(s), strlen(s)));
-
-int main(int argc, char **argv) {
-  /* ENCODE_AND_DECODE tests grpc_chttp2_base64_decode_with_length(), which
-     takes encoded base64 strings without pad chars, but output length is
-     required. */
-  /* Base64 test vectors from RFC 4648 */
-  ENCODE_AND_DECODE("");
-  ENCODE_AND_DECODE("f");
-  ENCODE_AND_DECODE("foo");
-  ENCODE_AND_DECODE("fo");
-  ENCODE_AND_DECODE("foob");
-  ENCODE_AND_DECODE("fooba");
-  ENCODE_AND_DECODE("foobar");
-
-  ENCODE_AND_DECODE("\xc0\xc1\xc2\xc3\xc4\xc5");
-
-  /* Base64 test vectors from RFC 4648, with pad chars */
-  /* BASE64("") = "" */
-  EXPECT_SLICE_EQ("", base64_decode(""));
-  /* BASE64("f") = "Zg==" */
-  EXPECT_SLICE_EQ("f", base64_decode("Zg=="));
-  /* BASE64("fo") = "Zm8=" */
-  EXPECT_SLICE_EQ("fo", base64_decode("Zm8="));
-  /* BASE64("foo") = "Zm9v" */
-  EXPECT_SLICE_EQ("foo", base64_decode("Zm9v"));
-  /* BASE64("foob") = "Zm9vYg==" */
-  EXPECT_SLICE_EQ("foob", base64_decode("Zm9vYg=="));
-  /* BASE64("fooba") = "Zm9vYmE=" */
-  EXPECT_SLICE_EQ("fooba", base64_decode("Zm9vYmE="));
-  /* BASE64("foobar") = "Zm9vYmFy" */
-  EXPECT_SLICE_EQ("foobar", base64_decode("Zm9vYmFy"));
-
-  EXPECT_SLICE_EQ("\xc0\xc1\xc2\xc3\xc4\xc5", base64_decode("wMHCw8TF"));
-
-  // Test illegal input length in grpc_chttp2_base64_decode
-  EXPECT_SLICE_EQ("", base64_decode("a"));
-  EXPECT_SLICE_EQ("", base64_decode("ab"));
-  EXPECT_SLICE_EQ("", base64_decode("abc"));
-
-  // Test illegal charactors in grpc_chttp2_base64_decode
-  EXPECT_SLICE_EQ("", base64_decode("Zm:v"));
-  EXPECT_SLICE_EQ("", base64_decode("Zm=v"));
-
-  // Test output_length longer than max possible output length in
-  // grpc_chttp2_base64_decode_with_length
-  EXPECT_SLICE_EQ("", base64_decode_with_length("Zg", 2));
-  EXPECT_SLICE_EQ("", base64_decode_with_length("Zm8", 3));
-  EXPECT_SLICE_EQ("", base64_decode_with_length("Zm9v", 4));
-
-  // Test illegal charactors in grpc_chttp2_base64_decode_with_length
-  EXPECT_SLICE_EQ("", base64_decode_with_length("Zm:v", 3));
-  EXPECT_SLICE_EQ("", base64_decode_with_length("Zm=v", 3));
-
-  grpc_exec_ctx_finish();
-
-  return all_ok ? 0 : 1;
-}
diff --git a/test/core/transport/chttp2/bin_decoder_test.cc b/test/core/transport/chttp2/bin_decoder_test.cc
index d426731dae..663ccf189b 100644
--- a/test/core/transport/chttp2/bin_decoder_test.cc
+++ b/test/core/transport/chttp2/bin_decoder_test.cc
@@ -29,11 +29,11 @@
 
 static int all_ok = 1;
 
-static void expect_slice_eq(grpc_slice expected, grpc_slice slice, char *debug,
-                            int line) {
+static void expect_slice_eq(grpc_slice expected, grpc_slice slice,
+                            const char* debug, int line) {
   if (!grpc_slice_eq(slice, expected)) {
-    char *hs = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    char *he = grpc_dump_slice(expected, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* hs = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* he = grpc_dump_slice(expected, GPR_DUMP_HEX | GPR_DUMP_ASCII);
     gpr_log(GPR_ERROR, "FAILED:%d: %s\ngot:  %s\nwant: %s", line, debug, hs,
             he);
     gpr_free(hs);
@@ -44,21 +44,21 @@ static void expect_slice_eq(grpc_slice expected, grpc_slice slice, char *debug,
   grpc_slice_unref_internal(slice);
 }
 
-static grpc_slice base64_encode(const char *s) {
+static grpc_slice base64_encode(const char* s) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
   grpc_slice out = grpc_chttp2_base64_encode(ss);
   grpc_slice_unref_internal(ss);
   return out;
 }
 
-static grpc_slice base64_decode(const char *s) {
+static grpc_slice base64_decode(const char* s) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
   grpc_slice out = grpc_chttp2_base64_decode(ss);
   grpc_slice_unref_internal(ss);
   return out;
 }
 
-static grpc_slice base64_decode_with_length(const char *s,
+static grpc_slice base64_decode_with_length(const char* s,
                                             size_t output_length) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
   grpc_slice out = grpc_chttp2_base64_decode_with_length(ss, output_length);
@@ -66,16 +66,16 @@ static grpc_slice base64_decode_with_length(const char *s,
   return out;
 }
 
-#define EXPECT_SLICE_EQ(expected, slice)                                       \
-  expect_slice_eq(                                                             \
-      exec_ctx, grpc_slice_from_copied_buffer(expected, sizeof(expected) - 1), \
-      slice, #slice, __LINE__);
+#define EXPECT_SLICE_EQ(expected, slice)                                    \
+  expect_slice_eq(                                                          \
+      grpc_slice_from_copied_buffer(expected, sizeof(expected) - 1), slice, \
+      #slice, __LINE__);
 
-#define ENCODE_AND_DECODE(s)                                \
-  EXPECT_SLICE_EQ(s, grpc_chttp2_base64_decode_with_length( \
-                         exec_ctx, base64_encode(s), strlen(s)));
+#define ENCODE_AND_DECODE(s) \
+  EXPECT_SLICE_EQ(           \
+      s, grpc_chttp2_base64_decode_with_length(base64_encode(s), strlen(s)));
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   ExecCtx _local_exec_ctx;
 
   /* ENCODE_AND_DECODE tests grpc_chttp2_base64_decode_with_length(), which
diff --git a/test/core/transport/chttp2/bin_encoder_test.c b/test/core/transport/chttp2/bin_encoder_test.cc
index acadcf6c89..78b8808c41 100644
--- a/test/core/transport/chttp2/bin_encoder_test.c
+++ b/test/core/transport/chttp2/bin_encoder_test.cc
@@ -31,11 +31,11 @@
 
 static int all_ok = 1;
 
-static void expect_slice_eq(grpc_slice expected, grpc_slice slice, char *debug,
-                            int line) {
+static void expect_slice_eq(grpc_slice expected, grpc_slice slice,
+                            const char* debug, int line) {
   if (!grpc_slice_eq(slice, expected)) {
-    char *hs = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    char *he = grpc_dump_slice(expected, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* hs = grpc_dump_slice(slice, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* he = grpc_dump_slice(expected, GPR_DUMP_HEX | GPR_DUMP_ASCII);
     gpr_log(GPR_ERROR, "FAILED:%d: %s\ngot:  %s\nwant: %s", line, debug, hs,
             he);
     gpr_free(hs);
@@ -46,14 +46,14 @@ static void expect_slice_eq(grpc_slice expected, grpc_slice slice, char *debug,
   grpc_slice_unref(slice);
 }
 
-static grpc_slice B64(const char *s) {
+static grpc_slice B64(const char* s) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
   grpc_slice out = grpc_chttp2_base64_encode(ss);
   grpc_slice_unref(ss);
   return out;
 }
 
-static grpc_slice HUFF(const char *s) {
+static grpc_slice HUFF(const char* s) {
   grpc_slice ss = grpc_slice_from_copied_string(s);
   grpc_slice out = grpc_chttp2_huffman_compress(ss);
   grpc_slice_unref(ss);
@@ -65,15 +65,15 @@ static grpc_slice HUFF(const char *s) {
       grpc_slice_from_copied_buffer(expected, sizeof(expected) - 1), slice, \
       #slice, __LINE__);
 
-static void expect_combined_equiv(const char *s, size_t len, int line) {
+static void expect_combined_equiv(const char* s, size_t len, int line) {
   grpc_slice input = grpc_slice_from_copied_buffer(s, len);
   grpc_slice base64 = grpc_chttp2_base64_encode(input);
   grpc_slice expect = grpc_chttp2_huffman_compress(base64);
   grpc_slice got = grpc_chttp2_base64_encode_and_huffman_compress(input);
   if (!grpc_slice_eq(expect, got)) {
-    char *t = grpc_dump_slice(input, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    char *e = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    char *g = grpc_dump_slice(got, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* t = grpc_dump_slice(input, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* e = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* g = grpc_dump_slice(got, GPR_DUMP_HEX | GPR_DUMP_ASCII);
     gpr_log(GPR_ERROR, "FAILED:%d:\ntest: %s\ngot:  %s\nwant: %s", line, t, g,
             e);
     gpr_free(t);
@@ -90,7 +90,7 @@ static void expect_combined_equiv(const char *s, size_t len, int line) {
 #define EXPECT_COMBINED_EQUIV(x) \
   expect_combined_equiv(x, sizeof(x) - 1, __LINE__)
 
-static void expect_binary_header(const char *hdr, int binary) {
+static void expect_binary_header(const char* hdr, int binary) {
   if (grpc_is_binary_header(grpc_slice_from_static_string(hdr)) != binary) {
     gpr_log(GPR_ERROR, "FAILED: expected header '%s' to be %s", hdr,
             binary ? "binary" : "not binary");
@@ -98,7 +98,7 @@ static void expect_binary_header(const char *hdr, int binary) {
   }
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   /* Base64 test vectors from RFC 4648, with padding removed */
   /* BASE64("") = "" */
   EXPECT_SLICE_EQ("", B64(""));
diff --git a/test/core/transport/chttp2/hpack_encoder_test.c b/test/core/transport/chttp2/hpack_encoder_test.cc
index f3690fc410..e1bfcc5b37 100644
--- a/test/core/transport/chttp2/hpack_encoder_test.c
+++ b/test/core/transport/chttp2/hpack_encoder_test.cc
@@ -39,36 +39,45 @@
 grpc_chttp2_hpack_compressor g_compressor;
 int g_failure = 0;
 
-void **to_delete = NULL;
+void** to_delete = NULL;
 size_t num_to_delete = 0;
 size_t cap_to_delete = 0;
 
+typedef struct {
+  bool eof;
+  bool use_true_binary_metadata;
+  bool only_intern_key;
+} verify_params;
+
 /* verify that the output generated by encoding the stream matches the
    hexstring passed in */
-static void verify(size_t window_available, bool eof,
-                   bool use_true_binary_metadata, size_t expect_window_used,
-                   const char *expected, size_t nheaders, ...) {
+static void verify(const verify_params params, const char* expected,
+                   size_t nheaders, ...) {
   grpc_slice_buffer output;
   grpc_slice merged;
   grpc_slice expect = parse_hexstring(expected);
   size_t i;
   va_list l;
-  grpc_linked_mdelem *e = gpr_malloc(sizeof(*e) * nheaders);
+  grpc_linked_mdelem* e =
+      static_cast<grpc_linked_mdelem*>(gpr_malloc(sizeof(*e) * nheaders));
   grpc_metadata_batch b;
 
   grpc_metadata_batch_init(&b);
 
   va_start(l, nheaders);
   for (i = 0; i < nheaders; i++) {
-    char *key = va_arg(l, char *);
-    char *value = va_arg(l, char *);
+    char* key = va_arg(l, char*);
+    char* value = va_arg(l, char*);
     if (i) {
       e[i - 1].next = &e[i];
       e[i].prev = &e[i - 1];
     }
+    grpc_slice value_slice = grpc_slice_from_static_string(value);
+    if (!params.only_intern_key) {
+      value_slice = grpc_slice_intern(value_slice);
+    }
     e[i].md = grpc_mdelem_from_slices(
-        grpc_slice_intern(grpc_slice_from_static_string(key)),
-        grpc_slice_intern(grpc_slice_from_static_string(value)));
+        grpc_slice_intern(grpc_slice_from_static_string(key)), value_slice);
   }
   e[0].prev = NULL;
   e[nheaders - 1].next = NULL;
@@ -80,7 +89,8 @@ static void verify(size_t window_available, bool eof,
 
   if (cap_to_delete == num_to_delete) {
     cap_to_delete = GPR_MAX(2 * cap_to_delete, 1000);
-    to_delete = gpr_realloc(to_delete, sizeof(*to_delete) * cap_to_delete);
+    to_delete = static_cast<void**>(
+        gpr_realloc(to_delete, sizeof(*to_delete) * cap_to_delete));
   }
   to_delete[num_to_delete++] = e;
 
@@ -89,11 +99,11 @@ static void verify(size_t window_available, bool eof,
   grpc_transport_one_way_stats stats;
   memset(&stats, 0, sizeof(stats));
   grpc_encode_header_options hopt = {
-      .stream_id = 0xdeadbeef,
-      .is_eof = eof,
-      .use_true_binary_metadata = use_true_binary_metadata,
-      .max_frame_size = 16384,
-      .stats = &stats,
+      0xdeadbeef,                      /* stream_id */
+      params.eof,                      /* is_eof */
+      params.use_true_binary_metadata, /* use_true_binary_metadata */
+      16384,                           /* max_frame_size */
+      &stats                           /* stats */
   };
   grpc_chttp2_encode_header(&g_compressor, NULL, 0, &b, &hopt, &output);
   merged = grpc_slice_merge(output.slices, output.count);
@@ -101,8 +111,8 @@ static void verify(size_t window_available, bool eof,
   grpc_metadata_batch_destroy(&b);
 
   if (!grpc_slice_eq(merged, expect)) {
-    char *expect_str = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
-    char *got_str = grpc_dump_slice(merged, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* expect_str = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
+    char* got_str = grpc_dump_slice(merged, GPR_DUMP_HEX | GPR_DUMP_ASCII);
     gpr_log(GPR_ERROR, "mismatched output for %s", expected);
     gpr_log(GPR_ERROR, "EXPECT: %s", expect_str);
     gpr_log(GPR_ERROR, "GOT:    %s", got_str);
@@ -118,28 +128,30 @@ static void verify(size_t window_available, bool eof,
 static void test_basic_headers() {
   int i;
 
-  verify(0, false, false, 0, "000005 0104 deadbeef 40 0161 0161", 1, "a", "a");
-  verify(0, false, false, 0, "000001 0104 deadbeef be", 1, "a", "a");
-  verify(0, false, false, 0, "000001 0104 deadbeef be", 1, "a", "a");
-  verify(0, false, false, 0, "000006 0104 deadbeef be 40 0162 0163", 2, "a",
-         "a", "b", "c");
-  verify(0, false, false, 0, "000002 0104 deadbeef bf be", 2, "a", "a", "b",
-         "c");
-  verify(0, false, false, 0, "000004 0104 deadbeef 7f 00 0164", 1, "a", "d");
+  verify_params params = {
+      false,
+      false,
+      false,
+  };
+  verify(params, "000005 0104 deadbeef 40 0161 0161", 1, "a", "a");
+  verify(params, "000001 0104 deadbeef be", 1, "a", "a");
+  verify(params, "000001 0104 deadbeef be", 1, "a", "a");
+  verify(params, "000006 0104 deadbeef be 40 0162 0163", 2, "a", "a", "b", "c");
+  verify(params, "000002 0104 deadbeef bf be", 2, "a", "a", "b", "c");
+  verify(params, "000004 0104 deadbeef 7f 00 0164", 1, "a", "d");
 
   /* flush out what's there to make a few values look very popular */
   for (i = 0; i < 350; i++) {
-    verify(0, false, false, 0, "000003 0104 deadbeef c0 bf be", 3, "a", "a",
-           "b", "c", "a", "d");
+    verify(params, "000003 0104 deadbeef c0 bf be", 3, "a", "a", "b", "c", "a",
+           "d");
   }
 
-  verify(0, false, false, 0, "000006 0104 deadbeef c0 00 016b 0176", 2, "a",
-         "a", "k", "v");
+  verify(params, "000006 0104 deadbeef c0 00 016b 0176", 2, "a", "a", "k", "v");
   /* this could be 000004 0104 deadbeef 0f 30 0176 also */
-  verify(0, false, false, 0, "000004 0104 deadbeef 0f 2f 0176", 1, "a", "v");
+  verify(params, "000004 0104 deadbeef 0f 2f 0176", 1, "a", "v");
 }
 
-static void encode_int_to_str(int i, char *p) {
+static void encode_int_to_str(int i, char* p) {
   p[0] = (char)('a' + i % 26);
   i /= 26;
   GPR_ASSERT(i < 26);
@@ -150,7 +162,13 @@ static void encode_int_to_str(int i, char *p) {
 static void test_decode_table_overflow() {
   int i;
   char key[3], value[3];
-  char *expect;
+  char* expect;
+
+  verify_params params = {
+      false,
+      false,
+      false,
+  };
 
   for (i = 0; i < 114; i++) {
     encode_int_to_str(i, key);
@@ -170,28 +188,29 @@ static void test_decode_table_overflow() {
     }
 
     if (i > 0) {
-      verify(0, false, false, 0, expect, 2, "aa", "ba", key, value);
+      verify(params, expect, 2, "aa", "ba", key, value);
     } else {
-      verify(0, false, false, 0, expect, 1, key, value);
+      verify(params, expect, 1, key, value);
     }
     gpr_free(expect);
   }
 
   /* if the above passes, then we must have just knocked this pair out of the
      decoder stack, and so we'll be forced to re-encode it */
-  verify(0, false, false, 0, "000007 0104 deadbeef 40 026161 026261", 1, "aa",
-         "ba");
+  verify(params, "000007 0104 deadbeef 40 026161 026261", 1, "aa", "ba");
 }
 
-static void verify_table_size_change_match_elem_size(const char *key,
-                                                     const char *value) {
+static void verify_table_size_change_match_elem_size(const char* key,
+                                                     const char* value,
+                                                     bool use_true_binary) {
   grpc_slice_buffer output;
   grpc_mdelem elem = grpc_mdelem_from_slices(
       grpc_slice_intern(grpc_slice_from_static_string(key)),
       grpc_slice_intern(grpc_slice_from_static_string(value)));
-  size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem);
+  size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem, use_true_binary);
   size_t initial_table_size = g_compressor.table_size;
-  grpc_linked_mdelem *e = gpr_malloc(sizeof(*e));
+  grpc_linked_mdelem* e =
+      static_cast<grpc_linked_mdelem*>(gpr_malloc(sizeof(*e)));
   grpc_metadata_batch b;
   grpc_metadata_batch_init(&b);
   e[0].md = elem;
@@ -204,11 +223,12 @@ static void verify_table_size_change_match_elem_size(const char *key,
 
   grpc_transport_one_way_stats stats;
   memset(&stats, 0, sizeof(stats));
-  grpc_encode_header_options hopt = {.stream_id = 0xdeadbeef,
-                                     .is_eof = false,
-                                     .use_true_binary_metadata = false,
-                                     .max_frame_size = 16384,
-                                     .stats = &stats};
+  grpc_encode_header_options hopt = {
+      0xdeadbeef,      /* stream_id */
+      false,           /* is_eof */
+      use_true_binary, /* use_true_binary_metadata */
+      16384,           /* max_frame_size */
+      &stats /* stats */};
   grpc_chttp2_encode_header(&g_compressor, NULL, 0, &b, &hopt, &output);
   grpc_slice_buffer_destroy_internal(&output);
   grpc_metadata_batch_destroy(&b);
@@ -218,20 +238,33 @@ static void verify_table_size_change_match_elem_size(const char *key,
 }
 
 static void test_encode_header_size() {
-  verify_table_size_change_match_elem_size("hello", "world");
-  verify_table_size_change_match_elem_size("hello-bin", "world");
+  verify_table_size_change_match_elem_size("hello", "world", false);
+  verify_table_size_change_match_elem_size("hello-bin", "world", false);
+  verify_table_size_change_match_elem_size("true-binary-bin",
+                                           "I_am_true_binary_value", true);
 }
 
-static void run_test(void (*test)(), const char *name) {
-  gpr_log(GPR_INFO, "RUN TEST: %s", name);
+static void test_interned_key_indexed() {
+  int i;
+  verify_params params = {false, false, true};
+  verify(params, "000009 0104 deadbeef 40 0161 0162 0f2f 0163", 2, "a", "b",
+         "a", "c");
+  for (i = 0; i < 10; i++) {
+    verify(params, "000008 0104 deadbeef 0f2f 0162 0f2f 0163", 2, "a", "b", "a",
+           "c");
+  }
+}
 
+static void run_test(void (*test)(), const char* name) {
+  gpr_log(GPR_INFO, "RUN TEST: %s", name);
+  ExecCtx _local_exec_ctx;
   grpc_chttp2_hpack_compressor_init(&g_compressor);
   test();
   grpc_chttp2_hpack_compressor_destroy(&g_compressor);
   grpc_exec_ctx_finish();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   size_t i;
   grpc_test_only_set_slice_hash_seed(0);
   grpc_test_init(argc, argv);
@@ -239,6 +272,7 @@ int main(int argc, char **argv) {
   TEST(test_basic_headers);
   TEST(test_decode_table_overflow);
   TEST(test_encode_header_size);
+  TEST(test_interned_key_indexed);
   grpc_shutdown();
   for (i = 0; i < num_to_delete; i++) {
     gpr_free(to_delete[i]);
diff --git a/test/core/transport/chttp2/hpack_parser_fuzzer_test.c b/test/core/transport/chttp2/hpack_parser_fuzzer_test.cc
index 944f81f7c6..d2199ca706 100644
--- a/test/core/transport/chttp2/hpack_parser_fuzzer_test.c
+++ b/test/core/transport/chttp2/hpack_parser_fuzzer_test.cc
@@ -29,15 +29,15 @@
 bool squelch = true;
 bool leak_check = true;
 
-static void onhdr(void *ud, grpc_mdelem md) { GRPC_MDELEM_UNREF(md); }
-static void dont_log(gpr_log_func_args *args) {}
+static void onhdr(void* ud, grpc_mdelem md) { GRPC_MDELEM_UNREF(md); }
+static void dont_log(gpr_log_func_args* args) {}
 
-int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   grpc_test_only_set_slice_hash_seed(0);
   if (squelch) gpr_set_log_function(dont_log);
   grpc_init();
   grpc_chttp2_hpack_parser parser;
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   grpc_chttp2_hpack_parser_init(&parser);
   parser.on_header = onhdr;
   GRPC_ERROR_UNREF(grpc_chttp2_hpack_parser_parse(
diff --git a/test/core/transport/chttp2/hpack_parser_test.c b/test/core/transport/chttp2/hpack_parser_test.cc
index 67b527934e..0a3cbf84ad 100644
--- a/test/core/transport/chttp2/hpack_parser_test.c
+++ b/test/core/transport/chttp2/hpack_parser_test.cc
@@ -28,25 +28,27 @@
 #include "test/core/util/slice_splitter.h"
 #include "test/core/util/test_config.h"
 
-typedef struct { va_list args; } test_checker;
+typedef struct {
+  va_list args;
+} test_checker;
 
-static void onhdr(void *ud, grpc_mdelem md) {
+static void onhdr(void* ud, grpc_mdelem md) {
   const char *ekey, *evalue;
-  test_checker *chk = ud;
-  ekey = va_arg(chk->args, char *);
+  test_checker* chk = static_cast<test_checker*>(ud);
+  ekey = va_arg(chk->args, char*);
   GPR_ASSERT(ekey);
-  evalue = va_arg(chk->args, char *);
+  evalue = va_arg(chk->args, char*);
   GPR_ASSERT(evalue);
   GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDKEY(md), ekey) == 0);
   GPR_ASSERT(grpc_slice_str_cmp(GRPC_MDVALUE(md), evalue) == 0);
   GRPC_MDELEM_UNREF(md);
 }
 
-static void test_vector(grpc_chttp2_hpack_parser *parser,
-                        grpc_slice_split_mode mode, const char *hexstring,
+static void test_vector(grpc_chttp2_hpack_parser* parser,
+                        grpc_slice_split_mode mode, const char* hexstring,
                         ... /* char *key, char *value */) {
   grpc_slice input = parse_hexstring(hexstring);
-  grpc_slice *slices;
+  grpc_slice* slices;
   size_t nslices;
   size_t i;
   test_checker chk;
@@ -60,7 +62,7 @@ static void test_vector(grpc_chttp2_hpack_parser *parser,
   grpc_slice_unref(input);
 
   for (i = 0; i < nslices; i++) {
-    exec_ctx = GRPC_EXEC_CTX_INIT;
+    ExecCtx _local_exec_ctx;
     GPR_ASSERT(grpc_chttp2_hpack_parser_parse(parser, slices[i]) ==
                GRPC_ERROR_NONE);
     grpc_exec_ctx_finish();
@@ -71,14 +73,14 @@ static void test_vector(grpc_chttp2_hpack_parser *parser,
   }
   gpr_free(slices);
 
-  GPR_ASSERT(NULL == va_arg(chk.args, char *));
+  GPR_ASSERT(NULL == va_arg(chk.args, char*));
 
   va_end(chk.args);
 }
 
 static void test_vectors(grpc_slice_split_mode mode) {
   grpc_chttp2_hpack_parser parser;
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
 
   grpc_chttp2_hpack_parser_init(&parser);
   /* D.2.1 */
@@ -206,7 +208,7 @@ static void test_vectors(grpc_slice_split_mode mode) {
   grpc_exec_ctx_finish();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_vectors(GRPC_SLICE_SPLIT_MERGE_ALL);
diff --git a/test/core/transport/chttp2/hpack_table_test.c b/test/core/transport/chttp2/hpack_table_test.cc
index cbb6b1d7a3..68682f1991 100644
--- a/test/core/transport/chttp2/hpack_table_test.c
+++ b/test/core/transport/chttp2/hpack_table_test.cc
@@ -31,20 +31,20 @@
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
 
-static void assert_str(const grpc_chttp2_hptbl *tbl, grpc_slice mdstr,
-                       const char *str) {
+static void assert_str(const grpc_chttp2_hptbl* tbl, grpc_slice mdstr,
+                       const char* str) {
   GPR_ASSERT(grpc_slice_str_cmp(mdstr, str) == 0);
 }
 
-static void assert_index(const grpc_chttp2_hptbl *tbl, uint32_t idx,
-                         const char *key, const char *value) {
+static void assert_index(const grpc_chttp2_hptbl* tbl, uint32_t idx,
+                         const char* key, const char* value) {
   grpc_mdelem md = grpc_chttp2_hptbl_lookup(tbl, idx);
   assert_str(tbl, GRPC_MDKEY(md), key);
   assert_str(tbl, GRPC_MDVALUE(md), value);
 }
 
 static void test_static_lookup(void) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   grpc_chttp2_hptbl tbl;
 
   grpc_chttp2_hptbl_init(&tbl);
@@ -119,12 +119,12 @@ static void test_static_lookup(void) {
 static void test_many_additions(void) {
   grpc_chttp2_hptbl tbl;
   int i;
-  char *key;
-  char *value;
+  char* key;
+  char* value;
 
   LOG_TEST("test_many_additions");
 
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   grpc_chttp2_hptbl_init(&tbl);
 
   for (i = 0; i < 100000; i++) {
@@ -151,10 +151,10 @@ static void test_many_additions(void) {
   grpc_exec_ctx_finish();
 }
 
-static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl *tbl,
-                                                 const char *key,
-                                                 const char *value) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl* tbl,
+                                                 const char* key,
+                                                 const char* value) {
+  ExecCtx _local_exec_ctx;
   grpc_mdelem md = grpc_mdelem_from_slices(
       grpc_slice_from_copied_string(key), grpc_slice_from_copied_string(value));
   grpc_chttp2_hptbl_find_result r = grpc_chttp2_hptbl_find(tbl, md);
@@ -164,7 +164,7 @@ static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl *tbl,
 }
 
 static void test_find(void) {
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   grpc_chttp2_hptbl tbl;
   uint32_t i;
   char buffer[32];
@@ -269,7 +269,7 @@ static void test_find(void) {
   grpc_exec_ctx_finish();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_init();
   test_static_lookup();
diff --git a/test/core/transport/chttp2/stream_map_test.c b/test/core/transport/chttp2/stream_map_test.cc
index ae2583ab84..23a7b3f4c2 100644
--- a/test/core/transport/chttp2/stream_map_test.c
+++ b/test/core/transport/chttp2/stream_map_test.cc
@@ -51,10 +51,10 @@ static void test_double_deletion(void) {
 
   grpc_chttp2_stream_map_init(&map, 8);
   GPR_ASSERT(0 == grpc_chttp2_stream_map_size(&map));
-  grpc_chttp2_stream_map_add(&map, 1, (void *)1);
-  GPR_ASSERT((void *)1 == grpc_chttp2_stream_map_find(&map, 1));
+  grpc_chttp2_stream_map_add(&map, 1, (void*)1);
+  GPR_ASSERT((void*)1 == grpc_chttp2_stream_map_find(&map, 1));
   GPR_ASSERT(1 == grpc_chttp2_stream_map_size(&map));
-  GPR_ASSERT((void *)1 == grpc_chttp2_stream_map_delete(&map, 1));
+  GPR_ASSERT((void*)1 == grpc_chttp2_stream_map_delete(&map, 1));
   GPR_ASSERT(0 == grpc_chttp2_stream_map_size(&map));
   GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 1));
   GPR_ASSERT(NULL == grpc_chttp2_stream_map_delete(&map, 1));
@@ -78,7 +78,7 @@ static void test_basic_add_find(uint32_t n) {
   grpc_chttp2_stream_map_init(&map, 8);
   GPR_ASSERT(0 == grpc_chttp2_stream_map_size(&map));
   for (i = 1; i <= n; i++) {
-    grpc_chttp2_stream_map_add(&map, i, (void *)(uintptr_t)i);
+    grpc_chttp2_stream_map_add(&map, i, (void*)(uintptr_t)i);
   }
   GPR_ASSERT(n == grpc_chttp2_stream_map_size(&map));
   GPR_ASSERT(NULL == grpc_chttp2_stream_map_find(&map, 0));
@@ -91,14 +91,14 @@ static void test_basic_add_find(uint32_t n) {
 }
 
 /* verify that for_each gets the right values during test_delete_evens_XXX */
-static void verify_for_each(void *user_data, uint32_t stream_id, void *ptr) {
-  uint32_t *for_each_check = user_data;
+static void verify_for_each(void* user_data, uint32_t stream_id, void* ptr) {
+  uint32_t* for_each_check = static_cast<uint32_t*>(user_data);
   GPR_ASSERT(ptr);
   GPR_ASSERT(*for_each_check == stream_id);
   *for_each_check += 2;
 }
 
-static void check_delete_evens(grpc_chttp2_stream_map *map, uint32_t n) {
+static void check_delete_evens(grpc_chttp2_stream_map* map, uint32_t n) {
   uint32_t for_each_check = 1;
   uint32_t i;
   size_t got;
@@ -133,12 +133,11 @@ static void test_delete_evens_sweep(uint32_t n) {
 
   grpc_chttp2_stream_map_init(&map, 8);
   for (i = 1; i <= n; i++) {
-    grpc_chttp2_stream_map_add(&map, i, (void *)(uintptr_t)i);
+    grpc_chttp2_stream_map_add(&map, i, (void*)(uintptr_t)i);
   }
   for (i = 1; i <= n; i++) {
     if ((i & 1) == 0) {
-      GPR_ASSERT((void *)(uintptr_t)i ==
-                 grpc_chttp2_stream_map_delete(&map, i));
+      GPR_ASSERT((void*)(uintptr_t)i == grpc_chttp2_stream_map_delete(&map, i));
     }
   }
   check_delete_evens(&map, n);
@@ -156,7 +155,7 @@ static void test_delete_evens_incremental(uint32_t n) {
 
   grpc_chttp2_stream_map_init(&map, 8);
   for (i = 1; i <= n; i++) {
-    grpc_chttp2_stream_map_add(&map, i, (void *)(uintptr_t)i);
+    grpc_chttp2_stream_map_add(&map, i, (void*)(uintptr_t)i);
     if ((i & 1) == 0) {
       grpc_chttp2_stream_map_delete(&map, i);
     }
@@ -178,10 +177,10 @@ static void test_periodic_compaction(uint32_t n) {
   grpc_chttp2_stream_map_init(&map, 16);
   GPR_ASSERT(map.capacity == 16);
   for (i = 1; i <= n; i++) {
-    grpc_chttp2_stream_map_add(&map, i, (void *)(uintptr_t)i);
+    grpc_chttp2_stream_map_add(&map, i, (void*)(uintptr_t)i);
     if (i > 8) {
       del = i - 8;
-      GPR_ASSERT((void *)(uintptr_t)del ==
+      GPR_ASSERT((void*)(uintptr_t)del ==
                  grpc_chttp2_stream_map_delete(&map, del));
     }
   }
@@ -189,7 +188,7 @@ static void test_periodic_compaction(uint32_t n) {
   grpc_chttp2_stream_map_destroy(&map);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   uint32_t n = 1;
   uint32_t prev = 1;
   uint32_t tmp;
diff --git a/test/core/transport/chttp2/varint_test.c b/test/core/transport/chttp2/varint_test.cc
index 0986a2cde6..413b461b3a 100644
--- a/test/core/transport/chttp2/varint_test.c
+++ b/test/core/transport/chttp2/varint_test.cc
@@ -24,7 +24,7 @@
 #include "test/core/util/test_config.h"
 
 static void test_varint(uint32_t value, uint32_t prefix_bits, uint8_t prefix_or,
-                        const char *expect_bytes, size_t expect_length) {
+                        const char* expect_bytes, size_t expect_length) {
   uint32_t nbytes = GRPC_CHTTP2_VARINT_LENGTH(value, prefix_bits);
   grpc_slice expect =
       grpc_slice_from_copied_buffer(expect_bytes, expect_length);
@@ -42,7 +42,7 @@ static void test_varint(uint32_t value, uint32_t prefix_bits, uint8_t prefix_or,
 #define TEST_VARINT(value, prefix_bits, prefix_or, expect) \
   test_varint(value, prefix_bits, prefix_or, expect, sizeof(expect) - 1)
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   TEST_VARINT(0, 1, 0, "\x00");
   TEST_VARINT(128, 1, 0, "\x7f\x01");
diff --git a/test/core/transport/connectivity_state_test.c b/test/core/transport/connectivity_state_test.cc
index f0a907d4c7..92bf1ba903 100644
--- a/test/core/transport/connectivity_state_test.c
+++ b/test/core/transport/connectivity_state_test.cc
@@ -24,17 +24,17 @@
 
 #include "test/core/util/test_config.h"
 
-#define THE_ARG ((void *)(size_t)0xcafebabe)
+#define THE_ARG ((void*)(size_t)0xcafebabe)
 
 int g_counter;
 
-static void must_succeed(void *arg, grpc_error *error) {
+static void must_succeed(void* arg, grpc_error* error) {
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   GPR_ASSERT(arg == THE_ARG);
   g_counter++;
 }
 
-static void must_fail(void *arg, grpc_error *error) {
+static void must_fail(void* arg, grpc_error* error) {
   GPR_ASSERT(error != GRPC_ERROR_NONE);
   GPR_ASSERT(arg == THE_ARG);
   g_counter++;
@@ -57,8 +57,8 @@ static void test_connectivity_state_name(void) {
 
 static void test_check(void) {
   grpc_connectivity_state_tracker tracker;
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_error *error;
+  ExecCtx _local_exec_ctx;
+  grpc_error* error;
   gpr_log(GPR_DEBUG, "test_check");
   grpc_connectivity_state_init(&tracker, GRPC_CHANNEL_IDLE, "xxx");
   GPR_ASSERT(grpc_connectivity_state_get(&tracker, &error) ==
@@ -71,10 +71,10 @@ static void test_check(void) {
 
 static void test_subscribe_then_unsubscribe(void) {
   grpc_connectivity_state_tracker tracker;
-  grpc_closure *closure =
+  grpc_closure* closure =
       GRPC_CLOSURE_CREATE(must_fail, THE_ARG, grpc_schedule_on_exec_ctx);
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   gpr_log(GPR_DEBUG, "test_subscribe_then_unsubscribe");
   g_counter = 0;
   grpc_connectivity_state_init(&tracker, GRPC_CHANNEL_IDLE, "xxx");
@@ -94,10 +94,10 @@ static void test_subscribe_then_unsubscribe(void) {
 
 static void test_subscribe_then_destroy(void) {
   grpc_connectivity_state_tracker tracker;
-  grpc_closure *closure =
+  grpc_closure* closure =
       GRPC_CLOSURE_CREATE(must_succeed, THE_ARG, grpc_schedule_on_exec_ctx);
   grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   gpr_log(GPR_DEBUG, "test_subscribe_then_destroy");
   g_counter = 0;
   grpc_connectivity_state_init(&tracker, GRPC_CHANNEL_IDLE, "xxx");
@@ -114,10 +114,10 @@ static void test_subscribe_then_destroy(void) {
 
 static void test_subscribe_with_failure_then_destroy(void) {
   grpc_connectivity_state_tracker tracker;
-  grpc_closure *closure =
+  grpc_closure* closure =
       GRPC_CLOSURE_CREATE(must_fail, THE_ARG, grpc_schedule_on_exec_ctx);
   grpc_connectivity_state state = GRPC_CHANNEL_SHUTDOWN;
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   gpr_log(GPR_DEBUG, "test_subscribe_with_failure_then_destroy");
   g_counter = 0;
   grpc_connectivity_state_init(&tracker, GRPC_CHANNEL_SHUTDOWN, "xxx");
@@ -132,7 +132,7 @@ static void test_subscribe_with_failure_then_destroy(void) {
   GPR_ASSERT(g_counter == 1);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_connectivity_state_trace.value = 1;
   test_connectivity_state_name();
diff --git a/test/core/transport/metadata_test.c b/test/core/transport/metadata_test.cc
index a721247766..4bc5672958 100644
--- a/test/core/transport/metadata_test.c
+++ b/test/core/transport/metadata_test.cc
@@ -60,7 +60,7 @@ static void test_create_metadata(bool intern_keys, bool intern_values) {
           intern_keys, intern_values);
 
   grpc_init();
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   m1 = grpc_mdelem_from_slices(
       maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
       maybe_intern(grpc_slice_from_static_string("b"), intern_values));
@@ -95,7 +95,7 @@ static void test_create_many_ephemeral_metadata(bool intern_keys,
       intern_keys, intern_values);
 
   grpc_init();
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   /* add, and immediately delete a bunch of different elements */
   for (i = 0; i < MANY; i++) {
     gpr_ltoa(i, buffer);
@@ -110,13 +110,14 @@ static void test_create_many_ephemeral_metadata(bool intern_keys,
 static void test_create_many_persistant_metadata(void) {
   char buffer[GPR_LTOA_MIN_BUFSIZE];
   long i;
-  grpc_mdelem *created = gpr_malloc(sizeof(grpc_mdelem) * MANY);
+  grpc_mdelem* created =
+      static_cast<grpc_mdelem*>(gpr_malloc(sizeof(grpc_mdelem) * MANY));
   grpc_mdelem md;
 
   gpr_log(GPR_INFO, "test_create_many_persistant_metadata");
 
   grpc_init();
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   /* add phase */
   for (i = 0; i < MANY; i++) {
     gpr_ltoa(i, buffer);
@@ -150,7 +151,7 @@ static void test_spin_creating_the_same_thing(bool intern_keys,
           intern_keys, intern_values);
 
   grpc_init();
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   grpc_mdelem a, b, c;
   GRPC_MDELEM_UNREF(
       a = grpc_mdelem_from_slices(
@@ -177,7 +178,7 @@ static void test_identity_laws(bool intern_keys, bool intern_values) {
           intern_keys, intern_values);
 
   grpc_init();
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
   grpc_mdelem a, b, c;
   a = grpc_mdelem_from_slices(
       maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
@@ -214,16 +215,17 @@ static void test_identity_laws(bool intern_keys, bool intern_values) {
 
 static void test_things_stick_around(void) {
   size_t i, j;
-  char *buffer;
+  char* buffer;
   size_t nstrs = 1000;
-  grpc_slice *strs = gpr_malloc(sizeof(grpc_slice) * nstrs);
-  size_t *shuf = gpr_malloc(sizeof(size_t) * nstrs);
+  grpc_slice* strs =
+      static_cast<grpc_slice*>(gpr_malloc(sizeof(grpc_slice) * nstrs));
+  size_t* shuf = static_cast<size_t*>(gpr_malloc(sizeof(size_t) * nstrs));
   grpc_slice test;
 
   gpr_log(GPR_INFO, "test_things_stick_around");
 
   grpc_init();
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
 
   for (i = 0; i < nstrs; i++) {
     gpr_asprintf(&buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%" PRIuPTR "x", i);
@@ -264,16 +266,16 @@ static void test_things_stick_around(void) {
 }
 
 static void test_user_data_works(void) {
-  int *ud1;
-  int *ud2;
+  int* ud1;
+  int* ud2;
   grpc_mdelem md;
   gpr_log(GPR_INFO, "test_user_data_works");
 
   grpc_init();
-  exec_ctx = GRPC_EXEC_CTX_INIT;
-  ud1 = gpr_malloc(sizeof(int));
+  ExecCtx _local_exec_ctx;
+  ud1 = static_cast<int*>(gpr_malloc(sizeof(int)));
   *ud1 = 1;
-  ud2 = gpr_malloc(sizeof(int));
+  ud2 = static_cast<int*>(gpr_malloc(sizeof(int)));
   *ud2 = 2;
   md = grpc_mdelem_from_slices(
       grpc_slice_intern(grpc_slice_from_static_string("abc")),
@@ -286,18 +288,18 @@ static void test_user_data_works(void) {
   grpc_shutdown();
 }
 
-static void verify_ascii_header_size(const char *key, const char *value,
+static void verify_ascii_header_size(const char* key, const char* value,
                                      bool intern_key, bool intern_value) {
   grpc_mdelem elem = grpc_mdelem_from_slices(
       maybe_intern(grpc_slice_from_static_string(key), intern_key),
       maybe_intern(grpc_slice_from_static_string(value), intern_value));
-  size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem);
+  size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem, false);
   size_t expected_size = 32 + strlen(key) + strlen(value);
   GPR_ASSERT(expected_size == elem_size);
   GRPC_MDELEM_UNREF(elem);
 }
 
-static void verify_binary_header_size(const char *key, const uint8_t *value,
+static void verify_binary_header_size(const char* key, const uint8_t* value,
                                       size_t value_len, bool intern_key,
                                       bool intern_value) {
   grpc_mdelem elem = grpc_mdelem_from_slices(
@@ -305,9 +307,9 @@ static void verify_binary_header_size(const char *key, const uint8_t *value,
       maybe_intern(grpc_slice_from_static_buffer(value, value_len),
                    intern_value));
   GPR_ASSERT(grpc_is_binary_header(GRPC_MDKEY(elem)));
-  size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem);
+  size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem, false);
   grpc_slice value_slice =
-      grpc_slice_from_copied_buffer((const char *)value, value_len);
+      grpc_slice_from_copied_buffer((const char*)value, value_len);
   grpc_slice base64_encoded = grpc_chttp2_base64_encode(value_slice);
   size_t expected_size = 32 + strlen(key) + GRPC_SLICE_LENGTH(base64_encoded);
   GPR_ASSERT(expected_size == elem_size);
@@ -321,7 +323,7 @@ static void test_mdelem_sizes_in_hpack(bool intern_key, bool intern_value) {
   gpr_log(GPR_INFO, "test_mdelem_size: intern_key=%d intern_value=%d",
           intern_key, intern_value);
   grpc_init();
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
 
   uint8_t binary_value[BUFFER_SIZE] = {0};
   for (uint8_t i = 0; i < BUFFER_SIZE; i++) {
@@ -346,7 +348,7 @@ static void test_copied_static_metadata(bool dup_key, bool dup_value) {
   gpr_log(GPR_INFO, "test_static_metadata: dup_key=%d dup_value=%d", dup_key,
           dup_value);
   grpc_init();
-  exec_ctx = GRPC_EXEC_CTX_INIT;
+  ExecCtx _local_exec_ctx;
 
   for (size_t i = 0; i < GRPC_STATIC_MDELEM_COUNT; i++) {
     grpc_mdelem p = GRPC_MAKE_MDELEM(&grpc_static_mdelem_table[i],
@@ -368,7 +370,7 @@ static void test_copied_static_metadata(bool dup_key, bool dup_value) {
   grpc_shutdown();
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_no_op();
   for (int k = 0; k <= 1; k++) {
diff --git a/test/core/transport/pid_controller_test.c b/test/core/transport/pid_controller_test.c
deleted file mode 100644
index 831c4b41ce..0000000000
--- a/test/core/transport/pid_controller_test.c
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include "src/core/lib/transport/pid_controller.h"
-
-#include <float.h>
-#include <math.h>
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/useful.h>
-#include "src/core/lib/support/string.h"
-#include "test/core/util/test_config.h"
-
-static void test_noop(void) {
-  gpr_log(GPR_INFO, "test_noop");
-  grpc_pid_controller pid;
-  grpc_pid_controller_init(
-      &pid, (grpc_pid_controller_args){.gain_p = 1,
-                                       .gain_i = 1,
-                                       .gain_d = 1,
-                                       .initial_control_value = 1,
-                                       .min_control_value = DBL_MIN,
-                                       .max_control_value = DBL_MAX,
-                                       .integral_range = DBL_MAX});
-}
-
-static void test_simple_convergence(double gain_p, double gain_i, double gain_d,
-                                    double dt, double set_point, double start) {
-  gpr_log(GPR_INFO,
-          "test_simple_convergence(p=%lf, i=%lf, d=%lf); dt=%lf set_point=%lf "
-          "start=%lf",
-          gain_p, gain_i, gain_d, dt, set_point, start);
-  grpc_pid_controller pid;
-  grpc_pid_controller_init(
-      &pid, (grpc_pid_controller_args){.gain_p = gain_p,
-                                       .gain_i = gain_i,
-                                       .gain_d = gain_d,
-                                       .initial_control_value = start,
-                                       .min_control_value = DBL_MIN,
-                                       .max_control_value = DBL_MAX,
-                                       .integral_range = DBL_MAX});
-
-  for (int i = 0; i < 100000; i++) {
-    grpc_pid_controller_update(&pid, set_point - grpc_pid_controller_last(&pid),
-                               1);
-  }
-
-  GPR_ASSERT(fabs(set_point - grpc_pid_controller_last(&pid)) < 0.1);
-  if (gain_i > 0) {
-    GPR_ASSERT(fabs(pid.error_integral) < 0.1);
-  }
-}
-
-int main(int argc, char **argv) {
-  grpc_test_init(argc, argv);
-  test_noop();
-  test_simple_convergence(0.2, 0, 0, 1, 100, 0);
-  test_simple_convergence(0.2, 0.1, 0, 1, 100, 0);
-  test_simple_convergence(0.2, 0.1, 0.1, 1, 100, 0);
-  return 0;
-}
diff --git a/test/core/transport/pid_controller_test.cc b/test/core/transport/pid_controller_test.cc
new file mode 100644
index 0000000000..081d03472a
--- /dev/null
+++ b/test/core/transport/pid_controller_test.cc
@@ -0,0 +1,91 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/transport/pid_controller.h"
+
+#include <float.h>
+#include <math.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/useful.h>
+#include <gtest/gtest.h>
+#include "src/core/lib/support/string.h"
+#include "test/core/util/test_config.h"
+
+namespace grpc_core {
+namespace testing {
+
+TEST(PidController, NoOp) {
+  PidController pid(PidController::Args()
+                        .set_gain_p(1)
+                        .set_gain_i(1)
+                        .set_gain_d(1)
+                        .set_initial_control_value(1));
+}
+
+struct SimpleConvergenceTestArgs {
+  double gain_p;
+  double gain_i;
+  double gain_d;
+  double dt;
+  double set_point;
+  double start;
+};
+
+std::ostream& operator<<(std::ostream& out, SimpleConvergenceTestArgs args) {
+  return out << "gain_p:" << args.gain_p << " gain_i:" << args.gain_i
+             << " gain_d:" << args.gain_d << " dt:" << args.dt
+             << " set_point:" << args.set_point << " start:" << args.start;
+}
+
+class SimpleConvergenceTest
+    : public ::testing::TestWithParam<SimpleConvergenceTestArgs> {};
+
+TEST_P(SimpleConvergenceTest, Converges) {
+  PidController pid(PidController::Args()
+                        .set_gain_p(GetParam().gain_p)
+                        .set_gain_i(GetParam().gain_i)
+                        .set_gain_d(GetParam().gain_d)
+                        .set_initial_control_value(GetParam().start));
+
+  for (int i = 0; i < 100000; i++) {
+    pid.Update(GetParam().set_point - pid.last_control_value(), GetParam().dt);
+  }
+
+  EXPECT_LT(fabs(GetParam().set_point - pid.last_control_value()), 0.1);
+  if (GetParam().gain_i > 0) {
+    EXPECT_LT(fabs(pid.error_integral()), 0.1);
+  }
+}
+
+INSTANTIATE_TEST_CASE_P(
+    X, SimpleConvergenceTest,
+    ::testing::Values(SimpleConvergenceTestArgs{0.2, 0, 0, 1, 100, 0},
+                      SimpleConvergenceTestArgs{0.2, 0.1, 0, 1, 100, 0},
+                      SimpleConvergenceTestArgs{0.2, 0.1, 0.1, 1, 100, 0}));
+
+}  // namespace testing
+}  // namespace grpc_core
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/test/core/transport/status_conversion_test.c b/test/core/transport/status_conversion_test.cc
index d91f3765c6..44e961310a 100644
--- a/test/core/transport/status_conversion_test.c
+++ b/test/core/transport/status_conversion_test.cc
@@ -24,17 +24,20 @@
   GPR_ASSERT(grpc_status_to_http2_error(a) == (b))
 #define HTTP2_ERROR_TO_GRPC_STATUS(a, deadline, b)                   \
   do {                                                               \
+    ExecCtx _local_exec_ctx;                                         \
     GPR_ASSERT(grpc_http2_error_to_grpc_status(a, deadline) == (b)); \
+    grpc_exec_ctx_finish();                                          \
   } while (0)
 #define GRPC_STATUS_TO_HTTP2_STATUS(a, b) \
   GPR_ASSERT(grpc_status_to_http2_status(a) == (b))
 #define HTTP2_STATUS_TO_GRPC_STATUS(a, b) \
   GPR_ASSERT(grpc_http2_status_to_grpc_status(a) == (b))
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int i;
 
   grpc_test_init(argc, argv);
+  grpc_init();
 
   GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_OK, GRPC_HTTP2_NO_ERROR);
   GRPC_STATUS_TO_HTTP2_ERROR(GRPC_STATUS_CANCELLED, GRPC_HTTP2_CANCEL);
@@ -126,6 +129,11 @@ int main(int argc, char **argv) {
                              GRPC_STATUS_INTERNAL);
   HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_REFUSED_STREAM, after_deadline,
                              GRPC_STATUS_UNAVAILABLE);
+  // We only have millisecond granularity in our timing code. This sleeps for 5
+  // millis to ensure that the status conversion code will pick up the fact
+  // that the deadline has expired.
+  gpr_sleep_until(gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
+                               gpr_time_from_millis(5, GPR_TIMESPAN)));
   HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_CANCEL, after_deadline,
                              GRPC_STATUS_DEADLINE_EXCEEDED);
   HTTP2_ERROR_TO_GRPC_STATUS(GRPC_HTTP2_COMPRESSION_ERROR, after_deadline,
@@ -155,5 +163,7 @@ int main(int argc, char **argv) {
     grpc_http2_status_to_grpc_status(i);
   }
 
+  grpc_shutdown();
+
   return 0;
 }
diff --git a/test/core/transport/stream_owned_slice_test.c b/test/core/transport/stream_owned_slice_test.cc
index f380763a6c..e8fcc61167 100644
--- a/test/core/transport/stream_owned_slice_test.c
+++ b/test/core/transport/stream_owned_slice_test.cc
@@ -22,9 +22,9 @@
 
 #include <grpc/support/log.h>
 
-static void do_nothing(void *arg, grpc_error *error) {}
+static void do_nothing(void* arg, grpc_error* error) {}
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
 
   uint8_t buffer[] = "abc123";
diff --git a/test/core/transport/timeout_encoding_test.c b/test/core/transport/timeout_encoding_test.cc
index 30357faed3..0930bc836d 100644
--- a/test/core/transport/timeout_encoding_test.c
+++ b/test/core/transport/timeout_encoding_test.cc
@@ -31,7 +31,7 @@
 
 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
 
-static void assert_encodes_as(grpc_millis ts, const char *s) {
+static void assert_encodes_as(grpc_millis ts, const char* s) {
   char buffer[GRPC_HTTP2_TIMEOUT_ENCODE_MIN_BUFSIZE];
   grpc_http2_encode_timeout(ts, buffer);
   gpr_log(GPR_INFO, "check '%s' == '%s'", buffer, s);
@@ -63,7 +63,7 @@ void test_encoding(void) {
   assert_encodes_as(10 * 60 * 60 * GPR_MS_PER_SEC, "10H");
 }
 
-static void assert_decodes_as(const char *buffer, grpc_millis expected) {
+static void assert_decodes_as(const char* buffer, grpc_millis expected) {
   grpc_millis got;
   uint32_t hash = gpr_murmur_hash3(buffer, strlen(buffer), 0);
   gpr_log(GPR_INFO, "check decoding '%s' (hash=0x%x)", buffer, hash);
@@ -81,7 +81,7 @@ void decode_suite(char ext, grpc_millis (*answer)(int64_t x)) {
                       1234567, 12345678, 123456789, 98765432, 9876543, 987654,
                       98765,   9876,     987,       98,       9};
   unsigned i;
-  char *input;
+  char* input;
   for (i = 0; i < GPR_ARRAY_SIZE(test_vals); i++) {
     gpr_asprintf(&input, "%ld%c", test_vals[i], ext);
     assert_decodes_as(input, answer(test_vals[i]));
@@ -133,7 +133,7 @@ void test_decoding(void) {
   assert_decodes_as("9999999999S", GRPC_MILLIS_INF_FUTURE);
 }
 
-static void assert_decoding_fails(const char *s) {
+static void assert_decoding_fails(const char* s) {
   grpc_millis x;
   GPR_ASSERT(0 ==
              grpc_http2_decode_timeout(grpc_slice_from_static_string(s), &x));
@@ -152,7 +152,7 @@ void test_decoding_fails(void) {
   assert_decoding_fails("-1u");
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   test_encoding();
   test_decoding();