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

test/core/iomgr/buffer_list_test.cc

@@ -37,7 +37,7 @@ extern gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type);
 
 static gpr_timespec g_now;
 gpr_timespec now_impl(gpr_clock_type clock_type) {
-  GPR_ASSERT(clock_type != GPR_TIMESPAN);
+  CHECK(clock_type != GPR_TIMESPAN);
   gpr_timespec ts = g_now;
   ts.clock_type = clock_type;
   return ts;

test/core/iomgr/endpoint_pair_test.cc

@@ -58,7 +58,7 @@ grpc_endpoint_pair grpc_iomgr_event_engine_shim_endpoint_pair(
   std::string target_addr = absl::StrCat(
       "ipv6:[::1]:", std::to_string(grpc_pick_unused_port_or_die()));
   auto resolved_addr = URIToResolvedAddress(target_addr);
-  GPR_ASSERT(resolved_addr.ok());
+  CHECK_OK(resolved_addr);
   std::unique_ptr<EventEngine::Endpoint> client_endpoint;
   std::unique_ptr<EventEngine::Endpoint> server_endpoint;
   grpc_core::Notification client_signal;
@@ -80,13 +80,13 @@ grpc_endpoint_pair grpc_iomgr_event_engine_shim_endpoint_pair(
       std::move(accept_cb), [](absl::Status /*status*/) {}, config,
       std::make_unique<grpc_core::MemoryQuota>("foo"));
 
-  GPR_ASSERT(listener->Bind(*resolved_addr).ok());
-  GPR_ASSERT(listener->Start().ok());
+  CHECK_OK(listener->Bind(*resolved_addr));
+  CHECK_OK(listener->Start());
 
   ee->Connect(
       [&client_endpoint, &client_signal](
           absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>> endpoint) {
-        GPR_ASSERT(endpoint.ok());
+        CHECK_OK(endpoint);
         client_endpoint = std::move(*endpoint);
         client_signal.Notify();
       },

test/core/iomgr/endpoint_tests.cc

@@ -61,7 +61,7 @@ size_t count_slices(grpc_slice* slices, size_t nslices, int* current_data) {
   for (i = 0; i < nslices; ++i) {
     buf = GRPC_SLICE_START_PTR(slices[i]);
     for (j = 0; j < GRPC_SLICE_LENGTH(slices[i]); ++j) {
-      GPR_ASSERT(buf[j] == *current_data);
+      CHECK(buf[j] == *current_data);
       *current_data = (*current_data + 1) % 256;
     }
     num_bytes += GRPC_SLICE_LENGTH(slices[i]);
@@ -99,7 +99,7 @@ static grpc_slice* allocate_blocks(size_t num_bytes, size_t slice_size,
       (*current_data)++;
     }
   }
-  GPR_ASSERT(num_bytes_left == 0);
+  CHECK_EQ(num_bytes_left, 0);
   return slices;
 }
 
@@ -273,8 +273,8 @@ static void read_and_write_test(grpc_endpoint_test_config config,
   gpr_mu_lock(g_mu);
   while (!state.read_done || !state.write_done) {
     grpc_pollset_worker* worker = nullptr;
-    GPR_ASSERT(grpc_core::Timestamp::Now() < deadline);
-    GPR_ASSERT(GRPC_LOG_IF_ERROR(
+    CHECK(grpc_core::Timestamp::Now() < deadline);
+    CHECK(GRPC_LOG_IF_ERROR(
         "pollset_work", grpc_pollset_work(g_pollset, &worker, deadline)));
   }
   gpr_mu_unlock(g_mu);
@@ -290,7 +290,7 @@ static void read_and_write_test(grpc_endpoint_test_config config,
 static void inc_on_failure(void* arg, grpc_error_handle error) {
   gpr_mu_lock(g_mu);
   *static_cast<int*>(arg) += (!error.ok());
-  GPR_ASSERT(GRPC_LOG_IF_ERROR("kick", grpc_pollset_kick(g_pollset, nullptr)));
+  CHECK(GRPC_LOG_IF_ERROR("kick", grpc_pollset_kick(g_pollset, nullptr)));
   gpr_mu_unlock(g_mu);
 }
 
@@ -302,13 +302,13 @@ static void wait_for_fail_count(int* fail_count, int want_fail_count) {
   while (grpc_core::Timestamp::Now() < deadline &&
          *fail_count < want_fail_count) {
     grpc_pollset_worker* worker = nullptr;
-    GPR_ASSERT(GRPC_LOG_IF_ERROR(
+    CHECK(GRPC_LOG_IF_ERROR(
         "pollset_work", grpc_pollset_work(g_pollset, &worker, deadline)));
     gpr_mu_unlock(g_mu);
     grpc_core::ExecCtx::Get()->Flush();
     gpr_mu_lock(g_mu);
   }
-  GPR_ASSERT(*fail_count == want_fail_count);
+  CHECK(*fail_count == want_fail_count);
   gpr_mu_unlock(g_mu);
 }
 

test/core/iomgr/fd_conservation_posix_test.cc

@@ -40,7 +40,7 @@ int main(int argc, char** argv) {
     // verify we can create and destroy many more than this number
     // of descriptors
     rlim.rlim_cur = rlim.rlim_max = 1000;
-    GPR_ASSERT(0 == setrlimit(RLIMIT_NOFILE, &rlim));
+    CHECK_EQ(setrlimit(RLIMIT_NOFILE, &rlim), 0);
     for (i = 0; i < 10000; i++) {
       p = grpc_iomgr_create_endpoint_pair("test", nullptr);
       grpc_endpoint_destroy(p.client);

test/core/iomgr/ios/CFStreamTests/CFStreamClientTests.mm

@@ -47,8 +47,8 @@ static void finish_connection() {
 }
 
 static void must_succeed(void* arg, grpc_error_handle error) {
-  GPR_ASSERT(g_connecting != nullptr);
-  GPR_ASSERT(error.ok());
+  CHECK_NE(g_connecting, nullptr);
+  CHECK_OK(error);
   grpc_endpoint_shutdown(g_connecting, GRPC_ERROR_CREATE("must_succeed called"));
   grpc_endpoint_destroy(g_connecting);
   g_connecting = nullptr;
@@ -56,8 +56,8 @@ static void must_succeed(void* arg, grpc_error_handle error) {
 }
 
 static void must_fail(void* arg, grpc_error_handle error) {
-  GPR_ASSERT(g_connecting == nullptr);
-  GPR_ASSERT(!error.ok());
+  CHECK_EQ(g_connecting, nullptr);
+  CHECK_DONT(!error.ok());
   NSLog(@"%s", grpc_core::StatusToString(error).c_str());
   finish_connection();
 }
@@ -87,21 +87,21 @@ static void must_fail(void* arg, grpc_error_handle error) {
   gpr_log(GPR_DEBUG, "test_succeeds");
 
   auto resolved_addr = grpc_core::StringToSockaddr("127.0.0.1:0");
-  GPR_ASSERT(resolved_addr.ok());
+  CHECK_OK(resolved_addr);
   struct sockaddr_in* addr = reinterpret_cast<struct sockaddr_in*>(resolved_addr->addr);
 
   /* create a phony server */
   svr_fd = socket(AF_INET, SOCK_STREAM, 0);
-  GPR_ASSERT(svr_fd >= 0);
-  GPR_ASSERT(0 == bind(svr_fd, (struct sockaddr*)addr, (socklen_t)resolved_addr->len));
-  GPR_ASSERT(0 == listen(svr_fd, 1));
+  CHECK_GE(svr_fd, 0);
+  CHECK_EQ(bind(svr_fd, (struct sockaddr*)addr, (socklen_t)resolved_addr->len), 0);
+  CHECK_EQ(listen(svr_fd, 1), 0);
 
   gpr_mu_lock(&g_mu);
   connections_complete_before = g_connections_complete;
   gpr_mu_unlock(&g_mu);
 
   /* connect to it */
-  GPR_ASSERT(getsockname(svr_fd, (struct sockaddr*)addr, (socklen_t*)&resolved_addr->len) == 0);
+  CHECK_EQ(getsockname(svr_fd, (struct sockaddr*)addr, (socklen_t*)&resolved_addr->len), 0);
   GRPC_CLOSURE_INIT(&done, must_succeed, nullptr, grpc_schedule_on_exec_ctx);
   auto args =
       grpc_core::CoreConfiguration::Get().channel_args_preconditioning().PreconditionChannelArgs(
@@ -116,7 +116,7 @@ static void must_fail(void* arg, grpc_error_handle error) {
     r = accept(svr_fd, reinterpret_cast<struct sockaddr*>(addr),
                reinterpret_cast<socklen_t*>(&resolved_addr->len));
   } while (r == -1 && errno == EINTR);
-  GPR_ASSERT(r >= 0);
+  CHECK_GE(r, 0);
   close(r);
 
   grpc_core::ExecCtx::Get()->Flush();
@@ -144,14 +144,14 @@ static void must_fail(void* arg, grpc_error_handle error) {
   gpr_log(GPR_DEBUG, "test_fails");
 
   auto resolved_addr = grpc_core::StringToSockaddr("127.0.0.1:0");
-  GPR_ASSERT(resolved_addr.ok());
+  CHECK_OK(resolved_addr);
   struct sockaddr_in* addr = reinterpret_cast<struct sockaddr_in*>(resolved_addr->addr);
 
   svr_fd = socket(AF_INET, SOCK_STREAM, 0);
-  GPR_ASSERT(svr_fd >= 0);
-  GPR_ASSERT(0 == bind(svr_fd, (struct sockaddr*)addr, (socklen_t)resolved_addr->len));
-  GPR_ASSERT(0 == listen(svr_fd, 1));
-  GPR_ASSERT(getsockname(svr_fd, (struct sockaddr*)addr, (socklen_t*)&resolved_addr->len) == 0);
+  CHECK_GE(svr_fd, 0);
+  CHECK_EQ(bind(svr_fd, (struct sockaddr*)addr, (socklen_t)resolved_addr->len), 0);
+  CHECK_EQ(listen(svr_fd, 1), 0);
+  CHECK_EQ(getsockname(svr_fd, (struct sockaddr*)addr, (socklen_t*)&resolved_addr->len), 0);
   close(svr_fd);
 
   gpr_mu_lock(&g_mu);

test/core/iomgr/resolve_address_test.cc

@@ -546,7 +546,7 @@ int main(int argc, char** argv) {
   } else if (absl::StrContains(std::string(argv[0]), "using_ares_resolver")) {
     g_resolver_type = "ares";
   } else {
-    GPR_ASSERT(0);
+    CHECK(0);
   }
   grpc_core::ConfigVars::Overrides overrides;
   overrides.dns_resolver = g_resolver_type;

test/core/iomgr/socket_utils_test.cc

@@ -198,7 +198,7 @@ TEST(SocketUtilsTest, MainTest) {
 
   if (grpc_ipv6_loopback_available()) {
     sock = socket(AF_INET6, SOCK_STREAM, 0);
-    GPR_ASSERT(sock > 0);
+    CHECK_GT(sock, 0);
 
     test_set_socket_dscp_ipv6(sock, 8 /*CS1*/);
     test_set_socket_dscp_ipv6(sock, 16 /*CS2*/);

test/core/memory_usage/callback_client.cc

@@ -124,7 +124,7 @@ std::shared_ptr<CallParams> GetBeforeSnapshot(
 int main(int argc, char** argv) {
   absl::ParseCommandLine(argc, argv);
   char* fake_argv[1];
-  GPR_ASSERT(argc >= 1);
+  CHECK_GE(argc, 1);
   fake_argv[0] = argv[0];
   grpc::testing::TestEnvironment env(&argc, argv);
   if (absl::GetFlag(FLAGS_target).empty()) {
@@ -158,7 +158,7 @@ int main(int argc, char** argv) {
 
   // Checking that all channels are still open
   for (int i = 0; i < size; ++i) {
-    GPR_ASSERT(!std::exchange(channels_list[i], nullptr)
+    CHECK(!std::exchange(channels_list[i], nullptr)
                     ->WaitForStateChange(GRPC_CHANNEL_READY,
                                          std::chrono::system_clock::now() +
                                              std::chrono::milliseconds(1)));

test/core/memory_usage/callback_server.cc

@@ -77,7 +77,7 @@ static void sigint_handler(int /*x*/) { _exit(0); }
 int main(int argc, char** argv) {
   absl::ParseCommandLine(argc, argv);
   char* fake_argv[1];
-  GPR_ASSERT(argc >= 1);
+  CHECK_GE(argc, 1);
   fake_argv[0] = argv[0];
   grpc::testing::TestEnvironment env(&argc, argv);
   grpc_init();

test/core/memory_usage/client.cc

@@ -90,7 +90,7 @@ static void init_ping_pong_request(int call_idx) {
       grpc_slice_from_static_string("/Reflector/reflectUnary"), &hostname,
       gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
 
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(calls[call_idx].call,
+  CHECK(GRPC_CALL_OK == grpc_call_start_batch(calls[call_idx].call,
                                                    metadata_ops,
                                                    (size_t)(op - metadata_ops),
                                                    tag(call_idx), nullptr));
@@ -110,7 +110,7 @@ static void finish_ping_pong_request(int call_idx) {
   op->data.recv_status_on_client.status_details = &calls[call_idx].details;
   op++;
 
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(calls[call_idx].call,
+  CHECK(GRPC_CALL_OK == grpc_call_start_batch(calls[call_idx].call,
                                                    status_ops,
                                                    (size_t)(op - status_ops),
                                                    tag(call_idx), nullptr));
@@ -154,7 +154,7 @@ static MemStats send_snapshot_request(int call_idx, grpc_slice call_type) {
   calls[call_idx].call = grpc_channel_create_call(
       channel, nullptr, GRPC_PROPAGATE_DEFAULTS, cq, call_type, &hostname,
       gpr_inf_future(GPR_CLOCK_REALTIME), nullptr);
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(calls[call_idx].call,
+  CHECK(GRPC_CALL_OK == grpc_call_start_batch(calls[call_idx].call,
                                                    snapshot_ops,
                                                    (size_t)(op - snapshot_ops),
                                                    (void*)nullptr, nullptr));
@@ -164,7 +164,7 @@ static MemStats send_snapshot_request(int call_idx, grpc_slice call_type) {
           std::string(grpc_core::StringViewFromSlice(calls[call_idx].details))
               .c_str());
 
-  GPR_ASSERT(response_payload_recv != nullptr);
+  CHECK_NE(response_payload_recv, nullptr);
   grpc_byte_buffer_reader reader;
   grpc_byte_buffer_reader_init(&reader, response_payload_recv);
   grpc_slice response = grpc_byte_buffer_reader_readall(&reader);
@@ -237,7 +237,7 @@ int main(int argc, char** argv) {
   grpc_slice slice = grpc_slice_from_copied_string("x");
   char* fake_argv[1];
 
-  GPR_ASSERT(argc >= 1);
+  CHECK_GE(argc, 1);
   fake_argv[0] = argv[0];
   grpc::testing::TestEnvironment env(&argc, argv);
 

test/core/memory_usage/memstats.cc

@@ -47,7 +47,7 @@ long GetMemUsage(absl::optional<int> pid) {
   stat_stream.close();
 
   // pid does not connect to an existing process
-  GPR_ASSERT(!state.empty());
+  CHECK(!state.empty());
 
   // Calculations in case x86-64 is configured to use 2MB pages
   long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024;

test/core/memory_usage/server.cc

@@ -106,7 +106,7 @@ static void send_initial_metadata_unary(void* tag) {
   metadata_ops[0].op = GRPC_OP_SEND_INITIAL_METADATA;
   metadata_ops[0].data.send_initial_metadata.count = 0;
 
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch((*(fling_call*)tag).call,
+  CHECK(GRPC_CALL_OK == grpc_call_start_batch((*(fling_call*)tag).call,
                                                    metadata_ops, 1, tag,
                                                    nullptr));
 }
@@ -118,7 +118,7 @@ static void send_status(void* tag) {
   grpc_slice details = grpc_slice_from_static_string("");
   status_op.data.send_status_from_server.status_details = &details;
 
-  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch((*(fling_call*)tag).call,
+  CHECK(GRPC_CALL_OK == grpc_call_start_batch((*(fling_call*)tag).call,
                                                    &status_op, 1, tag,
                                                    nullptr));
 }
@@ -152,7 +152,7 @@ static void send_snapshot(void* tag, MemStats* snapshot) {
   op->data.recv_close_on_server.cancelled = &was_cancelled;
   op++;
 
-  GPR_ASSERT(GRPC_CALL_OK ==
+  CHECK(GRPC_CALL_OK ==
              grpc_call_start_batch((*(fling_call*)tag).call, snapshot_ops,
                                    (size_t)(op - snapshot_ops), tag, nullptr));
 }
@@ -178,7 +178,7 @@ int main(int argc, char** argv) {
 
   char* fake_argv[1];
 
-  GPR_ASSERT(argc >= 1);
+  CHECK_GE(argc, 1);
   fake_argv[0] = argv[0];
   grpc::testing::TestEnvironment env(&argc, argv);
 
@@ -225,10 +225,10 @@ int main(int argc, char** argv) {
                                                     test_server1_cert};
     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(server, addr.c_str(), ssl_creds));
+    CHECK(grpc_server_add_http2_port(server, addr.c_str(), ssl_creds));
     grpc_server_credentials_release(ssl_creds);
   } else {
-    GPR_ASSERT(grpc_server_add_http2_port(
+    CHECK(grpc_server_add_http2_port(
         server, addr.c_str(), grpc_insecure_server_credentials_create()));
   }
 
@@ -257,7 +257,7 @@ int main(int argc, char** argv) {
 
       shutdown_cq = grpc_completion_queue_create_for_pluck(nullptr);
       grpc_server_shutdown_and_notify(server, shutdown_cq, tag(1000));
-      GPR_ASSERT(grpc_completion_queue_pluck(
+      CHECK(grpc_completion_queue_pluck(
                      shutdown_cq, tag(1000),
                      grpc_timeout_seconds_to_deadline(5), nullptr)
                      .type == GRPC_OP_COMPLETE);
@@ -338,7 +338,7 @@ int main(int argc, char** argv) {
         }
         break;
       case GRPC_QUEUE_SHUTDOWN:
-        GPR_ASSERT(shutdown_started);
+        CHECK(shutdown_started);
         shutdown_finished = 1;
         break;
       case GRPC_QUEUE_TIMEOUT: