Merge master into yashykt:execctxcleanup

15 files changed, 121 insertions, 103 deletions

diff --git a/test/core/client_channel/parse_address_test.cc b/test/core/client_channel/parse_address_test.cc
index 373ed76cbe..ae157fbb8b 100644
--- a/test/core/client_channel/parse_address_test.cc
+++ b/test/core/client_channel/parse_address_test.cc
@@ -18,6 +18,7 @@
 
 #include "src/core/ext/filters/client_channel/parse_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/iomgr/socket_utils.h"
 
 #include <string.h>
 #ifdef GRPC_HAVE_UNIX_SOCKET
@@ -58,16 +59,15 @@ static void test_grpc_parse_ipv4(const char* uri_text, const char* host,
   grpc_core::ExecCtx exec_ctx;
   grpc_uri* uri = grpc_uri_parse(uri_text, 0);
   grpc_resolved_address addr;
-  char ntop_buf[INET_ADDRSTRLEN];
+  char ntop_buf[GRPC_INET_ADDRSTRLEN];
 
   GPR_ASSERT(1 == grpc_parse_ipv4(uri, &addr));
-  struct sockaddr_in* addr_in =
-      reinterpret_cast<struct sockaddr_in*>(addr.addr);
-  GPR_ASSERT(AF_INET == addr_in->sin_family);
-  GPR_ASSERT(nullptr != grpc_inet_ntop(AF_INET, &addr_in->sin_addr, ntop_buf,
-                                       sizeof(ntop_buf)));
+  grpc_sockaddr_in* addr_in = reinterpret_cast<grpc_sockaddr_in*>(addr.addr);
+  GPR_ASSERT(GRPC_AF_INET == addr_in->sin_family);
+  GPR_ASSERT(nullptr != grpc_inet_ntop(GRPC_AF_INET, &addr_in->sin_addr,
+                                       ntop_buf, sizeof(ntop_buf)));
   GPR_ASSERT(0 == strcmp(ntop_buf, host));
-  GPR_ASSERT(ntohs(addr_in->sin_port) == port);
+  GPR_ASSERT(grpc_ntohs(addr_in->sin_port) == port);
 
   grpc_uri_destroy(uri);
 }
@@ -77,16 +77,15 @@ static void test_grpc_parse_ipv6(const char* uri_text, const char* host,
   grpc_core::ExecCtx exec_ctx;
   grpc_uri* uri = grpc_uri_parse(uri_text, 0);
   grpc_resolved_address addr;
-  char ntop_buf[INET6_ADDRSTRLEN];
+  char ntop_buf[GRPC_INET6_ADDRSTRLEN];
 
   GPR_ASSERT(1 == grpc_parse_ipv6(uri, &addr));
-  struct sockaddr_in6* addr_in6 =
-      reinterpret_cast<struct sockaddr_in6*>(addr.addr);
-  GPR_ASSERT(AF_INET6 == addr_in6->sin6_family);
-  GPR_ASSERT(nullptr != grpc_inet_ntop(AF_INET6, &addr_in6->sin6_addr, ntop_buf,
-                                       sizeof(ntop_buf)));
+  grpc_sockaddr_in6* addr_in6 = reinterpret_cast<grpc_sockaddr_in6*>(addr.addr);
+  GPR_ASSERT(GRPC_AF_INET6 == addr_in6->sin6_family);
+  GPR_ASSERT(nullptr != grpc_inet_ntop(GRPC_AF_INET6, &addr_in6->sin6_addr,
+                                       ntop_buf, sizeof(ntop_buf)));
   GPR_ASSERT(0 == strcmp(ntop_buf, host));
-  GPR_ASSERT(ntohs(addr_in6->sin6_port) == port);
+  GPR_ASSERT(grpc_ntohs(addr_in6->sin6_port) == port);
   GPR_ASSERT(addr_in6->sin6_scope_id == scope_id);
 
   grpc_uri_destroy(uri);
diff --git a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc
index 966fb1d14b..e34aa2e676 100644
--- a/test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc
+++ b/test/core/client_channel/resolvers/dns_resolver_connectivity_test.cc
@@ -57,6 +57,9 @@ static void my_resolve_address(const char* addr, const char* default_port,
   GRPC_CLOSURE_SCHED(on_done, error);
 }
 
+static grpc_address_resolver_vtable test_resolver = {my_resolve_address,
+                                                     nullptr};
+
 static grpc_ares_request* my_dns_lookup_ares(
     const char* dns_server, const char* addr, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
@@ -143,7 +146,7 @@ int main(int argc, char** argv) {
   grpc_init();
   gpr_mu_init(&g_mu);
   g_combiner = grpc_combiner_create();
-  grpc_resolve_address = my_resolve_address;
+  grpc_set_resolver_impl(&test_resolver);
   grpc_dns_lookup_ares = my_dns_lookup_ares;
   grpc_channel_args* result = (grpc_channel_args*)1;
 
diff --git a/test/core/client_channel/resolvers/dns_resolver_cooldown_test.cc b/test/core/client_channel/resolvers/dns_resolver_cooldown_test.cc
index 9402a605b3..01c61a9f18 100644
--- a/test/core/client_channel/resolvers/dns_resolver_cooldown_test.cc
+++ b/test/core/client_channel/resolvers/dns_resolver_cooldown_test.cc
@@ -28,12 +28,10 @@
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "test/core/util/test_config.h"
 
-static grpc_combiner* g_combiner;
+extern grpc_address_resolver_vtable* grpc_resolve_address_impl;
+static grpc_address_resolver_vtable* default_resolve_address;
 
-static void (*g_default_grpc_resolve_address)(
-    const char* name, const char* default_port,
-    grpc_pollset_set* interested_parties, grpc_closure* on_done,
-    grpc_resolved_addresses** addrs);
+static grpc_combiner* g_combiner;
 
 grpc_ares_request* (*g_default_dns_lookup_ares)(
     const char* dns_server, const char* name, const char* default_port,
@@ -52,18 +50,28 @@ struct iomgr_args {
   grpc_pollset_set* pollset_set;
 } g_iomgr_args;
 
-// Wrapper around g_default_grpc_resolve_address in order to count the number of
+// Wrapper around default resolve_address in order to count the number of
 // times we incur in a system-level name resolution.
 static void test_resolve_address_impl(const char* name,
                                       const char* default_port,
                                       grpc_pollset_set* interested_parties,
                                       grpc_closure* on_done,
                                       grpc_resolved_addresses** addrs) {
-  g_default_grpc_resolve_address(name, default_port, g_iomgr_args.pollset_set,
-                                 on_done, addrs);
+  default_resolve_address->resolve_address(
+      name, default_port, g_iomgr_args.pollset_set, on_done, addrs);
   ++g_resolution_count;
 }
 
+static grpc_error* test_blocking_resolve_address_impl(
+    const char* name, const char* default_port,
+    grpc_resolved_addresses** addresses) {
+  return default_resolve_address->blocking_resolve_address(name, default_port,
+                                                           addresses);
+}
+
+static grpc_address_resolver_vtable test_resolver = {
+    test_resolve_address_impl, test_blocking_resolve_address_impl};
+
 grpc_ares_request* test_dns_lookup_ares(
     const char* dns_server, const char* name, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
@@ -285,11 +293,14 @@ int main(int argc, char** argv) {
 
   g_combiner = grpc_combiner_create();
 
-  const bool using_cares = (grpc_resolve_address == grpc_resolve_address_ares);
-  g_default_grpc_resolve_address = grpc_resolve_address;
+  bool using_cares = false;
+#if GRPC_ARES == 1
+  using_cares = true;
+#endif
   g_default_dns_lookup_ares = grpc_dns_lookup_ares;
   grpc_dns_lookup_ares = test_dns_lookup_ares;
-  grpc_resolve_address = test_resolve_address_impl;
+  default_resolve_address = grpc_resolve_address_impl;
+  grpc_set_resolver_impl(&test_resolver);
 
   test_cooldown(using_cares);
 
diff --git a/test/core/end2end/fixtures/http_proxy_fixture.cc b/test/core/end2end/fixtures/http_proxy_fixture.cc
index 58353376f3..f02fa9d998 100644
--- a/test/core/end2end/fixtures/http_proxy_fixture.cc
+++ b/test/core/end2end/fixtures/http_proxy_fixture.cc
@@ -535,10 +535,10 @@ grpc_end2end_http_proxy* grpc_end2end_http_proxy_create(
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   // Bind to port.
   grpc_resolved_address resolved_addr;
-  struct sockaddr_in* addr =
-      reinterpret_cast<struct sockaddr_in*>(resolved_addr.addr);
+  grpc_sockaddr_in* addr =
+      reinterpret_cast<grpc_sockaddr_in*>(resolved_addr.addr);
   memset(&resolved_addr, 0, sizeof(resolved_addr));
-  addr->sin_family = AF_INET;
+  addr->sin_family = GRPC_AF_INET;
   grpc_sockaddr_set_port(&resolved_addr, proxy_port);
   int port;
   error = grpc_tcp_server_add_port(proxy->server, &resolved_addr, &port);
diff --git a/test/core/end2end/fuzzers/api_fuzzer.cc b/test/core/end2end/fuzzers/api_fuzzer.cc
index b6347fb1db..9ace7d04aa 100644
--- a/test/core/end2end/fuzzers/api_fuzzer.cc
+++ b/test/core/end2end/fuzzers/api_fuzzer.cc
@@ -426,6 +426,9 @@ void my_resolve_address(const char* addr, const char* default_port,
       GRPC_CLOSURE_CREATE(finish_resolve, r, grpc_schedule_on_exec_ctx));
 }
 
+static grpc_address_resolver_vtable fuzzer_resolver = {my_resolve_address,
+                                                       nullptr};
+
 grpc_ares_request* my_dns_lookup_ares(const char* dns_server, const char* addr,
                                       const char* default_port,
                                       grpc_pollset_set* interested_parties,
@@ -447,12 +450,6 @@ grpc_ares_request* my_dns_lookup_ares(const char* dns_server, const char* addr,
 ////////////////////////////////////////////////////////////////////////////////
 // client connection
 
-// defined in tcp_client_posix.c
-extern void (*grpc_tcp_client_connect_impl)(
-    grpc_closure* closure, grpc_endpoint** ep,
-    grpc_pollset_set* interested_parties, const grpc_channel_args* channel_args,
-    const grpc_resolved_address* addr, grpc_millis deadline);
-
 static void sched_connect(grpc_closure* closure, grpc_endpoint** ep,
                           gpr_timespec deadline);
 
@@ -513,6 +510,8 @@ static void my_tcp_client_connect(grpc_closure* closure, grpc_endpoint** ep,
                 grpc_millis_to_timespec(deadline, GPR_CLOCK_MONOTONIC));
 }
 
+grpc_tcp_client_vtable fuzz_tcp_client_vtable = {my_tcp_client_connect};
+
 ////////////////////////////////////////////////////////////////////////////////
 // test driver
 
@@ -753,7 +752,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   if (squelch && grpc_trace_fuzzer == nullptr) gpr_set_log_function(dont_log);
   gpr_free(grpc_trace_fuzzer);
   input_stream inp = {data, data + size};
-  grpc_tcp_client_connect_impl = my_tcp_client_connect;
+  grpc_set_tcp_client_impl(&fuzz_tcp_client_vtable);
   gpr_now_impl = now_impl;
   grpc_init();
   grpc_timer_manager_set_threading(false);
@@ -761,7 +760,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
     grpc_core::ExecCtx exec_ctx;
     grpc_executor_set_threading(false);
   }
-  grpc_resolve_address = my_resolve_address;
+  grpc_set_resolver_impl(&fuzzer_resolver);
   grpc_dns_lookup_ares = my_dns_lookup_ares;
 
   GPR_ASSERT(g_channel == nullptr);
diff --git a/test/core/end2end/goaway_server_test.cc b/test/core/end2end/goaway_server_test.cc
index 09f0301c44..8ff14e2b85 100644
--- a/test/core/end2end/goaway_server_test.cc
+++ b/test/core/end2end/goaway_server_test.cc
@@ -21,6 +21,7 @@
    including windows.h on Windows, uv.h must be included before other system
    headers. Therefore, sockaddr.h must always be included first */
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/iomgr/socket_utils.h"
 
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
@@ -35,14 +36,13 @@
 #include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
+extern grpc_address_resolver_vtable* grpc_resolve_address_impl;
+static grpc_address_resolver_vtable* default_resolver;
+
 static void* tag(intptr_t i) { return (void*)i; }
 
 static gpr_mu g_mu;
 static int g_resolve_port = -1;
-static void (*iomgr_resolve_address)(const char* addr, const char* default_port,
-                                     grpc_pollset_set* interested_parties,
-                                     grpc_closure* on_done,
-                                     grpc_resolved_addresses** addresses);
 
 static grpc_ares_request* (*iomgr_dns_lookup_ares)(
     const char* dns_server, const char* addr, const char* default_port,
@@ -61,8 +61,8 @@ static void my_resolve_address(const char* addr, const char* default_port,
                                grpc_closure* on_done,
                                grpc_resolved_addresses** addrs) {
   if (0 != strcmp(addr, "test")) {
-    iomgr_resolve_address(addr, default_port, interested_parties, on_done,
-                          addrs);
+    default_resolver->resolve_address(addr, default_port, interested_parties,
+                                      on_done, addrs);
     return;
   }
 
@@ -77,17 +77,27 @@ static void my_resolve_address(const char* addr, const char* default_port,
     (*addrs)->addrs = static_cast<grpc_resolved_address*>(
         gpr_malloc(sizeof(*(*addrs)->addrs)));
     memset((*addrs)->addrs, 0, sizeof(*(*addrs)->addrs));
-    struct sockaddr_in* sa =
-        reinterpret_cast<struct sockaddr_in*>((*addrs)->addrs[0].addr);
-    sa->sin_family = AF_INET;
-    sa->sin_addr.s_addr = htonl(0x7f000001);
-    sa->sin_port = htons(static_cast<uint16_t>(g_resolve_port));
+    grpc_sockaddr_in* sa =
+        reinterpret_cast<grpc_sockaddr_in*>((*addrs)->addrs[0].addr);
+    sa->sin_family = GRPC_AF_INET;
+    sa->sin_addr.s_addr = 0x100007f;
+    sa->sin_port = grpc_htons(static_cast<uint16_t>(g_resolve_port));
     (*addrs)->addrs[0].len = sizeof(*sa);
     gpr_mu_unlock(&g_mu);
   }
   GRPC_CLOSURE_SCHED(on_done, error);
 }
 
+static grpc_error* my_blocking_resolve_address(
+    const char* name, const char* default_port,
+    grpc_resolved_addresses** addresses) {
+  return default_resolver->blocking_resolve_address(name, default_port,
+                                                    addresses);
+}
+
+static grpc_address_resolver_vtable test_resolver = {
+    my_resolve_address, my_blocking_resolve_address};
+
 static grpc_ares_request* my_dns_lookup_ares(
     const char* dns_server, const char* addr, const char* default_port,
     grpc_pollset_set* interested_parties, grpc_closure* on_done,
@@ -106,11 +116,11 @@ static grpc_ares_request* my_dns_lookup_ares(
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("Forced Failure");
   } else {
     *lb_addrs = grpc_lb_addresses_create(1, nullptr);
-    struct sockaddr_in* sa = static_cast<struct sockaddr_in*>(
-        gpr_zalloc(sizeof(struct sockaddr_in)));
-    sa->sin_family = AF_INET;
-    sa->sin_addr.s_addr = htonl(0x7f000001);
-    sa->sin_port = htons(static_cast<uint16_t>(g_resolve_port));
+    grpc_sockaddr_in* sa =
+        static_cast<grpc_sockaddr_in*>(gpr_zalloc(sizeof(grpc_sockaddr_in)));
+    sa->sin_family = GRPC_AF_INET;
+    sa->sin_addr.s_addr = 0x100007f;
+    sa->sin_port = grpc_htons(static_cast<uint16_t>(g_resolve_port));
     grpc_lb_addresses_set_address(*lb_addrs, 0, sa, sizeof(*sa), false, nullptr,
                                   nullptr);
     gpr_free(sa);
@@ -130,9 +140,9 @@ int main(int argc, char** argv) {
 
   gpr_mu_init(&g_mu);
   grpc_init();
-  iomgr_resolve_address = grpc_resolve_address;
+  default_resolver = grpc_resolve_address_impl;
+  grpc_set_resolver_impl(&test_resolver);
   iomgr_dns_lookup_ares = grpc_dns_lookup_ares;
-  grpc_resolve_address = my_resolve_address;
   grpc_dns_lookup_ares = my_dns_lookup_ares;
 
   int was_cancelled1;
diff --git a/test/core/end2end/tests/request_with_flags.cc b/test/core/end2end/tests/request_with_flags.cc
index 4a54318d0f..c52482470e 100644
--- a/test/core/end2end/tests/request_with_flags.cc
+++ b/test/core/end2end/tests/request_with_flags.cc
@@ -48,14 +48,12 @@ static gpr_timespec n_seconds_from_now(int n) {
   return grpc_timeout_seconds_to_deadline(n);
 }
 
-static gpr_timespec five_seconds_from_now(void) {
-  return n_seconds_from_now(5);
-}
+static gpr_timespec one_second_from_now(void) { return n_seconds_from_now(1); }
 
 static void drain_cq(grpc_completion_queue* cq) {
   grpc_event ev;
   do {
-    ev = grpc_completion_queue_next(cq, five_seconds_from_now(), nullptr);
+    ev = grpc_completion_queue_next(cq, one_second_from_now(), nullptr);
   } while (ev.type != GRPC_QUEUE_SHUTDOWN);
 }
 
@@ -109,7 +107,7 @@ static void test_invoke_request_with_flags(
   grpc_slice details;
   grpc_call_error expectation;
 
-  gpr_timespec deadline = five_seconds_from_now();
+  gpr_timespec deadline = one_second_from_now();
   c = grpc_channel_create_call(
       f.client, nullptr, GRPC_PROPAGATE_DEFAULTS, f.cq,
       grpc_slice_from_static_string("/foo"),
diff --git a/test/core/http/httpcli_test.cc b/test/core/http/httpcli_test.cc
index 346568fcf2..16448d9e14 100644
--- a/test/core/http/httpcli_test.cc
+++ b/test/core/http/httpcli_test.cc
@@ -47,6 +47,7 @@ static void on_finish(void* arg, grpc_error* error) {
       "<body><p>This is a test</p></body></html>";
   grpc_http_response* response = static_cast<grpc_http_response*>(arg);
   GPR_ASSERT(response);
+  gpr_log(GPR_INFO, "response status %d", response->status);
   GPR_ASSERT(response->status == 200);
   GPR_ASSERT(response->body_length == strlen(expect));
   GPR_ASSERT(0 == memcmp(expect, response->body, response->body_length));
diff --git a/test/core/http/httpscli_test.cc b/test/core/http/httpscli_test.cc
index a38f306ef3..b8f2e438a4 100644
--- a/test/core/http/httpscli_test.cc
+++ b/test/core/http/httpscli_test.cc
@@ -49,6 +49,7 @@ static void on_finish(void* arg, grpc_error* error) {
       "<body><p>This is a test</p></body></html>";
   grpc_http_response* response = static_cast<grpc_http_response*>(arg);
   GPR_ASSERT(response);
+  gpr_log(GPR_INFO, "response status %d", response->status);
   GPR_ASSERT(response->status == 200);
   GPR_ASSERT(response->body_length == strlen(expect));
   GPR_ASSERT(0 == memcmp(expect, response->body, response->body_length));
diff --git a/test/core/iomgr/sockaddr_utils_test.cc b/test/core/iomgr/sockaddr_utils_test.cc
index 32d2a384bd..aa9ece3081 100644
--- a/test/core/iomgr/sockaddr_utils_test.cc
+++ b/test/core/iomgr/sockaddr_utils_test.cc
@@ -22,6 +22,7 @@
    headers. Therefore, sockaddr.h must always be included first */
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/iomgr/socket_utils.h"
 
 #include <errno.h>
 #include <string.h>
@@ -33,34 +34,33 @@
 
 static grpc_resolved_address make_addr4(const uint8_t* data, size_t data_len) {
   grpc_resolved_address resolved_addr4;
-  struct sockaddr_in* addr4 =
-      reinterpret_cast<struct sockaddr_in*>(resolved_addr4.addr);
+  grpc_sockaddr_in* addr4 =
+      reinterpret_cast<grpc_sockaddr_in*>(resolved_addr4.addr);
   memset(&resolved_addr4, 0, sizeof(resolved_addr4));
-  addr4->sin_family = AF_INET;
+  addr4->sin_family = GRPC_AF_INET;
   GPR_ASSERT(data_len == sizeof(addr4->sin_addr.s_addr));
   memcpy(&addr4->sin_addr.s_addr, data, data_len);
-  addr4->sin_port = htons(12345);
-  resolved_addr4.len = sizeof(struct sockaddr_in);
+  addr4->sin_port = grpc_htons(12345);
+  resolved_addr4.len = sizeof(grpc_sockaddr_in);
   return resolved_addr4;
 }
 
 static grpc_resolved_address make_addr6(const uint8_t* data, size_t data_len) {
   grpc_resolved_address resolved_addr6;
-  struct sockaddr_in6* addr6 =
-      reinterpret_cast<struct sockaddr_in6*>(resolved_addr6.addr);
+  grpc_sockaddr_in6* addr6 =
+      reinterpret_cast<grpc_sockaddr_in6*>(resolved_addr6.addr);
   memset(&resolved_addr6, 0, sizeof(resolved_addr6));
-  addr6->sin6_family = AF_INET6;
+  addr6->sin6_family = GRPC_AF_INET6;
   GPR_ASSERT(data_len == sizeof(addr6->sin6_addr.s6_addr));
   memcpy(&addr6->sin6_addr.s6_addr, data, data_len);
-  addr6->sin6_port = htons(12345);
-  resolved_addr6.len = sizeof(struct sockaddr_in6);
+  addr6->sin6_port = grpc_htons(12345);
+  resolved_addr6.len = sizeof(grpc_sockaddr_in6);
   return resolved_addr6;
 }
 
 static void set_addr6_scope_id(grpc_resolved_address* addr, uint32_t scope_id) {
-  struct sockaddr_in6* addr6 =
-      reinterpret_cast<struct sockaddr_in6*>(addr->addr);
-  GPR_ASSERT(addr6->sin6_family == AF_INET6);
+  grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(addr->addr);
+  GPR_ASSERT(addr6->sin6_family == GRPC_AF_INET6);
   addr6->sin6_scope_id = scope_id;
 }
 
@@ -131,9 +131,9 @@ static void test_sockaddr_is_wildcard(void) {
   grpc_resolved_address wild6;
   grpc_resolved_address wild_mapped;
   grpc_resolved_address dummy;
-  struct sockaddr_in* wild4_addr;
-  struct sockaddr_in6* wild6_addr;
-  struct sockaddr_in6* wild_mapped_addr;
+  grpc_sockaddr_in* wild4_addr;
+  grpc_sockaddr_in6* wild6_addr;
+  grpc_sockaddr_in6* wild_mapped_addr;
   int port;
 
   gpr_log(GPR_INFO, "%s", "test_sockaddr_is_wildcard");
@@ -146,7 +146,7 @@ static void test_sockaddr_is_wildcard(void) {
   port = -1;
   GPR_ASSERT(grpc_sockaddr_is_wildcard(&wild4, &port));
   GPR_ASSERT(port == 555);
-  wild4_addr = reinterpret_cast<struct sockaddr_in*>(&wild4.addr);
+  wild4_addr = reinterpret_cast<grpc_sockaddr_in*>(&wild4.addr);
   memset(&wild4_addr->sin_addr.s_addr, 0xbd, 1);
   GPR_ASSERT(!grpc_sockaddr_is_wildcard(&wild4, &port));
 
@@ -154,7 +154,7 @@ static void test_sockaddr_is_wildcard(void) {
   port = -1;
   GPR_ASSERT(grpc_sockaddr_is_wildcard(&wild6, &port));
   GPR_ASSERT(port == 555);
-  wild6_addr = reinterpret_cast<struct sockaddr_in6*>(&wild6.addr);
+  wild6_addr = reinterpret_cast<grpc_sockaddr_in6*>(&wild6.addr);
   memset(&wild6_addr->sin6_addr.s6_addr, 0xbd, 1);
   GPR_ASSERT(!grpc_sockaddr_is_wildcard(&wild6, &port));
 
@@ -162,7 +162,7 @@ static void test_sockaddr_is_wildcard(void) {
   port = -1;
   GPR_ASSERT(grpc_sockaddr_is_wildcard(&wild_mapped, &port));
   GPR_ASSERT(port == 555);
-  wild_mapped_addr = reinterpret_cast<struct sockaddr_in6*>(&wild_mapped.addr);
+  wild_mapped_addr = reinterpret_cast<grpc_sockaddr_in6*>(&wild_mapped.addr);
   memset(&wild_mapped_addr->sin6_addr.s6_addr, 0xbd, 1);
   GPR_ASSERT(!grpc_sockaddr_is_wildcard(&wild_mapped, &port));
 
@@ -200,7 +200,7 @@ static void test_sockaddr_to_string(void) {
   grpc_resolved_address input4;
   grpc_resolved_address input6;
   grpc_resolved_address dummy;
-  struct sockaddr* dummy_addr;
+  grpc_sockaddr* dummy_addr;
 
   gpr_log(GPR_INFO, "%s", "test_sockaddr_to_string");
 
@@ -237,7 +237,7 @@ static void test_sockaddr_to_string(void) {
   expect_sockaddr_uri("ipv6:[::fffe:c000:263]:12345", &input6);
 
   memset(&dummy, 0, sizeof(dummy));
-  dummy_addr = reinterpret_cast<struct sockaddr*>(dummy.addr);
+  dummy_addr = reinterpret_cast<grpc_sockaddr*>(dummy.addr);
   dummy_addr->sa_family = 123;
   expect_sockaddr_str("(sockaddr family=123)", &dummy, 0);
   expect_sockaddr_str("(sockaddr family=123)", &dummy, 1);
@@ -248,7 +248,7 @@ static void test_sockaddr_set_get_port(void) {
   grpc_resolved_address input4;
   grpc_resolved_address input6;
   grpc_resolved_address dummy;
-  struct sockaddr* dummy_addr;
+  grpc_sockaddr* dummy_addr;
 
   gpr_log(GPR_DEBUG, "test_sockaddr_set_get_port");
 
@@ -263,7 +263,7 @@ static void test_sockaddr_set_get_port(void) {
   GPR_ASSERT(grpc_sockaddr_get_port(&input6) == 54321);
 
   memset(&dummy, 0, sizeof(dummy));
-  dummy_addr = reinterpret_cast<struct sockaddr*>(dummy.addr);
+  dummy_addr = reinterpret_cast<grpc_sockaddr*>(dummy.addr);
   dummy_addr->sa_family = 123;
   GPR_ASSERT(grpc_sockaddr_get_port(&dummy) == 0);
   GPR_ASSERT(grpc_sockaddr_set_port(&dummy, 1234) == 0);
diff --git a/test/core/iomgr/timer_heap_test.cc b/test/core/iomgr/timer_heap_test.cc
index 08f5d632e3..ebe5e32f3a 100644
--- a/test/core/iomgr/timer_heap_test.cc
+++ b/test/core/iomgr/timer_heap_test.cc
@@ -18,9 +18,6 @@
 
 #include "src/core/lib/iomgr/port.h"
 
-// This test only works with the generic timer implementation
-#ifdef GRPC_TIMER_USE_GENERIC
-
 #include "src/core/lib/iomgr/timer_heap.h"
 
 #include <stdlib.h>
@@ -299,9 +296,3 @@ int main(int argc, char** argv) {
 
   return 0;
 }
-
-#else /* GRPC_TIMER_USE_GENERIC */
-
-int main(int argc, char** argv) { return 1; }
-
-#endif /* GRPC_TIMER_USE_GENERIC */
diff --git a/test/core/iomgr/timer_list_test.cc b/test/core/iomgr/timer_list_test.cc
index deb8c4d87e..b1d919b292 100644
--- a/test/core/iomgr/timer_list_test.cc
+++ b/test/core/iomgr/timer_list_test.cc
@@ -19,8 +19,9 @@
 #include "src/core/lib/iomgr/port.h"
 
 // This test only works with the generic timer implementation
-#ifdef GRPC_TIMER_USE_GENERIC
+#ifndef GRPC_CUSTOM_SOCKET
 
+#include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/timer.h"
 
 #include <string.h>
@@ -153,15 +154,19 @@ void destruction_test(void) {
 int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
   grpc_core::ExecCtx::GlobalInit();
+  grpc_core::ExecCtx exec_ctx;
+  grpc_determine_iomgr_platform();
+  grpc_iomgr_platform_init();
   gpr_set_log_verbosity(GPR_LOG_SEVERITY_DEBUG);
   add_test();
   destruction_test();
+  grpc_iomgr_platform_shutdown();
   grpc_core::ExecCtx::GlobalShutdown();
   return 0;
 }
 
-#else /* GRPC_TIMER_USE_GENERIC */
+#else /* GRPC_CUSTOM_SOCKET */
 
 int main(int argc, char** argv) { return 1; }
 
-#endif /* GRPC_TIMER_USE_GENERIC */
+#endif /* GRPC_CUSTOM_SOCKET */
diff --git a/test/core/iomgr/wakeup_fd_cv_test.cc b/test/core/iomgr/wakeup_fd_cv_test.cc
index 9bd7c6e47e..f297a569d2 100644
--- a/test/core/iomgr/wakeup_fd_cv_test.cc
+++ b/test/core/iomgr/wakeup_fd_cv_test.cc
@@ -225,7 +225,7 @@ int main(int argc, char** argv) {
   grpc_poll_function = &mock_poll;
   gpr_mu_init(&poll_mu);
   gpr_cv_init(&poll_cv);
-
+  grpc_determine_iomgr_platform();
   grpc_iomgr_platform_init();
   test_many_fds();
   grpc_iomgr_platform_shutdown();
diff --git a/test/core/surface/concurrent_connectivity_test.cc b/test/core/surface/concurrent_connectivity_test.cc
index c1298b6636..fbc5ec4c54 100644
--- a/test/core/surface/concurrent_connectivity_test.cc
+++ b/test/core/surface/concurrent_connectivity_test.cc
@@ -124,14 +124,13 @@ void bad_server_thread(void* vargs) {
 
   grpc_core::ExecCtx exec_ctx;
   grpc_resolved_address resolved_addr;
-  struct sockaddr_storage* addr =
-      reinterpret_cast<struct sockaddr_storage*>(resolved_addr.addr);
+  grpc_sockaddr* addr = reinterpret_cast<grpc_sockaddr*>(resolved_addr.addr);
   int port;
   grpc_tcp_server* s;
   grpc_error* error = grpc_tcp_server_create(nullptr, nullptr, &s);
   GPR_ASSERT(error == GRPC_ERROR_NONE);
   memset(&resolved_addr, 0, sizeof(resolved_addr));
-  addr->ss_family = AF_INET;
+  addr->sa_family = GRPC_AF_INET;
   error = grpc_tcp_server_add_port(s, &resolved_addr, &port);
   GPR_ASSERT(GRPC_LOG_IF_ERROR("grpc_tcp_server_add_port", error));
   GPR_ASSERT(port > 0);
diff --git a/test/core/util/test_tcp_server.cc b/test/core/util/test_tcp_server.cc
index cb2bc701fa..610a9918ce 100644
--- a/test/core/util/test_tcp_server.cc
+++ b/test/core/util/test_tcp_server.cc
@@ -17,6 +17,7 @@
  */
 
 #include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/iomgr/socket_utils.h"
 
 #include "test/core/util/test_tcp_server.h"
 
@@ -54,13 +55,13 @@ void test_tcp_server_init(test_tcp_server* server,
 
 void test_tcp_server_start(test_tcp_server* server, int port) {
   grpc_resolved_address resolved_addr;
-  struct sockaddr_in* addr =
-      reinterpret_cast<struct sockaddr_in*>(resolved_addr.addr);
+  grpc_sockaddr_in* addr =
+      reinterpret_cast<grpc_sockaddr_in*>(resolved_addr.addr);
   int port_added;
   grpc_core::ExecCtx exec_ctx;
 
-  addr->sin_family = AF_INET;
-  addr->sin_port = htons(static_cast<uint16_t>(port));
+  addr->sin_family = GRPC_AF_INET;
+  addr->sin_port = grpc_htons(static_cast<uint16_t>(port));
   memset(&addr->sin_addr, 0, sizeof(addr->sin_addr));
 
   grpc_error* error = grpc_tcp_server_create(&server->shutdown_complete,