[grpc][Gpr_To_Absl_Logging] Migrating from gpr to absl logging GPR_ASSERT (#36399)

grpc][Gpr_To_Absl_Logging] Migrating from gpr to absl logging GPR_ASSERT

Replacing GPR_ASSERT with absl CHECK

These changes have been made using string replacement

Will not be replacing all instances of CHECK with CHECK_EQ , CHECK_NE etc because there are too many callsites. Only ones which are doable using very simple regex with least chance of failure will be replaced.

Given that we have 5000+ instances of GPR_ASSERT to edit, Doing it manually is too much work for both the author and reviewer.

<!--

If you know who should review your pull request, please assign it to that
person, otherwise the pull request would get assigned randomly.

If your pull request is for a specific language, please add the appropriate
lang label.

-->

Closes #36399

COPYBARA_INTEGRATE_REVIEW=https://github.com/grpc/grpc/pull/36399 from tanvi-jagtap:tjagtap_core_end2end aeda9ecdea
PiperOrigin-RevId: 627626105

CMakeLists.txt

@@ -6431,6 +6431,7 @@ if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_POSIX)
   target_link_libraries(alts_concurrent_connectivity_test
     ${_gRPC_ALLTARGETS_LIBRARIES}
     gtest
+    absl::check
     grpc++
     grpc_test_util
   )
