Address core review comments

2 files changed, 40 insertions, 35 deletions

diff --git a/test/core/iomgr/resource_quota_test.cc b/test/core/iomgr/resource_quota_test.cc
index 573e4010fa..f3b35fed32 100644
--- a/test/core/iomgr/resource_quota_test.cc
+++ b/test/core/iomgr/resource_quota_test.cc
@@ -810,30 +810,31 @@ static void test_thread_limit() {
   grpc_resource_quota_set_max_threads(rq, 100);
 
   // Request quota for 100 threads (50 for ru1, 50 for ru2)
-  GPR_ASSERT(grpc_resource_user_alloc_threads(ru1, 10));
-  GPR_ASSERT(grpc_resource_user_alloc_threads(ru2, 10));
-  GPR_ASSERT(grpc_resource_user_alloc_threads(ru1, 40));
-  GPR_ASSERT(grpc_resource_user_alloc_threads(ru2, 40));
+  GPR_ASSERT(grpc_resource_user_allocate_threads(ru1, 10));
+  GPR_ASSERT(grpc_resource_user_allocate_threads(ru2, 10));
+  GPR_ASSERT(grpc_resource_user_allocate_threads(ru1, 40));
+  GPR_ASSERT(grpc_resource_user_allocate_threads(ru2, 40));
 
-  // Threads exhaused. Next request must fail
-  GPR_ASSERT(!grpc_resource_user_alloc_threads(ru2, 20));
+  // Threads exhausted. Next request must fail
+  GPR_ASSERT(!grpc_resource_user_allocate_threads(ru2, 20));
 
   // Free 20 threads from two different users
   grpc_resource_user_free_threads(ru1, 10);
   grpc_resource_user_free_threads(ru2, 10);
 
   // Next request to 20 threads must succeed
-  GPR_ASSERT(grpc_resource_user_alloc_threads(ru2, 20));
+  GPR_ASSERT(grpc_resource_user_allocate_threads(ru2, 20));
 
   // No more thread quota again
-  GPR_ASSERT(!grpc_resource_user_alloc_threads(ru1, 20));
+  GPR_ASSERT(!grpc_resource_user_allocate_threads(ru1, 20));
 
   // Free 10 more
   grpc_resource_user_free_threads(ru1, 10);
 
-  GPR_ASSERT(grpc_resource_user_alloc_threads(ru1, 5));
-  GPR_ASSERT(!grpc_resource_user_alloc_threads(ru2, 10));  // Only 5 available
-  GPR_ASSERT(grpc_resource_user_alloc_threads(ru2, 5));
+  GPR_ASSERT(grpc_resource_user_allocate_threads(ru1, 5));
+  GPR_ASSERT(
+      !grpc_resource_user_allocate_threads(ru2, 10));  // Only 5 available
+  GPR_ASSERT(grpc_resource_user_allocate_threads(ru2, 5));
 
   // Teardown (ru1 and ru2 release all the quota back to rq)
   grpc_resource_user_unref(ru1);
@@ -841,7 +842,7 @@ static void test_thread_limit() {
   grpc_resource_quota_unref(rq);
 }
 
-// Change max quota in either directions dynamically
+// Change max quota in either direction dynamically
 static void test_thread_maxquota_change() {
   grpc_core::ExecCtx exec_ctx;
 
@@ -854,34 +855,34 @@ static void test_thread_maxquota_change() {
   grpc_resource_quota_set_max_threads(rq, 100);
 
   // Request quota for 100 threads (50 for ru1, 50 for ru2)
-  GPR_ASSERT(grpc_resource_user_alloc_threads(ru1, 50));
-  GPR_ASSERT(grpc_resource_user_alloc_threads(ru2, 50));
+  GPR_ASSERT(grpc_resource_user_allocate_threads(ru1, 50));
+  GPR_ASSERT(grpc_resource_user_allocate_threads(ru2, 50));
 
-  // Threads exhaused. Next request must fail
-  GPR_ASSERT(!grpc_resource_user_alloc_threads(ru2, 20));
+  // Threads exhausted. Next request must fail
+  GPR_ASSERT(!grpc_resource_user_allocate_threads(ru2, 20));
 
   // Increase maxquota and retry
   // Max threads = 150;
   grpc_resource_quota_set_max_threads(rq, 150);
-  GPR_ASSERT(grpc_resource_user_alloc_threads(ru2, 20));  // ru2 = 70, ru1 = 50
+  GPR_ASSERT(grpc_resource_user_allocate_threads(ru2, 20));  // ru2=70, ru1=50
 
   // Decrease maxquota (Note: Quota already given to ru1 and ru2 is unaffected)
   // Max threads = 10;
   grpc_resource_quota_set_max_threads(rq, 10);
 
   // New requests will fail until quota is available
-  GPR_ASSERT(!grpc_resource_user_alloc_threads(ru1, 10));
+  GPR_ASSERT(!grpc_resource_user_allocate_threads(ru1, 10));
 
   // Make quota available
-  grpc_resource_user_free_threads(ru1, 50);                // ru1 now has 0
-  GPR_ASSERT(!grpc_resource_user_alloc_threads(ru1, 10));  // Still not enough
+  grpc_resource_user_free_threads(ru1, 50);                   // ru1 now has 0
+  GPR_ASSERT(!grpc_resource_user_allocate_threads(ru1, 10));  // not enough
 
   grpc_resource_user_free_threads(ru2, 70);  // ru2 now has 0
 
   // Now we can get quota up-to 10, the current max
-  GPR_ASSERT(grpc_resource_user_alloc_threads(ru2, 10));
+  GPR_ASSERT(grpc_resource_user_allocate_threads(ru2, 10));
   // No more thread quota again
-  GPR_ASSERT(!grpc_resource_user_alloc_threads(ru1, 10));
+  GPR_ASSERT(!grpc_resource_user_allocate_threads(ru1, 10));
 
   // Teardown (ru1 and ru2 release all the quota back to rq)
   grpc_resource_user_unref(ru1);
diff --git a/test/cpp/thread_manager/thread_manager_test.cc b/test/cpp/thread_manager/thread_manager_test.cc
index a7ed2dd380..838f5f72ad 100644
--- a/test/cpp/thread_manager/thread_manager_test.cc
+++ b/test/cpp/thread_manager/thread_manager_test.cc
@@ -124,16 +124,18 @@ static void TestPollAndWork() {
       2 /* min_pollers */, 10 /* max_pollers */, 10 /* poll_duration_ms */,
       1 /* work_duration_ms */, 50 /* max_poll_calls */};
 
-  grpc::ThreadManagerTest test_thd_mgr("TestThreadManager", rq, settings);
+  grpc::ThreadManagerTest test_thread_mgr("TestThreadManager", rq, settings);
   grpc_resource_quota_unref(rq);
 
-  test_thd_mgr.Initialize();  // Start the thread manager
-  test_thd_mgr.Wait();        // Wait for all threads to finish
+  test_thread_mgr.Initialize();  // Start the thread manager
+  test_thread_mgr.Wait();        // Wait for all threads to finish
 
   // Verify that The number of times DoWork() was called is equal to the number
   // of times WORK_FOUND was returned
-  gpr_log(GPR_DEBUG, "DoWork() called %d times", test_thd_mgr.GetNumDoWork());
-  GPR_ASSERT(test_thd_mgr.GetNumDoWork() == test_thd_mgr.GetNumWorkFound());
+  gpr_log(GPR_DEBUG, "DoWork() called %d times",
+          test_thread_mgr.GetNumDoWork());
+  GPR_ASSERT(test_thread_mgr.GetNumDoWork() ==
+             test_thread_mgr.GetNumWorkFound());
 }
 
 static void TestThreadQuota() {
@@ -151,18 +153,20 @@ static void TestThreadQuota() {
   // Create two thread managers (but with same resource quota). This means
   // that the max number of active threads across BOTH the thread managers
   // cannot be greater than kMaxNumthreads
-  grpc::ThreadManagerTest test_thd_mgr_1("TestThreadManager-1", rq, settings);
-  grpc::ThreadManagerTest test_thd_mgr_2("TestThreadManager-2", rq, settings);
+  grpc::ThreadManagerTest test_thread_mgr_1("TestThreadManager-1", rq,
+                                            settings);
+  grpc::ThreadManagerTest test_thread_mgr_2("TestThreadManager-2", rq,
+                                            settings);
   // It is ok to unref resource quota before starting thread managers.
   grpc_resource_quota_unref(rq);
 
   // Start both thread managers
-  test_thd_mgr_1.Initialize();
-  test_thd_mgr_2.Initialize();
+  test_thread_mgr_1.Initialize();
+  test_thread_mgr_2.Initialize();
 
   // Wait for both to finish
-  test_thd_mgr_1.Wait();
-  test_thd_mgr_2.Wait();
+  test_thread_mgr_1.Wait();
+  test_thread_mgr_2.Wait();
 
   // Now verify that the total number of active threads in either thread manager
   // never exceeds kMaxNumThreads
@@ -173,8 +177,8 @@ static void TestThreadQuota() {
   // Its okay to not test this case here. The resource quota c-core tests
   // provide enough coverage to resource quota object with multiple resource
   // users
-  int max1 = test_thd_mgr_1.GetMaxActiveThreadsSoFar();
-  int max2 = test_thd_mgr_2.GetMaxActiveThreadsSoFar();
+  int max1 = test_thread_mgr_1.GetMaxActiveThreadsSoFar();
+  int max2 = test_thread_mgr_2.GetMaxActiveThreadsSoFar();
   gpr_log(
       GPR_DEBUG,
       "MaxActiveThreads in TestThreadManager_1: %d, TestThreadManager_2: %d",