Merge with master

11 files changed, 177 insertions, 275 deletions

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");