@@ -7607,6 +7608,7 @@ target_include_directories(bad_server_response_test
 target_link_libraries(bad_server_response_test
   ${_gRPC_ALLTARGETS_LIBRARIES}
   gtest
+  absl::check
   grpc_test_util
 )
 
@@ -7662,6 +7664,7 @@ if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
   target_link_libraries(bad_ssl_alpn_test
     ${_gRPC_ALLTARGETS_LIBRARIES}
     gtest
+    absl::check
     grpc_test_util
   )
 
@@ -7718,6 +7721,7 @@ if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
   target_link_libraries(bad_ssl_cert_test
     ${_gRPC_ALLTARGETS_LIBRARIES}
     gtest
+    absl::check
     grpc_test_util
   )
 
@@ -9038,6 +9042,7 @@ target_include_directories(cancel_ares_query_test
 target_link_libraries(cancel_ares_query_test
   ${_gRPC_ALLTARGETS_LIBRARIES}
   gtest
+  absl::check
   grpc++_test_config
   grpc++_test_util
 )
@@ -11440,6 +11445,7 @@ target_include_directories(connection_refused_test
 target_link_libraries(connection_refused_test
   ${_gRPC_ALLTARGETS_LIBRARIES}
   gtest
+  absl::check
   grpc_test_util
 )
 
@@ -12410,6 +12416,7 @@ if(_gRPC_PLATFORM_LINUX OR _gRPC_PLATFORM_MAC OR _gRPC_PLATFORM_POSIX)
   target_link_libraries(dualstack_socket_test
     ${_gRPC_ALLTARGETS_LIBRARIES}
     gtest
+    absl::check
     grpc_test_util
   )
 
@@ -14829,6 +14836,7 @@ target_include_directories(goaway_server_test
 target_link_libraries(goaway_server_test
   ${_gRPC_ALLTARGETS_LIBRARIES}
   gtest
+  absl::check
   grpc_test_util
 )
 
@@ -16353,6 +16361,7 @@ target_include_directories(h2_ssl_session_reuse_test
 target_link_libraries(h2_ssl_session_reuse_test
   ${_gRPC_ALLTARGETS_LIBRARIES}
   gtest
+  absl::check
   grpc_test_util
 )
 
@@ -16396,6 +16405,7 @@ target_include_directories(h2_tls_peer_property_external_verifier_test
 target_link_libraries(h2_tls_peer_property_external_verifier_test
   ${_gRPC_ALLTARGETS_LIBRARIES}
   gtest
+  absl::check
   grpc_test_util
 )
 
@@ -18008,6 +18018,7 @@ target_include_directories(invalid_call_argument_test
 target_link_libraries(invalid_call_argument_test
   ${_gRPC_ALLTARGETS_LIBRARIES}
   gtest
+  absl::check
   grpc_test_util
 )
 
@@ -18506,6 +18517,7 @@ target_include_directories(lame_client_test
 target_link_libraries(lame_client_test
   ${_gRPC_ALLTARGETS_LIBRARIES}
   gtest
+  absl::check
   grpc_test_util
 )
 
@@ -20321,6 +20333,7 @@ target_include_directories(no_server_test
 target_link_libraries(no_server_test
   ${_gRPC_ALLTARGETS_LIBRARIES}
   gtest
+  absl::check
   grpc_test_util
 )
 

build_autogenerated.yaml

@@ -5434,6 +5434,7 @@ targets:
   - test/core/util/fake_udp_and_tcp_server.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc++
   - grpc_test_util
   platforms:
@@ -5882,6 +5883,7 @@ targets:
   - test/core/end2end/cq_verifier.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc_test_util
 - name: bad_ssl_alpn_test
   gtest: true
@@ -5917,6 +5919,7 @@ targets:
   - test/core/util/tracer_util.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc_test_util
   platforms:
   - linux
@@ -5956,6 +5959,7 @@ targets:
   - test/core/util/tracer_util.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc_test_util
   platforms:
   - linux
@@ -6893,6 +6897,7 @@ targets:
   - test/cpp/naming/cancel_ares_query_test.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc++_test_config
   - grpc++_test_util
 - name: cancel_before_invoke_test
@@ -8286,6 +8291,7 @@ targets:
   - test/core/end2end/cq_verifier.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc_test_util
 - name: connectivity_state_test
   gtest: true
@@ -8710,6 +8716,7 @@ targets:
   - test/core/end2end/dualstack_socket_test.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc_test_util
   platforms:
   - linux
@@ -10259,6 +10266,7 @@ targets:
   - test/core/end2end/goaway_server_test.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc_test_util
 - name: google_c2p_resolver_test
   gtest: true
@@ -10955,6 +10963,7 @@ targets:
   - test/core/end2end/h2_ssl_session_reuse_test.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc_test_util
 - name: h2_tls_peer_property_external_verifier_test
   gtest: true
@@ -10967,6 +10976,7 @@ targets:
   - test/core/end2end/h2_tls_peer_property_external_verifier_test.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc_test_util
 - name: handle_tests
   gtest: true
@@ -11816,6 +11826,7 @@ targets:
   - test/core/end2end/invalid_call_argument_test.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc_test_util
 - name: invoke_large_request_test
   gtest: true
@@ -12096,6 +12107,7 @@ targets:
   - test/core/surface/lame_client_test.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc_test_util
 - name: large_metadata_test
   gtest: true
@@ -13202,6 +13214,7 @@ targets:
   - test/core/end2end/no_server_test.cc
   deps:
   - gtest
+  - absl/log:check
   - grpc_test_util
 - name: nonblocking_test
   gtest: true

test/core/end2end/BUILD

@@ -27,6 +27,7 @@ grpc_cc_library(
     external_deps = [
         "absl/container:flat_hash_map",
         "absl/functional:any_invocable",
+        "absl/log:check",
         "absl/strings",
         "absl/strings:str_format",
         "absl/types:variant",
@@ -118,6 +119,7 @@ grpc_cc_library(
     ],
     external_deps = [
         "absl/functional:any_invocable",
+        "absl/log:check",
         "absl/memory",
         "absl/meta:type_traits",
         "absl/random",
@@ -200,6 +202,7 @@ grpc_cc_library(
     external_deps = [
         "absl/base:core_headers",
         "absl/functional:any_invocable",
+        "absl/log:check",
         "absl/meta:type_traits",
         "absl/random",
         "absl/status",
@@ -264,6 +267,7 @@ grpc_cc_library(
     ],
     external_deps = [
         "absl/functional:any_invocable",
+        "absl/log:check",
         "absl/strings",
         "absl/types:optional",
         "gtest",
@@ -496,6 +500,7 @@ grpc_core_end2end_test(name = "write_buffering_at_end")
 grpc_cc_test(
     name = "bad_server_response_test",
     srcs = ["bad_server_response_test.cc"],
+    external_deps = ["absl/log:check"],
     language = "C++",
     deps = [
         "cq_verifier",
@@ -518,6 +523,7 @@ grpc_cc_test(
 grpc_cc_test(
     name = "connection_refused_test",
     srcs = ["connection_refused_test.cc"],
+    external_deps = ["absl/log:check"],
     language = "C++",
     deps = [
         "cq_verifier",
@@ -534,6 +540,7 @@ grpc_cc_test(
     name = "dualstack_socket_test",
     srcs = ["dualstack_socket_test.cc"],
     external_deps = [
+        "absl/log:check",
         "absl/status:statusor",
         "absl/strings",
         "absl/strings:str_format",
@@ -557,6 +564,7 @@ grpc_cc_test(
     name = "goaway_server_test",
     srcs = ["goaway_server_test.cc"],
     external_deps = [
+        "absl/log:check",
         "absl/status",
         "absl/status:statusor",
         "absl/strings",
@@ -588,6 +596,7 @@ grpc_cc_test(
 grpc_cc_test(
     name = "invalid_call_argument_test",
     srcs = ["invalid_call_argument_test.cc"],
+    external_deps = ["absl/log:check"],
     language = "C++",
     deps = [
         "cq_verifier",
@@ -613,6 +622,7 @@ grpc_cc_test(
     name = "no_server_test",
     srcs = ["no_server_test.cc"],
     external_deps = [
+        "absl/log:check",
         "absl/status",
         "absl/status:statusor",
         "absl/time",
@@ -641,6 +651,7 @@ grpc_cc_test(
     ],
     external_deps = [
         "absl/functional:any_invocable",
+        "absl/log:check",
         "absl/memory",
         "absl/meta:type_traits",
         "absl/strings",
@@ -682,6 +693,7 @@ grpc_cc_test(
         "//src/core/tsi/test_creds:server1.pem",
     ],
     external_deps = [
+        "absl/log:check",
         "absl/types:optional",
         "gtest",
     ],
@@ -712,6 +724,7 @@ grpc_cc_test(
         "//src/core/tsi/test_creds:server1.pem",
     ],
     external_deps = [
+        "absl/log:check",
         "absl/types:optional",
         "gtest",
     ],

test/core/end2end/bad_server_response_test.cc

@@ -24,6 +24,8 @@
 #include <string>
 #include <vector>
 
+#include "absl/log/check.h"
+
 #include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
@@ -110,13 +112,13 @@ static grpc_closure on_write;
 static void* tag(intptr_t t) { return reinterpret_cast<void*>(t); }
 
 static void done_write(void* /*arg*/, grpc_error_handle error) {
-  GPR_ASSERT(error.ok());
+  CHECK_OK(error);
   gpr_atm_rel_store(&state.done_atm, 1);
 }
 
 static void done_writing_settings_frame(void* /* arg */,
                                         grpc_error_handle error) {
-  GPR_ASSERT(error.ok());
+  CHECK_OK(error);
   grpc_endpoint_read(state.tcp, &state.temp_incoming_buffer, &on_read,
                      /*urgent=*/false, /*min_progress_size=*/1);
 }
@@ -255,15 +257,15 @@ static void start_rpc(int target_port, grpc_status_code expected_status,
   error = grpc_call_start_batch(state.call, ops, static_cast<size_t>(op - ops),
                                 tag(1), nullptr);
 
-  GPR_ASSERT(GRPC_CALL_OK == error);
+  CHECK_EQ(error, GRPC_CALL_OK);
 
   cqv.Expect(tag(1), true);
   cqv.Verify();
 
-  GPR_ASSERT(status == expected_status);
+  CHECK_EQ(status, expected_status);
   if (expected_detail != nullptr) {
-    GPR_ASSERT(-1 != grpc_slice_slice(details, grpc_slice_from_static_string(
-                                                   expected_detail)));
+    CHECK_NE(-1, grpc_slice_slice(
+                     details, grpc_slice_from_static_string(expected_detail)));
   }
 
   grpc_metadata_array_destroy(&initial_metadata_recv);
@@ -353,7 +355,7 @@ static void run_test(bool http2_response, bool send_settings,
   thdptr->Join();
   state.on_connect_done->WaitForNotification();
   // Proof that the server accepted the TCP connection.
-  GPR_ASSERT(state.connection_attempt_made == true);
+  CHECK_EQ(state.connection_attempt_made, true);
   // clean up
   grpc_endpoint_shutdown(state.tcp, GRPC_ERROR_CREATE("Test Shutdown"));
   grpc_endpoint_destroy(state.tcp);

test/core/end2end/connection_refused_test.cc

@@ -20,6 +20,8 @@
 
 #include <string>
 
+#include "absl/log/check.h"
+
 #include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
@@ -60,7 +62,7 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
   // if using service config, create channel args
   grpc_channel_args* args = nullptr;
   if (use_service_config) {
-    GPR_ASSERT(wait_for_ready);
+    CHECK(wait_for_ready);
     grpc_arg arg;
     arg.type = GRPC_ARG_STRING;
     arg.key = const_cast<char*>(GRPC_ARG_SERVICE_CONFIG);
@@ -106,17 +108,17 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch(call, ops, (size_t)(op - ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_call_start_batch(call, ops, (size_t)(op - ops),
+                                 grpc_core::CqVerifier::tag(1), nullptr));
   // verify that all tags get completed
   cqv.Expect(grpc_core::CqVerifier::tag(1), true);
   cqv.Verify();
 
   if (wait_for_ready) {
-    GPR_ASSERT(status == GRPC_STATUS_DEADLINE_EXCEEDED);
+    CHECK_EQ(status, GRPC_STATUS_DEADLINE_EXCEEDED);
   } else {
-    GPR_ASSERT(status == GRPC_STATUS_UNAVAILABLE);
+    CHECK_EQ(status, GRPC_STATUS_UNAVAILABLE);
   }
 
   grpc_completion_queue_shutdown(cq);

test/core/end2end/cq_verifier.cc

@@ -28,6 +28,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -163,9 +164,9 @@ int byte_buffer_eq_slice(grpc_byte_buffer* bb, grpc_slice b) {
   if (bb->data.raw.compression > GRPC_COMPRESS_NONE) {
     grpc_slice_buffer decompressed_buffer;
     grpc_slice_buffer_init(&decompressed_buffer);
-    GPR_ASSERT(grpc_msg_decompress(bb->data.raw.compression,
-                                   &bb->data.raw.slice_buffer,
-                                   &decompressed_buffer));
+    CHECK(grpc_msg_decompress(bb->data.raw.compression,
+                              &bb->data.raw.slice_buffer,
+                              &decompressed_buffer));
     grpc_byte_buffer* rbb = grpc_raw_byte_buffer_create(
         decompressed_buffer.slices, decompressed_buffer.count);
     int ret_val = raw_byte_buffer_eq_slice(rbb, b);
@@ -427,7 +428,7 @@ void CqVerifier::VerifyEmpty(Duration timeout, SourceLocation location) {
   }
   const gpr_timespec deadline =
       gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC), timeout.as_timespec());
-  GPR_ASSERT(expectations_.empty());
+  CHECK(expectations_.empty());
   grpc_event ev = Step(deadline);
   if (ev.type != GRPC_QUEUE_TIMEOUT) {
     FailUnexpectedEvent(&ev, location);

test/core/end2end/dualstack_socket_test.cc

@@ -20,6 +20,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/log/check.h"
 #include "absl/status/statusor.h"
 
 #include <grpc/impl/propagation_bits.h>
@@ -121,13 +122,13 @@ void test_connect(const char* server_host, const char* client_host, int port,
   grpc_server_register_completion_queue(server, cq, nullptr);
   grpc_server_credentials* server_creds =
       grpc_insecure_server_credentials_create();
-  GPR_ASSERT((got_port = grpc_server_add_http2_port(
-                  server, server_hostport.c_str(), server_creds)) > 0);
+  CHECK((got_port = grpc_server_add_http2_port(server, server_hostport.c_str(),
+                                               server_creds)) > 0);
   grpc_server_credentials_release(server_creds);
   if (port == 0) {
     port = got_port;
   } else {
-    GPR_ASSERT(port == got_port);
+    CHECK_EQ(port, got_port);
   }
   grpc_server_start(server);
   grpc_core::CqVerifier cqv(cq);
@@ -171,7 +172,7 @@ void test_connect(const char* server_host, const char* client_host, int port,
   c = grpc_channel_create_call(client, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
                                grpc_slice_from_static_string("/foo"), &host,
                                deadline, nullptr);
-  GPR_ASSERT(c);
+  CHECK(c);
 
   memset(ops, 0, sizeof(ops));
   op = ops;
@@ -198,14 +199,14 @@ void test_connect(const char* server_host, const char* client_host, int port,
   op++;
   error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops),
                                 grpc_core::CqVerifier::tag(1), nullptr);
-  GPR_ASSERT(GRPC_CALL_OK == error);
+  CHECK_EQ(error, GRPC_CALL_OK);
 
   if (expect_ok) {
     // Check for a successful request.
     error = grpc_server_request_call(server, &s, &call_details,
                                      &request_metadata_recv, cq, cq,
                                      grpc_core::CqVerifier::tag(101));
-    GPR_ASSERT(GRPC_CALL_OK == error);
+    CHECK_EQ(error, GRPC_CALL_OK);
     cqv.Expect(grpc_core::CqVerifier::tag(101), true);
     cqv.Verify();
 
@@ -228,7 +229,7 @@ void test_connect(const char* server_host, const char* client_host, int port,
     op++;
     error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops),
                                   grpc_core::CqVerifier::tag(102), nullptr);
-    GPR_ASSERT(GRPC_CALL_OK == error);
+    CHECK_EQ(error, GRPC_CALL_OK);
 
     cqv.Expect(grpc_core::CqVerifier::tag(102), true);
     cqv.Expect(grpc_core::CqVerifier::tag(1), true);
@@ -238,12 +239,11 @@ void test_connect(const char* server_host, const char* client_host, int port,
     gpr_log(GPR_DEBUG, "got peer: '%s'", peer);
     gpr_free(peer);
 
-    GPR_ASSERT(status == GRPC_STATUS_UNIMPLEMENTED);
-    GPR_ASSERT(0 == grpc_slice_str_cmp(details, "xyz"));
-    GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.method, "/foo"));
-    GPR_ASSERT(0 ==
-               grpc_slice_str_cmp(call_details.host, "foo.test.google.fr"));
-    GPR_ASSERT(was_cancelled == 0);
+    CHECK_EQ(status, GRPC_STATUS_UNIMPLEMENTED);
+    CHECK_EQ(grpc_slice_str_cmp(details, "xyz"), 0);
+    CHECK_EQ(grpc_slice_str_cmp(call_details.method, "/foo"), 0);
+    CHECK_EQ(grpc_slice_str_cmp(call_details.host, "foo.test.google.fr"), 0);
+    CHECK_EQ(was_cancelled, 0);
 
     grpc_call_unref(s);
   } else {
@@ -253,7 +253,7 @@ void test_connect(const char* server_host, const char* client_host, int port,
 
     gpr_log(GPR_INFO, "status: %d (expected: %d)", status,
             GRPC_STATUS_UNAVAILABLE);
-    GPR_ASSERT(status == GRPC_STATUS_UNAVAILABLE);
+    CHECK_EQ(status, GRPC_STATUS_UNAVAILABLE);
   }
 
   grpc_call_unref(c);

test/core/end2end/end2end_test_fuzzer.cc

@@ -26,6 +26,8 @@
 
 #include <gtest/gtest.h>
 
+#include "absl/log/check.h"
+
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/log.h>
 
@@ -133,7 +135,7 @@ void RunEnd2endFuzzer(const core_end2end_test_fuzzer::Msg& msg) {
   test->SetUp();
   test->RunTest();
   test->TearDown();
-  GPR_ASSERT(!::testing::Test::HasFailure());
+  CHECK(!::testing::Test::HasFailure());
 }
 
 }  // namespace grpc_core

test/core/end2end/end2end_test_suites.cc

@@ -26,6 +26,7 @@
 
 #include "absl/base/thread_annotations.h"
 #include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
@@ -109,7 +110,7 @@ void ProcessAuthFailure(void* state, grpc_auth_context* /*ctx*/,
                         const grpc_metadata* /*md*/, size_t /*md_count*/,
                         grpc_process_auth_metadata_done_cb cb,
                         void* user_data) {
-  GPR_ASSERT(state == nullptr);
+  CHECK_EQ(state, nullptr);
   cb(user_data, nullptr, 0, nullptr, 0, GRPC_STATUS_UNAUTHENTICATED, nullptr);
 }
 
@@ -134,8 +135,7 @@ class CensusFixture : public CoreTestFixture {
     auto* server = grpc_server_create(
         args.Set(GRPC_ARG_ENABLE_CENSUS, true).ToC().get(), nullptr);
     grpc_server_register_completion_queue(server, cq, nullptr);
-    GPR_ASSERT(
-        grpc_server_add_http2_port(server, localaddr_.c_str(), server_creds));
+    CHECK(grpc_server_add_http2_port(server, localaddr_.c_str(), server_creds));
     grpc_server_credentials_release(server_creds);
     pre_server_start(server);
     grpc_server_start(server);
@@ -168,8 +168,7 @@ class CompressionFixture : public CoreTestFixture {
     grpc_server_register_completion_queue(server, cq, nullptr);
     grpc_server_credentials* server_creds =
         grpc_insecure_server_credentials_create();
-    GPR_ASSERT(
-        grpc_server_add_http2_port(server, localaddr_.c_str(), server_creds));
+    CHECK(grpc_server_add_http2_port(server, localaddr_.c_str(), server_creds));
     grpc_server_credentials_release(server_creds);
     pre_server_start(server);
     grpc_server_start(server);
@@ -281,13 +280,11 @@ class FdFixture : public CoreTestFixture {
     int flags;
     grpc_create_socketpair_if_unix(sv);
     flags = fcntl(sv[0], F_GETFL, 0);
-    GPR_ASSERT(fcntl(sv[0], F_SETFL, flags | O_NONBLOCK) == 0);
+    CHECK_EQ(fcntl(sv[0], F_SETFL, flags | O_NONBLOCK), 0);
     flags = fcntl(sv[1], F_GETFL, 0);
-    GPR_ASSERT(fcntl(sv[1], F_SETFL, flags | O_NONBLOCK) == 0);
-    GPR_ASSERT(grpc_set_socket_no_sigpipe_if_possible(sv[0]) ==
-               absl::OkStatus());
-    GPR_ASSERT(grpc_set_socket_no_sigpipe_if_possible(sv[1]) ==
-               absl::OkStatus());
+    CHECK_EQ(fcntl(sv[1], F_SETFL, flags | O_NONBLOCK), 0);
+    CHECK(grpc_set_socket_no_sigpipe_if_possible(sv[0]) == absl::OkStatus());
+    CHECK(grpc_set_socket_no_sigpipe_if_possible(sv[1]) == absl::OkStatus());
   }
 
   int fd_pair_[2];
@@ -315,7 +312,7 @@ class HttpProxyFilter : public CoreTestFixture {
     grpc_server_register_completion_queue(server, cq, nullptr);
     grpc_server_credentials* server_creds =
         grpc_insecure_server_credentials_create();
-    GPR_ASSERT(
+    CHECK(
         grpc_server_add_http2_port(server, server_addr_.c_str(), server_creds));
     grpc_server_credentials_release(server_creds);
     pre_server_start(server);
@@ -342,7 +339,7 @@ class HttpProxyFilter : public CoreTestFixture {
         server_addr_.c_str(), creds,
         args.Set(GRPC_ARG_HTTP_PROXY, proxy_uri).ToC().get());
     grpc_channel_credentials_release(creds);
-    GPR_ASSERT(client);
+    CHECK(client);
     return client;
   }
 
@@ -364,7 +361,7 @@ class ProxyFixture : public CoreTestFixture {
     grpc_server* s = grpc_server_create(server_args, nullptr);
     grpc_server_credentials* server_creds =
         grpc_insecure_server_credentials_create();
-    GPR_ASSERT(grpc_server_add_http2_port(s, port, server_creds));
+    CHECK(grpc_server_add_http2_port(s, port, server_creds));
     grpc_server_credentials_release(server_creds);
     return s;
   }
@@ -384,7 +381,7 @@ class ProxyFixture : public CoreTestFixture {
     grpc_server_register_completion_queue(server, cq, nullptr);
     grpc_server_credentials* server_creds =
         grpc_insecure_server_credentials_create();
-    GPR_ASSERT(grpc_server_add_http2_port(
+    CHECK(grpc_server_add_http2_port(
         server, grpc_end2end_proxy_get_server_port(proxy_), server_creds));
     grpc_server_credentials_release(server_creds);
     pre_server_start(server);
@@ -398,7 +395,7 @@ class ProxyFixture : public CoreTestFixture {
     auto* client = grpc_channel_create(
         grpc_end2end_proxy_get_client_target(proxy_), creds, args.ToC().get());
     grpc_channel_credentials_release(creds);
-    GPR_ASSERT(client);
+    CHECK(client);
     return client;
   }
   const grpc_end2end_proxy_def proxy_def_ = {CreateProxyServer,
@@ -424,7 +421,7 @@ class SslProxyFixture : public CoreTestFixture {
                                                     server_cert.c_str()};
     grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
         nullptr, &pem_key_cert_pair, 1, 0, nullptr);
-    GPR_ASSERT(grpc_server_add_http2_port(s, port, ssl_creds));
+    CHECK(grpc_server_add_http2_port(s, port, ssl_creds));
     grpc_server_credentials_release(ssl_creds);
     return s;
   }
@@ -466,7 +463,7 @@ class SslProxyFixture : public CoreTestFixture {
 
     auto* server = grpc_server_create(args.ToC().get(), nullptr);
     grpc_server_register_completion_queue(server, cq, nullptr);
-    GPR_ASSERT(grpc_server_add_http2_port(
+    CHECK(grpc_server_add_http2_port(
         server, grpc_end2end_proxy_get_server_port(proxy_), ssl_creds));
     grpc_server_credentials_release(ssl_creds);
     pre_server_start(server);
@@ -483,7 +480,7 @@ class SslProxyFixture : public CoreTestFixture {
         args.Set(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, "foo.test.google.fr")
             .ToC()
             .get());
-    GPR_ASSERT(client != nullptr);
+    CHECK_NE(client, nullptr);
     grpc_channel_credentials_release(ssl_creds);
     return client;
   }
@@ -537,7 +534,7 @@ class ChaoticGoodFixture final : public CoreTestFixture {
       absl::AnyInvocable<void(grpc_server*)>& pre_server_start) override {
     auto* server = grpc_server_create(args.ToC().get(), nullptr);
     grpc_server_register_completion_queue(server, cq, nullptr);
-    GPR_ASSERT(grpc_server_add_chaotic_good_port(server, localaddr_.c_str()));
+    CHECK(grpc_server_add_chaotic_good_port(server, localaddr_.c_str()));
     pre_server_start(server);
     grpc_server_start(server);
     return server;

test/core/end2end/end2end_tests.cc

@@ -22,6 +22,7 @@
 #include <regex>
 #include <tuple>
 
+#include "absl/log/check.h"
 #include "absl/memory/memory.h"
 #include "absl/random/random.h"
 
@@ -119,8 +120,8 @@ void CoreEnd2endTest::TearDown() {
       gpr_log(GPR_ERROR, "Timeout in waiting for gRPC shutdown");
     }
   }
-  GPR_ASSERT(client_ == nullptr);
-  GPR_ASSERT(server_ == nullptr);
+  CHECK_EQ(client_, nullptr);
+  CHECK_EQ(server_, nullptr);
   initialized_ = false;
 }
 
@@ -151,20 +152,20 @@ std::string CoreEnd2endTest::IncomingMessage::payload() const {
   if (payload_->data.raw.compression > GRPC_COMPRESS_NONE) {
     grpc_slice_buffer decompressed_buffer;
     grpc_slice_buffer_init(&decompressed_buffer);
-    GPR_ASSERT(grpc_msg_decompress(payload_->data.raw.compression,
+    CHECK(grpc_msg_decompress(payload_->data.raw.compression,
                                    &payload_->data.raw.slice_buffer,
                                    &decompressed_buffer));
     grpc_byte_buffer* rbb = grpc_raw_byte_buffer_create(
         decompressed_buffer.slices, decompressed_buffer.count);
     grpc_byte_buffer_reader reader;
-    GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, rbb));
+    CHECK(grpc_byte_buffer_reader_init(&reader, rbb));
     out = Slice(grpc_byte_buffer_reader_readall(&reader));
     grpc_byte_buffer_reader_destroy(&reader);
     grpc_byte_buffer_destroy(rbb);
     grpc_slice_buffer_destroy(&decompressed_buffer);
   } else {
     grpc_byte_buffer_reader reader;
-    GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, payload_));
+    CHECK(grpc_byte_buffer_reader_init(&reader, payload_));
     out = Slice(grpc_byte_buffer_reader_readall(&reader));
     grpc_byte_buffer_reader_destroy(&reader);
   }
@@ -322,7 +323,7 @@ CoreEnd2endTest::Call CoreEnd2endTest::ClientCallBuilder::Create() {
 CoreEnd2endTest::ServerRegisteredMethod::ServerRegisteredMethod(
     CoreEnd2endTest* test, absl::string_view name,
     grpc_server_register_method_payload_handling payload_handling) {
-  GPR_ASSERT(test->server_ == nullptr);
+  CHECK_EQ(test->server_, nullptr);
   test->pre_server_start_ = [old = std::move(test->pre_server_start_),
                              handle = handle_, name = std::string(name),
                              payload_handling](grpc_server* server) mutable {
@@ -374,14 +375,14 @@ void CoreEnd2endTestRegistry::RegisterTest(absl::string_view suite,
                                            SourceLocation) {
   if (absl::StartsWith(name, "DISABLED_")) return;
   auto& tests = tests_by_suite_[suite];
-  GPR_ASSERT(tests.count(name) == 0);
+  CHECK_EQ(tests.count(name), 0u);
   tests[name] = std::move(make_test);
 }
 
 void CoreEnd2endTestRegistry::RegisterSuite(
     absl::string_view suite, std::vector<const CoreTestConfiguration*> configs,
     SourceLocation) {
-  GPR_ASSERT(suites_.count(suite) == 0);
+  CHECK_EQ(suites_.count(suite), 0u);
   suites_[suite] = std::move(configs);
 }
 

test/core/end2end/end2end_tests.h

@@ -32,6 +32,7 @@
 #include <vector>
 
 #include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
 #include "absl/memory/memory.h"
 #include "absl/meta/type_traits.h"
 #include "absl/strings/str_cat.h"
@@ -640,7 +641,7 @@ class CoreEnd2endTest : public ::testing::Test {
     if (client_ != nullptr) ShutdownAndDestroyClient();
     auto& f = fixture();
     client_ = f.MakeClient(args, cq_);
-    GPR_ASSERT(client_ != nullptr);
+    CHECK_NE(client_, nullptr);
   }
   // Initialize the server.
   // If called, then InitClient must be called to create a client (otherwise one
@@ -650,7 +651,7 @@ class CoreEnd2endTest : public ::testing::Test {
     if (server_ != nullptr) ShutdownAndDestroyServer();
     auto& f = fixture();
     server_ = f.MakeServer(args, cq_, pre_server_start_);
-    GPR_ASSERT(server_ != nullptr);
+    CHECK_NE(server_, nullptr);
   }
   // Remove the client.
   void ShutdownAndDestroyClient() {
@@ -728,7 +729,7 @@ class CoreEnd2endTest : public ::testing::Test {
   }
 
   void SetPostGrpcInitFunc(absl::AnyInvocable<void()> fn) {
-    GPR_ASSERT(fixture_ == nullptr);
+    CHECK(fixture_ == nullptr);
     post_grpc_init_func_ = std::move(fn);
   }
 

test/core/end2end/fuzzers/BUILD

@@ -34,7 +34,10 @@ grpc_cc_library(
     name = "fuzzing_common",
     srcs = ["fuzzing_common.cc"],
     hdrs = ["fuzzing_common.h"],
-    external_deps = ["absl/strings"],
+    external_deps = [
+        "absl/log:check",
+        "absl/strings",
+    ],
     deps = [
         "api_fuzzer_proto",
         "//:gpr",
@@ -47,6 +50,7 @@ grpc_proto_fuzzer(
     name = "api_fuzzer",
     srcs = ["api_fuzzer.cc"],
     corpus = "api_fuzzer_corpus",
+    external_deps = ["absl/log:check"],
     language = "C++",
     proto = None,
     tags = [
@@ -102,6 +106,7 @@ grpc_proto_fuzzer(
     name = "client_fuzzer",
     srcs = ["client_fuzzer.cc"],
     corpus = "client_fuzzer_corpus",
+    external_deps = ["absl/log:check"],
     language = "C++",
     proto = None,
     tags = ["no_windows"],
@@ -125,6 +130,7 @@ grpc_cc_library(
     name = "server_fuzzer",
     srcs = ["server_fuzzer.cc"],
     hdrs = ["server_fuzzer.h"],
+    external_deps = ["absl/log:check"],
     deps = [
         "fuzzer_input_proto",
         "fuzzing_common",
@@ -161,6 +167,7 @@ grpc_proto_fuzzer(
     name = "server_fuzzer_chaotic_good",
     srcs = ["server_fuzzer_chaotic_good.cc"],
     corpus = "server_fuzzer_chaotic_good_corpus",
+    external_deps = ["absl/log:check"],
     language = "C++",
     proto = None,
     tags = [

test/core/end2end/fuzzers/api_fuzzer.cc

@@ -27,6 +27,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_join.h"
@@ -92,8 +93,7 @@ static void finish_resolve(addr_req r) {
   if (0 == strcmp(r.addr, "server")) {
     *r.addresses = std::make_unique<grpc_core::EndpointAddressesList>();
     grpc_resolved_address fake_resolved_address;
-    GPR_ASSERT(
-        grpc_parse_ipv4_hostport("1.2.3.4:5", &fake_resolved_address, false));
+    CHECK(grpc_parse_ipv4_hostport("1.2.3.4:5", &fake_resolved_address, false));
     (*r.addresses)
         ->emplace_back(fake_resolved_address, grpc_core::ChannelArgs());
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, r.on_done, absl::OkStatus());
@@ -231,7 +231,7 @@ grpc_ares_request* my_dns_lookup_ares(
 }
 
 static void my_cancel_ares_request(grpc_ares_request* request) {
-  GPR_ASSERT(request == nullptr);
+  CHECK_EQ(request, nullptr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -404,13 +404,13 @@ ApiFuzzer::ApiFuzzer(const fuzzing_event_engine::Actions& actions)
   grpc_dns_lookup_hostname_ares = my_dns_lookup_ares;
   grpc_cancel_ares_request = my_cancel_ares_request;
 
-  GPR_ASSERT(channel_ == nullptr);
-  GPR_ASSERT(server_ == nullptr);
+  CHECK_EQ(channel_, nullptr);
+  CHECK_EQ(server_, nullptr);
 }
 
 ApiFuzzer::~ApiFuzzer() {
-  GPR_ASSERT(channel_ == nullptr);
-  GPR_ASSERT(server_ == nullptr);
+  CHECK_EQ(channel_, nullptr);
+  CHECK_EQ(server_, nullptr);
 }
 
 void ApiFuzzer::Tick() {
@@ -458,7 +458,7 @@ ApiFuzzer::Result ApiFuzzer::CreateChannel(
                             creds, args.ToC().get());
     grpc_channel_credentials_release(creds);
   }
-  GPR_ASSERT(channel_ != nullptr);
+  CHECK_NE(channel_, nullptr);
   channel_force_delete_ = false;
   return Result::kComplete;
 }
@@ -473,7 +473,7 @@ ApiFuzzer::Result ApiFuzzer::CreateServer(
     ChannelArgs args = testing::CreateChannelArgsFromFuzzingConfiguration(
         create_server.channel_args(), fuzzing_env);
     server_ = grpc_server_create(args.ToC().get(), nullptr);
-    GPR_ASSERT(server_ != nullptr);
+    CHECK_NE(server_, nullptr);
     grpc_server_register_completion_queue(server_, cq(), nullptr);
     for (const auto& http2_port : create_server.http2_ports()) {
       auto* creds = ReadServerCreds(http2_port.server_creds());

test/core/end2end/fuzzers/client_fuzzer.cc

@@ -14,6 +14,7 @@
 
 #include <string>
 
+#include "absl/log/check.h"
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
 
@@ -73,7 +74,7 @@ class ClientFuzzer final : public BasicFuzzer {
                    ->c_ptr();
   }
 
-  ~ClientFuzzer() { GPR_ASSERT(channel_ == nullptr); }
+  ~ClientFuzzer() { CHECK_EQ(channel_, nullptr); }
 
  private:
   Result CreateChannel(const api_fuzzer::CreateChannel&) override {

test/core/end2end/fuzzers/fuzzing_common.cc

@@ -23,6 +23,7 @@
 #include <memory>
 #include <new>
 
+#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 
@@ -58,7 +59,7 @@ int force_experiments = []() {
 namespace testing {
 
 static void free_non_null(void* p) {
-  GPR_ASSERT(p != nullptr);
+  CHECK_NE(p, nullptr);
   gpr_free(p);
 }
 
@@ -92,7 +93,7 @@ class Call : public std::enable_shared_from_this<Call> {
   }
 
   void SetCall(grpc_call* call) {
-    GPR_ASSERT(call_ == nullptr);
+    CHECK_EQ(call_, nullptr);
     call_ = call;
   }
 
@@ -273,10 +274,10 @@ class Call : public std::enable_shared_from_this<Call> {
     ++pending_ops_;
     auto self = shared_from_this();
     return MakeValidator([self](bool success) {
-      GPR_ASSERT(self->pending_ops_ > 0);
+      CHECK_GT(self->pending_ops_, 0);
       --self->pending_ops_;
       if (success) {
-        GPR_ASSERT(self->call_ != nullptr);
+        CHECK_NE(self->call_, nullptr);
         self->type_ = CallType::SERVER;
       } else {
         self->type_ = CallType::TOMBSTONED;
@@ -335,7 +336,7 @@ Validator* ValidateConnectivityWatch(gpr_timespec deadline, int* counter) {
   return MakeValidator([deadline, counter](bool success) {
     if (!success) {
       auto now = gpr_now(deadline.clock_type);
-      GPR_ASSERT(gpr_time_cmp(now, deadline) >= 0);
+      CHECK_GE(gpr_time_cmp(now, deadline), 0);
     }
     --*counter;
   });
@@ -368,13 +369,13 @@ BasicFuzzer::BasicFuzzer(const fuzzing_event_engine::Actions& actions)
 }
 
 BasicFuzzer::~BasicFuzzer() {
-  GPR_ASSERT(ActiveCall() == nullptr);
-  GPR_ASSERT(calls_.empty());
+  CHECK_EQ(ActiveCall(), nullptr);
+  CHECK(calls_.empty());
 
   engine_->TickUntilIdle();
 
   grpc_completion_queue_shutdown(cq_);
-  GPR_ASSERT(PollCq() == Result::kComplete);
+  CHECK(PollCq() == Result::kComplete);
   grpc_completion_queue_destroy(cq_);
 
   grpc_shutdown_blocking();
@@ -735,7 +736,7 @@ void BasicFuzzer::TryShutdown() {
   ShutdownCalls();
 
   grpc_timer_manager_tick();
-  GPR_ASSERT(PollCq() == Result::kPending);
+  CHECK(PollCq() == Result::kPending);
 }
 
 void BasicFuzzer::Run(absl::Span<const api_fuzzer::Action* const> actions) {

test/core/end2end/fuzzers/fuzzing_common.h

@@ -28,6 +28,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "absl/types/span.h"
 
 #include <grpc/grpc.h>
@@ -63,7 +64,7 @@ inline Validator* MakeValidator(std::function<void(bool)> impl) {
 
 inline Validator* AssertSuccessAndDecrement(int* counter) {
   return MakeValidator([counter](bool success) {
-    GPR_ASSERT(success);
+    CHECK(success);
     --*counter;
   });
 }
@@ -99,7 +100,7 @@ class BasicFuzzer {
   void ShutdownCalls();
   void ResetServerState() {
     server_shutdown_ = false;
-    GPR_ASSERT(pending_server_shutdowns_ == 0);
+    CHECK_EQ(pending_server_shutdowns_, 0);
   }
 
   // Poll any created completion queue to drive the RPC forward.

test/core/end2end/fuzzers/server_fuzzer.cc

@@ -14,6 +14,7 @@
 
 #include <string>
 
+#include "absl/log/check.h"
 #include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
@@ -66,7 +67,7 @@ class ServerFuzzer final : public BasicFuzzer {
     }
   }
 
-  ~ServerFuzzer() { GPR_ASSERT(server_ == nullptr); }
+  ~ServerFuzzer() { CHECK_EQ(server_, nullptr); }
 
  private:
   Result CreateChannel(
@@ -103,7 +104,7 @@ void RunServerFuzzer(
     ForceEnableExperiment("event_engine_listener", true);
     return 42;
   }();
-  GPR_ASSERT(once == 42);  // avoid unused variable warning
+  CHECK_EQ(once, 42);  // avoid unused variable warning
   ApplyFuzzConfigVars(msg.config_vars());
   TestOnlyReloadExperimentsFromConfigVariables();
   testing::ServerFuzzer(msg, server_setup).Run(msg.api_actions());

test/core/end2end/fuzzers/server_fuzzer_chaotic_good.cc

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "absl/log/check.h"
+
 #include <grpc/grpc_security.h>
 
 #include "src/core/ext/transport/chaotic_good/server/chaotic_good_server.h"
@@ -33,8 +35,8 @@ DEFINE_PROTO_FUZZER(const fuzzer_input::Msg& msg) {
             grpc_event_engine::experimental::URIToResolvedAddress(
                 absl::StrCat("ipv4:0.0.0.0:", port_num))
                 .value());
-        GPR_ASSERT(port.ok());
-        GPR_ASSERT(port.value() == port_num);
+        CHECK_OK(port);
+        CHECK_EQ(port.value(), port_num);
         grpc_core::Server::FromC(server)->AddListener(
             grpc_core::OrphanablePtr<
                 grpc_core::chaotic_good::ChaoticGoodServerListener>(listener));

test/core/end2end/goaway_server_test.cc

@@ -26,6 +26,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -293,9 +294,9 @@ int main(int argc, char** argv) {
   op->flags = GRPC_INITIAL_METADATA_WAIT_FOR_READY;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch(call1, ops, (size_t)(op - ops),
-                                   grpc_core::CqVerifier::tag(0x101), nullptr));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_call_start_batch(call1, ops, (size_t)(op - ops),
+                                 grpc_core::CqVerifier::tag(0x101), nullptr));
   // and receive status to probe termination
   memset(ops, 0, sizeof(ops));
   op = ops;
@@ -306,9 +307,9 @@ int main(int argc, char** argv) {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch(call1, ops, (size_t)(op - ops),
-                                   grpc_core::CqVerifier::tag(0x102), nullptr));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_call_start_batch(call1, ops, (size_t)(op - ops),
+                                 grpc_core::CqVerifier::tag(0x102), nullptr));
 
   // bring a server up on the first port
   grpc_server* server1 = grpc_server_create(nullptr, nullptr);
@@ -322,10 +323,10 @@ int main(int argc, char** argv) {
 
   // request a call to the server
   grpc_call* server_call1;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_server_request_call(server1, &server_call1, &request_details1,
-                                      &request_metadata1, cq, cq,
-                                      grpc_core::CqVerifier::tag(0x301)));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_server_request_call(server1, &server_call1, &request_details1,
+                                    &request_metadata1, cq, cq,
+                                    grpc_core::CqVerifier::tag(0x301)));
 
   set_resolve_port(port1);
 
@@ -334,8 +335,7 @@ int main(int argc, char** argv) {
   cqv.Expect(grpc_core::CqVerifier::tag(0x301), true);
   cqv.Verify();
 
-  GPR_ASSERT(GRPC_CHANNEL_READY ==
-             grpc_channel_check_connectivity_state(chan, 0));
+  CHECK(GRPC_CHANNEL_READY == grpc_channel_check_connectivity_state(chan, 0));
   grpc_channel_watch_connectivity_state(chan, GRPC_CHANNEL_READY,
                                         gpr_inf_future(GPR_CLOCK_REALTIME), cq,
                                         grpc_core::CqVerifier::tag(0x9999));
@@ -347,9 +347,9 @@ int main(int argc, char** argv) {
   op->data.recv_close_on_server.cancelled = &was_cancelled1;
   op->flags = 0;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch(server_call1, ops, (size_t)(op - ops),
-                                   grpc_core::CqVerifier::tag(0x302), nullptr));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_call_start_batch(server_call1, ops, (size_t)(op - ops),
+                                 grpc_core::CqVerifier::tag(0x302), nullptr));
 
   // shutdown first server:
   // we should see a connectivity change and then nothing
@@ -373,9 +373,9 @@ int main(int argc, char** argv) {
   op->flags = GRPC_INITIAL_METADATA_WAIT_FOR_READY;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch(call2, ops, (size_t)(op - ops),
-                                   grpc_core::CqVerifier::tag(0x201), nullptr));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_call_start_batch(call2, ops, (size_t)(op - ops),
+                                 grpc_core::CqVerifier::tag(0x201), nullptr));
   // and receive status to probe termination
   memset(ops, 0, sizeof(ops));
   op = ops;
@@ -386,9 +386,9 @@ int main(int argc, char** argv) {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch(call2, ops, (size_t)(op - ops),
-                                   grpc_core::CqVerifier::tag(0x202), nullptr));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_call_start_batch(call2, ops, (size_t)(op - ops),
+                                 grpc_core::CqVerifier::tag(0x202), nullptr));
 
   // and bring up second server
   set_resolve_port(port2);
@@ -403,10 +403,10 @@ int main(int argc, char** argv) {
 
   // request a call to the server
   grpc_call* server_call2;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_server_request_call(server2, &server_call2, &request_details2,
-                                      &request_metadata2, cq, cq,
-                                      grpc_core::CqVerifier::tag(0x401)));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_server_request_call(server2, &server_call2, &request_details2,
+                                    &request_metadata2, cq, cq,
+                                    grpc_core::CqVerifier::tag(0x401)));
 
   // second call should now start
   cqv.Expect(grpc_core::CqVerifier::tag(0x201), true);
@@ -420,9 +420,9 @@ int main(int argc, char** argv) {
   op->data.recv_close_on_server.cancelled = &was_cancelled2;
   op->flags = 0;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch(server_call2, ops, (size_t)(op - ops),
-                                   grpc_core::CqVerifier::tag(0x402), nullptr));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_call_start_batch(server_call2, ops, (size_t)(op - ops),
+                                 grpc_core::CqVerifier::tag(0x402), nullptr));
 
   // shutdown second server: we should see nothing
   grpc_server_shutdown_and_notify(server2, cq,

test/core/end2end/h2_ssl_cert_test.cc

@@ -24,6 +24,7 @@
 #include <string>
 
 #include "absl/functional/any_invocable.h"
+#include "absl/log/check.h"
 #include "absl/types/optional.h"
 #include "gtest/gtest.h"
 
@@ -58,7 +59,7 @@ static void process_auth_failure(void* state, grpc_auth_context* /*ctx*/,
                                  size_t /*md_count*/,
                                  grpc_process_auth_metadata_done_cb cb,
                                  void* user_data) {
-  GPR_ASSERT(state == nullptr);
+  CHECK_EQ(state, nullptr);
   cb(user_data, nullptr, 0, nullptr, 0, GRPC_STATUS_UNAUTHENTICATED, nullptr);
 }
 
@@ -213,7 +214,7 @@ static void simple_request_body(grpc_core::CoreTestFixture* f,
   c = grpc_channel_create_call(client, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
                                grpc_slice_from_static_string("/foo"), &host,
                                deadline, nullptr);
-  GPR_ASSERT(c);
+  CHECK(c);
 
   memset(ops, 0, sizeof(ops));
   op = ops;
@@ -224,7 +225,7 @@ static void simple_request_body(grpc_core::CoreTestFixture* f,
   op++;
   error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops),
                                 grpc_core::CqVerifier::tag(1), nullptr);
-  GPR_ASSERT(GRPC_CALL_OK == error);
+  CHECK_EQ(error, GRPC_CALL_OK);
 
   cqv.Expect(grpc_core::CqVerifier::tag(1), expected_result == SUCCESS);
   cqv.Verify();
@@ -236,9 +237,9 @@ static void simple_request_body(grpc_core::CoreTestFixture* f,
   cqv.Verify();
   grpc_server_destroy(server);
   grpc_completion_queue_shutdown(cq);
-  GPR_ASSERT(grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
-                                        nullptr)
-                 .type == GRPC_QUEUE_SHUTDOWN);
+  CHECK(grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME),
+                                   nullptr)
+            .type == GRPC_QUEUE_SHUTDOWN);
   grpc_completion_queue_destroy(cq);
 }
 
@@ -278,9 +279,9 @@ int main(int argc, char** argv) {
   // Set the SSL roots env var.
   roots_file =
       gpr_tmpfile("chttp2_simple_ssl_cert_fullstack_test", &roots_filename);
-  GPR_ASSERT(roots_filename != nullptr);
-  GPR_ASSERT(roots_file != nullptr);
-  GPR_ASSERT(fwrite(test_root_cert, 1, roots_size, roots_file) == roots_size);
+  CHECK_NE(roots_filename, nullptr);
+  CHECK_NE(roots_file, nullptr);
+  CHECK(fwrite(test_root_cert, 1, roots_size, roots_file) == roots_size);
   fclose(roots_file);
   grpc_core::ConfigVars::Overrides config_overrides;
   config_overrides.default_ssl_roots_file_path = roots_filename;

test/core/end2end/h2_ssl_session_reuse_test.cc

@@ -22,6 +22,7 @@
 
 #include <gtest/gtest.h>
 
+#include "absl/log/check.h"
 #include "absl/types/optional.h"
 
 #include <grpc/credentials.h>
@@ -71,7 +72,7 @@ grpc_server* server_create(grpc_completion_queue* cq, const char* server_addr) {
 
   grpc_server* server = grpc_server_create(nullptr, nullptr);
   grpc_server_register_completion_queue(server, cq, nullptr);
-  GPR_ASSERT(grpc_server_add_http2_port(server, server_addr, server_creds));
+  CHECK(grpc_server_add_http2_port(server, server_addr, server_creds));
   grpc_server_credentials_release(server_creds);
   grpc_server_start(server);
   return server;
@@ -100,7 +101,7 @@ grpc_channel* client_create(const char* server_addr,
 
   grpc_channel* client =
       grpc_channel_create(server_addr, client_creds, client_args);
-  GPR_ASSERT(client != nullptr);
+  CHECK_NE(client, nullptr);
   grpc_channel_credentials_release(client_creds);
 
   {
@@ -132,7 +133,7 @@ void do_round_trip(grpc_completion_queue* cq, grpc_server* server,
   grpc_call* c = grpc_channel_create_call(
       client, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
       grpc_slice_from_static_string("/foo"), nullptr, deadline, nullptr);
-  GPR_ASSERT(c);
+  CHECK(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
   grpc_metadata_array_init(&trailing_metadata_recv);
@@ -164,13 +165,13 @@ void do_round_trip(grpc_completion_queue* cq, grpc_server* server,
   op++;
   error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops),
                                 grpc_core::CqVerifier::tag(1), nullptr);
-  GPR_ASSERT(GRPC_CALL_OK == error);
+  CHECK_EQ(error, GRPC_CALL_OK);
 
   grpc_call* s;
   error = grpc_server_request_call(server, &s, &call_details,
                                    &request_metadata_recv, cq, cq,
                                    grpc_core::CqVerifier::tag(101));
-  GPR_ASSERT(GRPC_CALL_OK == error);
+  CHECK_EQ(error, GRPC_CALL_OK);
   cqv.Expect(grpc_core::CqVerifier::tag(101), true);
   cqv.Verify();
 
@@ -178,11 +179,11 @@ void do_round_trip(grpc_completion_queue* cq, grpc_server* server,
   grpc_auth_property_iterator it = grpc_auth_context_find_properties_by_name(
       auth, GRPC_SSL_SESSION_REUSED_PROPERTY);
   const grpc_auth_property* property = grpc_auth_property_iterator_next(&it);
-  GPR_ASSERT(property != nullptr);
+  CHECK_NE(property, nullptr);
   if (expect_session_reuse) {
-    GPR_ASSERT(strcmp(property->value, "true") == 0);
+    CHECK_EQ(strcmp(property->value, "true"), 0);
   } else {
-    GPR_ASSERT(strcmp(property->value, "false") == 0);
+    CHECK_EQ(strcmp(property->value, "false"), 0);
   }
   grpc_auth_context_release(auth);
 
@@ -206,7 +207,7 @@ void do_round_trip(grpc_completion_queue* cq, grpc_server* server,
   op++;
   error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops),
                                 grpc_core::CqVerifier::tag(103), nullptr);
-  GPR_ASSERT(GRPC_CALL_OK == error);
+  CHECK_EQ(error, GRPC_CALL_OK);
 
   cqv.Expect(grpc_core::CqVerifier::tag(103), true);
   cqv.Expect(grpc_core::CqVerifier::tag(1), true);
@@ -246,9 +247,9 @@ TEST(H2SessionReuseTest, SingleReuse) {
 
   grpc_ssl_session_cache_destroy(cache);
 
-  GPR_ASSERT(grpc_completion_queue_next(
-                 cq, grpc_timeout_milliseconds_to_deadline(100), nullptr)
-                 .type == GRPC_QUEUE_TIMEOUT);
+  CHECK(grpc_completion_queue_next(
+            cq, grpc_timeout_milliseconds_to_deadline(100), nullptr)
+            .type == GRPC_QUEUE_TIMEOUT);
 
   grpc_server_shutdown_and_notify(server, cq, grpc_core::CqVerifier::tag(1000));
   grpc_event ev;

test/core/end2end/h2_tls_peer_property_external_verifier_test.cc

@@ -22,6 +22,7 @@
 
 #include <gtest/gtest.h>
 
+#include "absl/log/check.h"
 #include "absl/types/optional.h"
 
 #include <grpc/credentials.h>
@@ -95,7 +96,7 @@ grpc_server* server_create(grpc_completion_queue* cq, const char* server_addr,
 
   grpc_server* server = grpc_server_create(nullptr, nullptr);
   grpc_server_register_completion_queue(server, cq, nullptr);
-  GPR_ASSERT(grpc_server_add_http2_port(server, server_addr, creds));
+  CHECK(grpc_server_add_http2_port(server, server_addr, creds));
   grpc_server_credentials_release(creds);
 
   grpc_server_start(server);
@@ -144,7 +145,7 @@ grpc_channel* client_create(const char* server_addr,
       grpc_channel_args_copy_and_add(nullptr, args, GPR_ARRAY_SIZE(args));
 
   grpc_channel* client = grpc_channel_create(server_addr, creds, client_args);
-  GPR_ASSERT(client != nullptr);
+  CHECK_NE(client, nullptr);
   grpc_channel_credentials_release(creds);
 
   {
@@ -177,7 +178,7 @@ void do_round_trip(grpc_completion_queue* cq, grpc_server* server,
   grpc_call* c = grpc_channel_create_call(
       client, nullptr, GRPC_PROPAGATE_DEFAULTS, cq,
       grpc_slice_from_static_string("/foo"), nullptr, deadline, nullptr);
-  GPR_ASSERT(c);
+  CHECK(c);
 
   grpc_metadata_array_init(&initial_metadata_recv);
   grpc_metadata_array_init(&trailing_metadata_recv);
@@ -209,12 +210,12 @@ void do_round_trip(grpc_completion_queue* cq, grpc_server* server,
   op++;
   error = grpc_call_start_batch(c, ops, static_cast<size_t>(op - ops), tag(1),
                                 nullptr);
-  GPR_ASSERT(GRPC_CALL_OK == error);
+  CHECK_EQ(error, GRPC_CALL_OK);
 
   grpc_call* s;
   error = grpc_server_request_call(server, &s, &call_details,
                                    &request_metadata_recv, cq, cq, tag(101));
-  GPR_ASSERT(GRPC_CALL_OK == error);
+  CHECK_EQ(error, GRPC_CALL_OK);
   cqv.Expect(tag(101), true);
   cqv.Verify();
 
@@ -238,7 +239,7 @@ void do_round_trip(grpc_completion_queue* cq, grpc_server* server,
   op++;
   error = grpc_call_start_batch(s, ops, static_cast<size_t>(op - ops), tag(103),
                                 nullptr);
-  GPR_ASSERT(GRPC_CALL_OK == error);
+  CHECK_EQ(error, GRPC_CALL_OK);
 
   cqv.Expect(tag(103), true);
   cqv.Expect(tag(1), true);
@@ -278,9 +279,9 @@ TEST(H2TlsPeerPropertyExternalVerifier, PeerPropertyExternalVerifierTest) {
 
   do_round_trip(cq, server, server_addr.c_str());
 
-  GPR_ASSERT(grpc_completion_queue_next(
-                 cq, grpc_timeout_milliseconds_to_deadline(100), nullptr)
-                 .type == GRPC_QUEUE_TIMEOUT);
+  CHECK(grpc_completion_queue_next(
+            cq, grpc_timeout_milliseconds_to_deadline(100), nullptr)
+            .type == GRPC_QUEUE_TIMEOUT);
 
   grpc_server_shutdown_and_notify(server, cq, tag(1000));
   grpc_event ev;

test/core/end2end/invalid_call_argument_test.cc

@@ -23,6 +23,8 @@
 #include <memory>
 #include <string>
 
+#include "absl/log/check.h"
+
 #include <grpc/byte_buffer.h>
 #include <grpc/credentials.h>
 #include <grpc/grpc.h>
@@ -108,15 +110,15 @@ static void prepare_test(int is_client) {
     op->flags = GRPC_INITIAL_METADATA_WAIT_FOR_READY;
     op->reserved = nullptr;
     op++;
-    GPR_ASSERT(GRPC_CALL_OK ==
-               grpc_call_start_batch(g_state.call, g_state.ops,
-                                     (size_t)(op - g_state.ops),
-                                     grpc_core::CqVerifier::tag(1), nullptr));
-    GPR_ASSERT(GRPC_CALL_OK ==
-               grpc_server_request_call(
-                   g_state.server, &g_state.server_call, &g_state.call_details,
-                   &g_state.server_initial_metadata_recv, g_state.cq,
-                   g_state.cq, grpc_core::CqVerifier::tag(101)));
+    CHECK_EQ(GRPC_CALL_OK,
+             grpc_call_start_batch(g_state.call, g_state.ops,
+                                   (size_t)(op - g_state.ops),
+                                   grpc_core::CqVerifier::tag(1), nullptr));
+    CHECK_EQ(GRPC_CALL_OK,
+             grpc_server_request_call(
+                 g_state.server, &g_state.server_call, &g_state.call_details,
+                 &g_state.server_initial_metadata_recv, g_state.cq, g_state.cq,
+                 grpc_core::CqVerifier::tag(101)));
     g_state.cqv->Expect(grpc_core::CqVerifier::tag(101), true);
     g_state.cqv->Expect(grpc_core::CqVerifier::tag(1), true);
     g_state.cqv->Verify();
@@ -156,9 +158,9 @@ static void test_non_null_reserved_on_start_batch() {
   gpr_log(GPR_INFO, "test_non_null_reserved_on_start_batch");
 
   prepare_test(1);
-  GPR_ASSERT(GRPC_CALL_ERROR ==
-             grpc_call_start_batch(g_state.call, nullptr, 0, nullptr,
-                                   grpc_core::CqVerifier::tag(1)));
+  CHECK(GRPC_CALL_ERROR ==
+        grpc_call_start_batch(g_state.call, nullptr, 0, nullptr,
+                              grpc_core::CqVerifier::tag(1)));
   cleanup_test();
 }
 
@@ -174,10 +176,10 @@ static void test_non_null_reserved_on_op() {
   op->flags = 0;
   op->reserved = grpc_core::CqVerifier::tag(2);
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK(GRPC_CALL_ERROR == grpc_call_start_batch(g_state.call, g_state.ops,
+                                                 (size_t)(op - g_state.ops),
+                                                 grpc_core::CqVerifier::tag(1),
+                                                 nullptr));
   cleanup_test();
 }
 
@@ -193,10 +195,10 @@ static void test_send_initial_metadata_more_than_once() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_call_start_batch(g_state.call, g_state.ops,
+                                 (size_t)(op - g_state.ops),
+                                 grpc_core::CqVerifier::tag(1), nullptr));
   g_state.cqv->Expect(grpc_core::CqVerifier::tag(1), false);
   g_state.cqv->Verify();
 
@@ -206,10 +208,10 @@ static void test_send_initial_metadata_more_than_once() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
+        grpc_call_start_batch(g_state.call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(1), nullptr));
   cleanup_test();
 }
 
@@ -225,10 +227,10 @@ static void test_too_many_metadata() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_INVALID_METADATA ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK(GRPC_CALL_ERROR_INVALID_METADATA ==
+        grpc_call_start_batch(g_state.call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(1), nullptr));
   cleanup_test();
 }
 
@@ -249,10 +251,10 @@ static void test_send_null_message() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_INVALID_MESSAGE ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK(GRPC_CALL_ERROR_INVALID_MESSAGE ==
+        grpc_call_start_batch(g_state.call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(1), nullptr));
   cleanup_test();
 }
 
@@ -282,10 +284,10 @@ static void test_send_messages_at_the_same_time() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
+        grpc_call_start_batch(g_state.call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(1), nullptr));
   grpc_byte_buffer_destroy(request_payload);
   cleanup_test();
 }
@@ -305,10 +307,10 @@ static void test_send_server_status_from_client() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_CLIENT ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK(GRPC_CALL_ERROR_NOT_ON_CLIENT ==
+        grpc_call_start_batch(g_state.call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(1), nullptr));
   cleanup_test();
 }
 
@@ -324,10 +326,10 @@ static void test_receive_initial_metadata_twice_at_client() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_call_start_batch(g_state.call, g_state.ops,
+                                 (size_t)(op - g_state.ops),
+                                 grpc_core::CqVerifier::tag(1), nullptr));
   g_state.cqv->Expect(grpc_core::CqVerifier::tag(1), false);
   g_state.cqv->Verify();
   op = g_state.ops;
@@ -337,10 +339,10 @@ static void test_receive_initial_metadata_twice_at_client() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
+        grpc_call_start_batch(g_state.call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(1), nullptr));
   cleanup_test();
 }
 
@@ -356,10 +358,10 @@ static void test_receive_message_with_invalid_flags() {
   op->flags = 1;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_INVALID_FLAGS ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK(GRPC_CALL_ERROR_INVALID_FLAGS ==
+        grpc_call_start_batch(g_state.call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(1), nullptr));
   cleanup_test();
 }
 
@@ -380,10 +382,10 @@ static void test_receive_two_messages_at_the_same_time() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
+        grpc_call_start_batch(g_state.call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(1), nullptr));
   cleanup_test();
 }
 
@@ -399,10 +401,10 @@ static void test_recv_close_on_server_from_client() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_CLIENT ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK(GRPC_CALL_ERROR_NOT_ON_CLIENT ==
+        grpc_call_start_batch(g_state.call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(1), nullptr));
   cleanup_test();
 }
 
@@ -421,10 +423,10 @@ static void test_recv_status_on_client_twice() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_call_start_batch(g_state.call, g_state.ops,
+                                 (size_t)(op - g_state.ops),
+                                 grpc_core::CqVerifier::tag(1), nullptr));
   g_state.cqv->Expect(grpc_core::CqVerifier::tag(1), true);
   g_state.cqv->Verify();
 
@@ -436,10 +438,10 @@ static void test_recv_status_on_client_twice() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
+        grpc_call_start_batch(g_state.call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(1), nullptr));
   cleanup_test();
 }
 
@@ -454,10 +456,10 @@ static void test_send_close_from_client_on_server() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_SERVER ==
-             grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(2), nullptr));
+  CHECK(GRPC_CALL_ERROR_NOT_ON_SERVER ==
+        grpc_call_start_batch(g_state.server_call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(2), nullptr));
   cleanup_test();
 }
 
@@ -476,10 +478,10 @@ static void test_recv_status_on_client_from_server() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_NOT_ON_SERVER ==
-             grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(2), nullptr));
+  CHECK(GRPC_CALL_ERROR_NOT_ON_SERVER ==
+        grpc_call_start_batch(g_state.server_call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(2), nullptr));
   cleanup_test();
 }
 
@@ -498,10 +500,10 @@ static void test_send_status_from_server_with_invalid_flags() {
   op->flags = 1;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_INVALID_FLAGS ==
-             grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(2), nullptr));
+  CHECK(GRPC_CALL_ERROR_INVALID_FLAGS ==
+        grpc_call_start_batch(g_state.server_call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(2), nullptr));
   cleanup_test();
 }
 
@@ -521,10 +523,10 @@ static void test_too_many_trailing_metadata() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_INVALID_METADATA ==
-             grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(2), nullptr));
+  CHECK(GRPC_CALL_ERROR_INVALID_METADATA ==
+        grpc_call_start_batch(g_state.server_call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(2), nullptr));
   cleanup_test();
 }
 
@@ -550,10 +552,10 @@ static void test_send_server_status_twice() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
-             grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(2), nullptr));
+  CHECK(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
+        grpc_call_start_batch(g_state.server_call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(2), nullptr));
   cleanup_test();
 }
 
@@ -569,10 +571,10 @@ static void test_recv_close_on_server_with_invalid_flags() {
   op->flags = 1;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_INVALID_FLAGS ==
-             grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(2), nullptr));
+  CHECK(GRPC_CALL_ERROR_INVALID_FLAGS ==
+        grpc_call_start_batch(g_state.server_call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(2), nullptr));
   cleanup_test();
 }
 
@@ -593,10 +595,10 @@ static void test_recv_close_on_server_twice() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
-             grpc_call_start_batch(g_state.server_call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(2), nullptr));
+  CHECK(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
+        grpc_call_start_batch(g_state.server_call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(2), nullptr));
   cleanup_test();
 }
 
@@ -616,10 +618,10 @@ static void test_invalid_initial_metadata_reserved_key() {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_ERROR_INVALID_METADATA ==
-             grpc_call_start_batch(g_state.call, g_state.ops,
-                                   (size_t)(op - g_state.ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK(GRPC_CALL_ERROR_INVALID_METADATA ==
+        grpc_call_start_batch(g_state.call, g_state.ops,
+                              (size_t)(op - g_state.ops),
+                              grpc_core::CqVerifier::tag(1), nullptr));
   cleanup_test();
 }
 
@@ -639,10 +641,10 @@ static void test_multiple_ops_in_a_single_batch() {
     op++;
     op->op = which;
     op++;
-    GPR_ASSERT(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
-               grpc_call_start_batch(g_state.call, g_state.ops,
-                                     (size_t)(op - g_state.ops),
-                                     grpc_core::CqVerifier::tag(1), nullptr));
+    CHECK(GRPC_CALL_ERROR_TOO_MANY_OPERATIONS ==
+          grpc_call_start_batch(g_state.call, g_state.ops,
+                                (size_t)(op - g_state.ops),
+                                grpc_core::CqVerifier::tag(1), nullptr));
   }
 
   cleanup_test();

test/core/end2end/no_server_test.cc

@@ -20,6 +20,7 @@
 
 #include <utility>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/time/time.h"
@@ -85,9 +86,9 @@ void run_test(bool wait_for_ready) {
   op->flags = 0;
   op->reserved = nullptr;
   op++;
-  GPR_ASSERT(GRPC_CALL_OK ==
-             grpc_call_start_batch(call, ops, (size_t)(op - ops),
-                                   grpc_core::CqVerifier::tag(1), nullptr));
+  CHECK_EQ(GRPC_CALL_OK,
+           grpc_call_start_batch(call, ops, (size_t)(op - ops),
+                                 grpc_core::CqVerifier::tag(1), nullptr));
 
   {
     response_generator->WaitForResolverSet(
@@ -105,9 +106,9 @@ void run_test(bool wait_for_ready) {
 
   gpr_log(GPR_INFO, "call status: %d", status);
   if (wait_for_ready) {
-    GPR_ASSERT(status == GRPC_STATUS_DEADLINE_EXCEEDED);
+    CHECK_EQ(status, GRPC_STATUS_DEADLINE_EXCEEDED);
   } else {
-    GPR_ASSERT(status == GRPC_STATUS_UNAVAILABLE);
+    CHECK_EQ(status, GRPC_STATUS_UNAVAILABLE);
   }
 
   grpc_slice_unref(details);

test/core/end2end/tests/filter_context.cc

@@ -19,6 +19,7 @@
 #include <initializer_list>
 #include <memory>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "gtest/gtest.h"
 
@@ -65,7 +66,7 @@ void start_transport_stream_op_batch(grpc_call_element* elem,
   gpr_log(GPR_INFO, "start_transport_stream_op_batch(): context=%p",
           batch->payload->context);
   if (batch->payload->context != nullptr) {
-    GPR_ASSERT(calld->context == batch->payload->context);
+    CHECK(calld->context == batch->payload->context);
   }
   grpc_call_next_op(elem, batch);
 }

test/core/end2end/tests/grpc_authz.cc

@@ -14,6 +14,7 @@
 
 #include <string>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "gtest/gtest.h"
 
@@ -100,7 +101,7 @@ class InitWithTempFile {
     provider_ = grpc_authorization_policy_provider_file_watcher_create(
         tmp_file_.name().c_str(), /*refresh_interval_sec=*/1, &code,
         &error_details);
-    GPR_ASSERT(GRPC_STATUS_OK == code);
+    CHECK_EQ(code, GRPC_STATUS_OK);
     InitWithPolicy(test, provider_);
   }
 

test/core/end2end/tests/retry_lb_drop.cc

@@ -19,6 +19,7 @@
 #include <utility>
 #include <vector>
 
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
@@ -106,7 +107,7 @@ CORE_END2END_TEST(RetryTest, RetryLbDrop) {
     RegisterTestPickArgsLoadBalancingPolicy(
         builder,
         [](const PickArgsSeen& pick_args) {
-          GPR_ASSERT(g_pick_args_vector != nullptr);
+          CHECK_NE(g_pick_args_vector, nullptr);
           g_pick_args_vector->push_back(pick_args);
         },
         kDropPolicyName);

test/core/end2end/tests/server_streaming.cc

@@ -18,6 +18,7 @@
 
 #include <memory>
 
+#include "absl/log/check.h"
 #include "gtest/gtest.h"
 
 #include <grpc/status.h>
@@ -86,7 +87,7 @@ void ServerStreaming(CoreEnd2endTest& test, int num_messages) {
     EXPECT_EQ(server_message.payload(), "hello world");
     num_messages_received++;
   }
-  GPR_ASSERT(num_messages_received == num_messages);
+  CHECK_EQ(num_messages_received, num_messages);
   if (!seen_status) {
     test.Expect(1, true);
     test.Step();