From 54a3da2e99e19baae1c98ee14d405de7d356e526 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Tue, 18 Jun 2024 14:19:29 -0400
Subject: [PATCH] cpplint fixes

---
 test/unit/math/opencl/rev/bernoulli_cdf_test.cpp | 12 ++++++------
 .../math/opencl/rev/bernoulli_lccdf_test.cpp     | 14 +++++++-------
 .../opencl/rev/bernoulli_logit_glm_lpmf_test.cpp | 14 +++++++-------
 .../opencl/rev/bernoulli_logit_lpmf_test.cpp     | 10 +++++-----
 .../unit/math/opencl/rev/bernoulli_lpmf_test.cpp | 10 +++++-----
 .../math/opencl/rev/beta_binomial_lpmf_test.cpp  | 14 +++++++-------
 test/unit/math/opencl/rev/beta_lpdf_test.cpp     | 16 ++++++++--------
 .../opencl/rev/beta_proportion_lpdf_test.cpp     | 12 ++++++------
 .../opencl/rev/binomial_logit_glm_lpmf_test.cpp  | 14 +++++++-------
 .../math/opencl/rev/binomial_logit_lpmf_test.cpp | 14 +++++++-------
 test/unit/math/opencl/rev/binomial_lpmf_test.cpp | 14 +++++++-------
 .../rev/categorical_logit_glm_lpmf_test.cpp      | 16 ++++++++--------
 test/unit/math/opencl/rev/cauchy_cdf_test.cpp    | 14 +++++++-------
 test/unit/math/opencl/rev/cauchy_lccdf_test.cpp  | 12 ++++++------
 test/unit/math/opencl/rev/cauchy_lpdf_test.cpp   | 12 ++++++------
 .../math/opencl/rev/chi_square_lpdf_test.cpp     | 10 +++++-----
 .../unit/math/opencl/rev/dirichlet_lpdf_test.cpp |  6 +++---
 .../opencl/rev/double_exponential_cdf_test.cpp   | 12 ++++++------
 .../opencl/rev/double_exponential_lccdf_test.cpp | 12 ++++++------
 .../opencl/rev/double_exponential_lcdf_test.cpp  | 12 ++++++------
 .../opencl/rev/double_exponential_lpdf_test.cpp  | 14 +++++++-------
 .../math/opencl/rev/exp_mod_normal_cdf2_test.cpp |  4 ++--
 .../math/opencl/rev/exp_mod_normal_cdf_test.cpp  | 12 ++++++------
 .../opencl/rev/exp_mod_normal_lccdf2_test.cpp    |  2 +-
 .../opencl/rev/exp_mod_normal_lccdf3_test.cpp    |  2 +-
 .../opencl/rev/exp_mod_normal_lccdf4_test.cpp    |  2 +-
 .../opencl/rev/exp_mod_normal_lccdf_test.cpp     | 12 ++++++------
 .../opencl/rev/exp_mod_normal_lcdf2_test.cpp     |  2 +-
 .../opencl/rev/exp_mod_normal_lcdf3_test.cpp     |  2 +-
 .../opencl/rev/exp_mod_normal_lcdf4_test.cpp     |  2 +-
 .../math/opencl/rev/exp_mod_normal_lcdf_test.cpp | 12 ++++++------
 .../math/opencl/rev/exp_mod_normal_lpdf_test.cpp | 14 +++++++-------
 .../math/opencl/rev/exponential_cdf_test.cpp     | 10 +++++-----
 .../math/opencl/rev/exponential_lccdf_test.cpp   | 10 +++++-----
 .../math/opencl/rev/exponential_lcdf_test.cpp    | 10 +++++-----
 .../math/opencl/rev/exponential_lpdf_test.cpp    | 10 +++++-----
 test/unit/math/opencl/rev/frechet_cdf_test.cpp   | 12 ++++++------
 test/unit/math/opencl/rev/frechet_lccdf_test.cpp | 12 ++++++------
 test/unit/math/opencl/rev/frechet_lcdf_test.cpp  | 12 ++++++------
 test/unit/math/opencl/rev/frechet_lpdf_test.cpp  | 12 ++++++------
 test/unit/math/opencl/rev/gamma_lpdf_test.cpp    | 12 ++++++------
 test/unit/math/opencl/rev/gumbel_cdf_test.cpp    | 12 ++++++------
 test/unit/math/opencl/rev/gumbel_lccdf_test.cpp  | 12 ++++++------
 test/unit/math/opencl/rev/gumbel_lcdf_test.cpp   | 12 ++++++------
 test/unit/math/opencl/rev/gumbel_lpdf_test.cpp   | 12 ++++++------
 .../math/opencl/rev/inv_chi_square_lpdf_test.cpp | 12 ++++++------
 .../unit/math/opencl/rev/inv_gamma_lpdf_test.cpp | 14 +++++++-------
 test/unit/math/opencl/rev/logistic_cdf_test.cpp  | 14 +++++++-------
 .../unit/math/opencl/rev/logistic_lccdf_test.cpp | 14 +++++++-------
 test/unit/math/opencl/rev/logistic_lcdf_test.cpp | 14 +++++++-------
 test/unit/math/opencl/rev/logistic_lpdf_test.cpp | 14 +++++++-------
 test/unit/math/opencl/rev/lognormal_cdf_test.cpp | 14 +++++++-------
 .../math/opencl/rev/lognormal_lccdf_test.cpp     | 14 +++++++-------
 .../unit/math/opencl/rev/lognormal_lcdf_test.cpp | 14 +++++++-------
 .../unit/math/opencl/rev/lognormal_lpdf_test.cpp | 14 +++++++-------
 .../rev/multi_normal_cholesky_lpdf_test.cpp      |  6 +++---
 .../rev/neg_binomial_2_log_glm_lpmf_test.cpp     | 14 +++++++-------
 .../opencl/rev/neg_binomial_2_log_lpmf_test.cpp  | 14 +++++++-------
 .../math/opencl/rev/neg_binomial_2_lpmf_test.cpp |  2 +-
 test/unit/math/opencl/rev/normal_cdf_test.cpp    | 12 ++++++------
 .../math/opencl/rev/normal_id_glm_lpdf_test.cpp  | 14 +++++++-------
 test/unit/math/opencl/rev/normal_lccdf_test.cpp  | 12 ++++++------
 test/unit/math/opencl/rev/normal_lcdf_test.cpp   | 12 ++++++------
 test/unit/math/opencl/rev/normal_lpdf_test.cpp   | 12 ++++++------
 .../rev/ordered_logistic_glm_lpmf_test.cpp       | 14 +++++++-------
 .../opencl/rev/ordered_logistic_lpmf_test.cpp    | 10 +++++-----
 test/unit/math/opencl/rev/pareto_cdf_test.cpp    | 14 +++++++-------
 test/unit/math/opencl/rev/pareto_lccdf_test.cpp  | 14 +++++++-------
 test/unit/math/opencl/rev/pareto_lcdf_test.cpp   | 14 +++++++-------
 test/unit/math/opencl/rev/pareto_lpdf_test.cpp   | 12 ++++++------
 .../math/opencl/rev/pareto_type_2_cdf_test.cpp   | 14 +++++++-------
 .../math/opencl/rev/pareto_type_2_lccdf_test.cpp | 14 +++++++-------
 .../math/opencl/rev/pareto_type_2_lcdf_test.cpp  | 14 +++++++-------
 .../math/opencl/rev/pareto_type_2_lpdf_test.cpp  | 14 +++++++-------
 .../opencl/rev/poisson_log_glm_lpmf_test.cpp     | 14 +++++++-------
 .../math/opencl/rev/poisson_log_lpmf_test.cpp    | 10 +++++-----
 test/unit/math/opencl/rev/poisson_lpmf_test.cpp  | 10 +++++-----
 test/unit/math/opencl/rev/rayleigh_cdf_test.cpp  | 10 +++++-----
 .../unit/math/opencl/rev/rayleigh_lccdf_test.cpp | 10 +++++-----
 test/unit/math/opencl/rev/rayleigh_lcdf_test.cpp | 10 +++++-----
 test/unit/math/opencl/rev/rayleigh_lpdf_test.cpp | 10 +++++-----
 .../rev/scaled_inv_chi_square_lpdf_test.cpp      | 14 +++++++-------
 .../rev/skew_double_exponential_cdf2_test.cpp    |  4 ++--
 .../rev/skew_double_exponential_cdf_test.cpp     | 12 ++++++------
 .../rev/skew_double_exponential_lccdf2_test.cpp  |  4 ++--
 .../rev/skew_double_exponential_lccdf_test.cpp   | 12 ++++++------
 .../rev/skew_double_exponential_lcdf2_test.cpp   |  4 ++--
 .../rev/skew_double_exponential_lcdf_test.cpp    | 12 ++++++------
 .../rev/skew_double_exponential_lpdf_test.cpp    | 14 +++++++-------
 .../math/opencl/rev/skew_normal_lpdf_test.cpp    | 14 +++++++-------
 .../unit/math/opencl/rev/std_normal_cdf_test.cpp |  6 +++---
 .../math/opencl/rev/std_normal_lccdf_test.cpp    |  6 +++---
 .../math/opencl/rev/std_normal_lcdf_test.cpp     |  6 +++---
 .../math/opencl/rev/std_normal_lpdf_test.cpp     |  6 +++---
 .../math/opencl/rev/student_t_lpdf2_test.cpp     |  6 +++---
 .../unit/math/opencl/rev/student_t_lpdf_test.cpp |  8 ++++----
 test/unit/math/opencl/rev/uniform_cdf_test.cpp   | 14 +++++++-------
 test/unit/math/opencl/rev/uniform_lccdf_test.cpp | 14 +++++++-------
 test/unit/math/opencl/rev/uniform_lcdf_test.cpp  | 14 +++++++-------
 test/unit/math/opencl/rev/uniform_lpdf_test.cpp  | 14 +++++++-------
 test/unit/math/opencl/rev/weibull_cdf_test.cpp   | 12 ++++++------
 test/unit/math/opencl/rev/weibull_lccdf_test.cpp | 12 ++++++------
 test/unit/math/opencl/rev/weibull_lcdf_test.cpp  | 12 ++++++------
 test/unit/math/opencl/rev/weibull_lpdf_test.cpp  | 12 ++++++------
 104 files changed, 577 insertions(+), 577 deletions(-)

diff --git a/test/unit/math/opencl/rev/bernoulli_cdf_test.cpp b/test/unit/math/opencl/rev/bernoulli_cdf_test.cpp
index 91bd1fb5897..46dfd8ae389 100644
--- a/test/unit/math/opencl/rev/bernoulli_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/bernoulli_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistBernoulliCdf_error_checking) {
   int N = 3;
 
   std::vector<int> n{1, -2, 11};
@@ -43,7 +43,7 @@ auto bernoulli_cdf_functor = [](const auto& n, const auto& theta) {
   return stan::math::bernoulli_cdf(n, theta);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliCdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistBernoulliCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -58,7 +58,7 @@ TEST_F(OpenCLRevTests, probdistributionsBernoulliCdf_opencl_matches_cpu_small) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBernoulliCdf_opencl_matches_cpu_small_n_negative) {
+       probdistBernoulliCdf_opencl_matches_cpu_small_n_negative) {
   int N = 3;
   int M = 2;
 
@@ -72,7 +72,7 @@ TEST_F(OpenCLRevTests,
                                                 theta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliCdf_opencl_broadcast_n) {
+TEST_F(OpenCLRevTests, probdistBernoulliCdf_opencl_broadcast_n) {
   int N = 3;
 
   int n_scal = 1;
@@ -83,7 +83,7 @@ TEST_F(OpenCLRevTests, probdistributionsBernoulliCdf_opencl_broadcast_n) {
                                                          n_scal, theta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliCdf_opencl_broadcast_theta) {
+TEST_F(OpenCLRevTests, probdistBernoulliCdf_opencl_broadcast_theta) {
   int N = 3;
 
   std::vector<int> n{0, 1, 0};
@@ -93,7 +93,7 @@ TEST_F(OpenCLRevTests, probdistributionsBernoulliCdf_opencl_broadcast_theta) {
                                                          n, theta_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistBernoulliCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   std::vector<int> n(N);
diff --git a/test/unit/math/opencl/rev/bernoulli_lccdf_test.cpp b/test/unit/math/opencl/rev/bernoulli_lccdf_test.cpp
index 1fb6d76ee09..e827a5fd751 100644
--- a/test/unit/math/opencl/rev/bernoulli_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/bernoulli_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistBernoulliLccdf_error_checking) {
   int N = 3;
 
   std::vector<int> n{1, -2, 11};
@@ -44,7 +44,7 @@ auto bernoulli_lccdf_functor = [](const auto& n, const auto& theta) {
 };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBernoulliLccdf_opencl_matches_cpu_small) {
+       probdistBernoulliLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -59,7 +59,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBernoulliLccdf_opencl_matches_cpu_small_n_negative) {
+       probdistBernoulliLccdf_opencl_matches_cpu_small_n_negative) {
   int N = 3;
   int M = 2;
 
@@ -74,7 +74,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBernoulliLccdf_opencl_matches_cpu_small_n_over_one) {
+       probdistBernoulliLccdf_opencl_matches_cpu_small_n_over_one) {
   int N = 3;
   int M = 2;
 
@@ -88,7 +88,7 @@ TEST_F(OpenCLRevTests,
                                                 theta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliLccdf_opencl_broadcast_n) {
+TEST_F(OpenCLRevTests, probdistBernoulliLccdf_opencl_broadcast_n) {
   int N = 3;
 
   int n_scal = 0;
@@ -99,7 +99,7 @@ TEST_F(OpenCLRevTests, probdistributionsBernoulliLccdf_opencl_broadcast_n) {
       bernoulli_lccdf_functor, n_scal, theta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliLccdf_opencl_broadcast_theta) {
+TEST_F(OpenCLRevTests, probdistBernoulliLccdf_opencl_broadcast_theta) {
   int N = 3;
 
   std::vector<int> n{0, 0, 0};
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests, probdistributionsBernoulliLccdf_opencl_broadcast_theta) {
       bernoulli_lccdf_functor, n, theta_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliLccdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistBernoulliLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   std::vector<int> n(N);
diff --git a/test/unit/math/opencl/rev/bernoulli_logit_glm_lpmf_test.cpp b/test/unit/math/opencl/rev/bernoulli_logit_glm_lpmf_test.cpp
index 671796fe92e..feadcc0d8cd 100644
--- a/test/unit/math/opencl/rev/bernoulli_logit_glm_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/bernoulli_logit_glm_lpmf_test.cpp
@@ -13,7 +13,7 @@ using stan::math::var;
 using stan::test::expect_near_rel;
 using std::vector;
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliLogitGLM_error_checking) {
+TEST_F(OpenCLRevTests, probdistBernoulliLogitGLM_error_checking) {
   int N = 3;
   int M = 2;
 
@@ -101,7 +101,7 @@ auto bernoulli_logit_glm_lpmf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBernoulliLogitGLM_opencl_matches_cpu_small_simple) {
+       probdistBernoulliLogitGLM_opencl_matches_cpu_small_simple) {
   int N = 3;
   int M = 2;
 
@@ -118,7 +118,7 @@ TEST_F(OpenCLRevTests,
       bernoulli_logit_glm_lpmf_functor_propto, y, x, alpha, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliLogitGLM_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistBernoulliLogitGLM_opencl_broadcast_y) {
   int N = 3;
   int M = 2;
 
@@ -136,7 +136,7 @@ TEST_F(OpenCLRevTests, probdistributionsBernoulliLogitGLM_opencl_broadcast_y) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBernoulliLogitGLM_opencl_matches_cpu_zero_instances) {
+       probdistBernoulliLogitGLM_opencl_matches_cpu_zero_instances) {
   int N = 0;
   int M = 2;
 
@@ -153,7 +153,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBernoulliLogitGLM_opencl_matches_cpu_zero_attributes) {
+       probdistBernoulliLogitGLM_opencl_matches_cpu_zero_attributes) {
   int N = 3;
   int M = 0;
 
@@ -170,7 +170,7 @@ TEST_F(OpenCLRevTests,
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsBernoulliLogitGLM_opencl_matches_cpu_small_vector_alpha) {
+    probdistBernoulliLogitGLM_opencl_matches_cpu_small_vector_alpha) {
   int N = 3;
   int M = 2;
 
@@ -189,7 +189,7 @@ TEST_F(
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBernoulliLogitGLM_opencl_matches_cpu_big) {
+       probdistBernoulliLogitGLM_opencl_matches_cpu_big) {
   int N = 153;
   int M = 71;
 
diff --git a/test/unit/math/opencl/rev/bernoulli_logit_lpmf_test.cpp b/test/unit/math/opencl/rev/bernoulli_logit_lpmf_test.cpp
index fafee386901..28e6e2c7470 100644
--- a/test/unit/math/opencl/rev/bernoulli_logit_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/bernoulli_logit_lpmf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliLogit_error_checking) {
+TEST_F(OpenCLRevTests, probdistBernoulliLogit_error_checking) {
   int N = 3;
 
   std::vector<int> n{1, 0, 1};
@@ -47,7 +47,7 @@ auto bernoulli_logit_lpmf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBernoulliLogit_opencl_matches_cpu_small) {
+       probdistBernoulliLogit_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -65,7 +65,7 @@ TEST_F(OpenCLRevTests,
       bernoulli_logit_lpmf_functor_propto, n, theta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliLogit_opencl_broadcast_n) {
+TEST_F(OpenCLRevTests, probdistBernoulliLogit_opencl_broadcast_n) {
   int N = 3;
 
   int n = 1;
@@ -78,7 +78,7 @@ TEST_F(OpenCLRevTests, probdistributionsBernoulliLogit_opencl_broadcast_n) {
       bernoulli_logit_lpmf_functor_propto, n, theta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliLogit_opencl_broadcast_theta) {
+TEST_F(OpenCLRevTests, probdistBernoulliLogit_opencl_broadcast_theta) {
   int N = 3;
 
   std::vector<int> n{0, 1, 0};
@@ -90,7 +90,7 @@ TEST_F(OpenCLRevTests, probdistributionsBernoulliLogit_opencl_broadcast_theta) {
       bernoulli_logit_lpmf_functor_propto, n, theta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulliLogit_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistBernoulliLogit_opencl_matches_cpu_big) {
   int N = 153;
 
   std::vector<int> n(N);
diff --git a/test/unit/math/opencl/rev/bernoulli_lpmf_test.cpp b/test/unit/math/opencl/rev/bernoulli_lpmf_test.cpp
index eb5b21fdb0d..4236dbe497a 100644
--- a/test/unit/math/opencl/rev/bernoulli_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/bernoulli_lpmf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulli_error_checking) {
+TEST_F(OpenCLRevTests, probdistBernoulli_error_checking) {
   int N = 3;
 
   std::vector<int> n{1, 0, 1};
@@ -45,7 +45,7 @@ auto bernoulli_lpmf_functor_propto = [](const auto& n, const auto& theta) {
   return stan::math::bernoulli_lpmf<true>(n, theta);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulli_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistBernoulli_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -63,7 +63,7 @@ TEST_F(OpenCLRevTests, probdistributionsBernoulli_opencl_matches_cpu_small) {
                                                 n, theta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulli_opencl_broadcast_n) {
+TEST_F(OpenCLRevTests, probdistBernoulli_opencl_broadcast_n) {
   int N = 3;
 
   int n_scal = 1;
@@ -76,7 +76,7 @@ TEST_F(OpenCLRevTests, probdistributionsBernoulli_opencl_broadcast_n) {
       bernoulli_lpmf_functor_propto, n_scal, theta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulli_opencl_broadcast_theta) {
+TEST_F(OpenCLRevTests, probdistBernoulli_opencl_broadcast_theta) {
   int N = 3;
 
   std::vector<int> n{0, 1, 0};
@@ -88,7 +88,7 @@ TEST_F(OpenCLRevTests, probdistributionsBernoulli_opencl_broadcast_theta) {
       bernoulli_lpmf_functor_propto, n, theta_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBernoulli_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistBernoulli_opencl_matches_cpu_big) {
   int N = 153;
 
   std::vector<int> n(N);
diff --git a/test/unit/math/opencl/rev/beta_binomial_lpmf_test.cpp b/test/unit/math/opencl/rev/beta_binomial_lpmf_test.cpp
index e594f02e3ec..f170601d765 100644
--- a/test/unit/math/opencl/rev/beta_binomial_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/beta_binomial_lpmf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsBetaBinomial_error_checking) {
+TEST_F(OpenCLRevTests, probdistBetaBinomial_error_checking) {
   int N = 3;
 
   std::vector<int> n{2, 0, 12};
@@ -86,7 +86,7 @@ auto beta_binomial_lpmf_functor_propto
         return stan::math::beta_binomial_lpmf<true>(n, N, alpha, beta);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsBetaBinomial_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistBetaBinomial_opencl_matches_cpu_small) {
   int N_ = 3;
 
   std::vector<int> n{2, 0, 12};
@@ -108,7 +108,7 @@ TEST_F(OpenCLRevTests, probdistributionsBetaBinomial_opencl_matches_cpu_small) {
       beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBetaBinomial_opencl_broadcast_n) {
+TEST_F(OpenCLRevTests, probdistBetaBinomial_opencl_broadcast_n) {
   int N_ = 3;
 
   int n = 1;
@@ -130,7 +130,7 @@ TEST_F(OpenCLRevTests, probdistributionsBetaBinomial_opencl_broadcast_n) {
       beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBetaBinomial_opencl_broadcast_N) {
+TEST_F(OpenCLRevTests, probdistBetaBinomial_opencl_broadcast_N) {
   int N_ = 3;
 
   std::vector<int> n{2, 0, 12};
@@ -152,7 +152,7 @@ TEST_F(OpenCLRevTests, probdistributionsBetaBinomial_opencl_broadcast_N) {
       beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBetaBinomial_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistBetaBinomial_opencl_broadcast_alpha) {
   int N_ = 3;
 
   std::vector<int> n{2, 0, 12};
@@ -171,7 +171,7 @@ TEST_F(OpenCLRevTests, probdistributionsBetaBinomial_opencl_broadcast_alpha) {
       beta_binomial_lpmf_functor_propto, n, N, alpha, beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBetaBinomial_opencl_broadcast_beta) {
+TEST_F(OpenCLRevTests, probdistBetaBinomial_opencl_broadcast_beta) {
   int N_ = 3;
 
   std::vector<int> n{2, 0, 12};
@@ -189,7 +189,7 @@ TEST_F(OpenCLRevTests, probdistributionsBetaBinomial_opencl_broadcast_beta) {
       beta_binomial_lpmf_functor_propto, n, N, alpha.transpose().eval(), beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBetaBinomial_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistBetaBinomial_opencl_matches_cpu_big) {
   int N_ = 153;
 
   std::vector<int> n(N_);
diff --git a/test/unit/math/opencl/rev/beta_lpdf_test.cpp b/test/unit/math/opencl/rev/beta_lpdf_test.cpp
index 010d6e62aef..5edab3ef65f 100644
--- a/test/unit/math/opencl/rev/beta_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/beta_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsBeta_error_checking) {
+TEST_F(OpenCLRevTests, probdistBeta_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -83,7 +83,7 @@ auto beta_lpdf_functor_propto
         return stan::math::beta_lpdf<true>(y, alpha, beta);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistBeta_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -106,7 +106,7 @@ TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_matches_cpu_small) {
       beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistBeta_opencl_broadcast_y) {
   int N = 3;
 
   double y = 0.3;
@@ -125,7 +125,7 @@ TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_broadcast_y) {
       beta_lpdf_functor_propto, y, alpha, beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistBeta_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -144,7 +144,7 @@ TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_broadcast_alpha) {
       beta_lpdf_functor_propto, y, alpha, beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_broadcast_beta) {
+TEST_F(OpenCLRevTests, probdistBeta_opencl_broadcast_beta) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -165,7 +165,7 @@ TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_broadcast_beta) {
       beta_lpdf_functor_propto, y, alpha.transpose().eval(), beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_y_alpha_scalar) {
+TEST_F(OpenCLRevTests, probdistBeta_opencl_y_alpha_scalar) {
   int N = 3;
 
   double y = 0.3;
@@ -179,7 +179,7 @@ TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_y_alpha_scalar) {
                                                 alpha, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_y_beta_scalar) {
+TEST_F(OpenCLRevTests, probdistBeta_opencl_y_beta_scalar) {
   int N = 3;
 
   double y = 0.3;
@@ -193,7 +193,7 @@ TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_y_beta_scalar) {
                                                 alpha, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBeta_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistBeta_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/beta_proportion_lpdf_test.cpp b/test/unit/math/opencl/rev/beta_proportion_lpdf_test.cpp
index 76908e687ad..272341f9edb 100644
--- a/test/unit/math/opencl/rev/beta_proportion_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/beta_proportion_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsBetaProportion_error_checking) {
+TEST_F(OpenCLRevTests, probdistBetaProportion_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -64,7 +64,7 @@ auto beta_proportion_lpdf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBetaProportion_opencl_matches_cpu_small) {
+       probdistBetaProportion_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -83,7 +83,7 @@ TEST_F(OpenCLRevTests,
       mu.transpose().eval(), kappa.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBetaProportion_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistBetaProportion_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 0.7;
@@ -103,7 +103,7 @@ TEST_F(OpenCLRevTests, probdistributionsBetaProportion_opencl_broadcast_y) {
       kappa.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBetaProportion_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistBetaProportion_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -123,7 +123,7 @@ TEST_F(OpenCLRevTests, probdistributionsBetaProportion_opencl_broadcast_mu) {
       kappa.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBetaProportion_opencl_broadcast_kappa) {
+TEST_F(OpenCLRevTests, probdistBetaProportion_opencl_broadcast_kappa) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -143,7 +143,7 @@ TEST_F(OpenCLRevTests, probdistributionsBetaProportion_opencl_broadcast_kappa) {
       kappa_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBetaProportion_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistBetaProportion_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/binomial_logit_glm_lpmf_test.cpp b/test/unit/math/opencl/rev/binomial_logit_glm_lpmf_test.cpp
index 150008c16bc..b111ef77a07 100644
--- a/test/unit/math/opencl/rev/binomial_logit_glm_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/binomial_logit_glm_lpmf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsBinomialLogitGLM_error_checking) {
+TEST_F(OpenCLRevTests, probdistBinomialLogitGLM_error_checking) {
   using stan::math::binomial_logit_glm_lpmf;
   using stan::math::matrix_cl;
 
@@ -110,7 +110,7 @@ auto binomial_logit_glm_lpmf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBinomialLogitGLM_opencl_matches_cpu_small_simple) {
+       probdistBinomialLogitGLM_opencl_matches_cpu_small_simple) {
   int N = 3;
   int M = 2;
 
@@ -128,7 +128,7 @@ TEST_F(OpenCLRevTests,
       binomial_logit_glm_lpmf_functor_propto, n, trials, x, alpha, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBinomialLogitGLM_opencl_broadcast_n) {
+TEST_F(OpenCLRevTests, probdistBinomialLogitGLM_opencl_broadcast_n) {
   int N = 3;
   int M = 2;
 
@@ -147,7 +147,7 @@ TEST_F(OpenCLRevTests, probdistributionsBinomialLogitGLM_opencl_broadcast_n) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBinomialLogitGLM_opencl_matches_cpu_zero_instances) {
+       probdistBinomialLogitGLM_opencl_matches_cpu_zero_instances) {
   int N = 0;
   int M = 2;
 
@@ -165,7 +165,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBinomialLogitGLM_opencl_matches_cpu_zero_attributes) {
+       probdistBinomialLogitGLM_opencl_matches_cpu_zero_attributes) {
   int N = 3;
   int M = 0;
 
@@ -183,7 +183,7 @@ TEST_F(OpenCLRevTests,
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsBinomialLogitGLM_opencl_matches_cpu_small_vector_alpha) {
+    probdistBinomialLogitGLM_opencl_matches_cpu_small_vector_alpha) {
   int N = 3;
   int M = 2;
 
@@ -203,7 +203,7 @@ TEST_F(
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBinomialLogitGLM_opencl_matches_cpu_big) {
+       probdistBinomialLogitGLM_opencl_matches_cpu_big) {
   int N = 153;
   int M = 71;
 
diff --git a/test/unit/math/opencl/rev/binomial_logit_lpmf_test.cpp b/test/unit/math/opencl/rev/binomial_logit_lpmf_test.cpp
index ac0798cb74d..0c5c1e11eee 100644
--- a/test/unit/math/opencl/rev/binomial_logit_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/binomial_logit_lpmf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsBinomialLogit_error_checking) {
+TEST_F(OpenCLRevTests, probdistBinomialLogit_error_checking) {
   int N = 3;
 
   std::vector<int> n{1, 0, 4};
@@ -60,7 +60,7 @@ auto binomial_logit_lpmf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsBinomialLogit_opencl_matches_cpu_small) {
+       probdistBinomialLogit_opencl_matches_cpu_small) {
   int N = 3;
 
   std::vector<int> n{0, 1, 3};
@@ -78,7 +78,7 @@ TEST_F(OpenCLRevTests,
       binomial_logit_lpmf_functor_propto, n, m, alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBinomialLogit_opencl_broadcast_n) {
+TEST_F(OpenCLRevTests, probdistBinomialLogit_opencl_broadcast_n) {
   int N = 3;
 
   int n = 1;
@@ -96,7 +96,7 @@ TEST_F(OpenCLRevTests, probdistributionsBinomialLogit_opencl_broadcast_n) {
       binomial_logit_lpmf_functor_propto, n, m, alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBinomialLogit_opencl_broadcast_N) {
+TEST_F(OpenCLRevTests, probdistBinomialLogit_opencl_broadcast_N) {
   int N = 3;
 
   std::vector<int> n{0, 1, 12};
@@ -114,7 +114,7 @@ TEST_F(OpenCLRevTests, probdistributionsBinomialLogit_opencl_broadcast_N) {
       binomial_logit_lpmf_functor_propto, n, m, alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBinomialLogit_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistBinomialLogit_opencl_broadcast_alpha) {
   int N = 3;
 
   std::vector<int> n{0, 1, 12};
@@ -127,7 +127,7 @@ TEST_F(OpenCLRevTests, probdistributionsBinomialLogit_opencl_broadcast_alpha) {
       binomial_logit_lpmf_functor_propto, n, m, alpha_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBinomialLogit_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistBinomialLogit_opencl_matches_cpu_big) {
   int N = 153;
 
   std::vector<int> n(N);
@@ -150,7 +150,7 @@ TEST_F(OpenCLRevTests, probdistributionsBinomialLogit_opencl_matches_cpu_big) {
       binomial_logit_lpmf_functor_propto, n, m, alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBinomialLogit_opencl_n_N_scalar) {
+TEST_F(OpenCLRevTests, probdistBinomialLogit_opencl_n_N_scalar) {
   int N = 3;
 
   int n = 1;
diff --git a/test/unit/math/opencl/rev/binomial_lpmf_test.cpp b/test/unit/math/opencl/rev/binomial_lpmf_test.cpp
index 95a13d3812e..51a413280c3 100644
--- a/test/unit/math/opencl/rev/binomial_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/binomial_lpmf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsBinomial_error_checking) {
+TEST_F(OpenCLRevTests, probdistBinomial_error_checking) {
   int N = 3;
 
   std::vector<int> n{1, 0, 4};
@@ -64,7 +64,7 @@ auto binomial_lpmf_functor_propto
         return stan::math::binomial_lpmf<true>(n, N, theta);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsBinomial_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistBinomial_opencl_matches_cpu_small) {
   int N = 3;
 
   std::vector<int> n{0, 1, 3};
@@ -82,7 +82,7 @@ TEST_F(OpenCLRevTests, probdistributionsBinomial_opencl_matches_cpu_small) {
                                                 m, theta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBinomial_opencl_broadcast_n) {
+TEST_F(OpenCLRevTests, probdistBinomial_opencl_broadcast_n) {
   int N = 3;
 
   int n = 1;
@@ -100,7 +100,7 @@ TEST_F(OpenCLRevTests, probdistributionsBinomial_opencl_broadcast_n) {
       binomial_lpmf_functor_propto, n, m, theta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBinomial_opencl_broadcast_N) {
+TEST_F(OpenCLRevTests, probdistBinomial_opencl_broadcast_N) {
   int N = 3;
 
   std::vector<int> n{0, 1, 12};
@@ -118,7 +118,7 @@ TEST_F(OpenCLRevTests, probdistributionsBinomial_opencl_broadcast_N) {
       binomial_lpmf_functor_propto, n, m, theta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBinomial_opencl_broadcast_theta) {
+TEST_F(OpenCLRevTests, probdistBinomial_opencl_broadcast_theta) {
   int N = 3;
 
   std::vector<int> n{0, 1, 12};
@@ -131,7 +131,7 @@ TEST_F(OpenCLRevTests, probdistributionsBinomial_opencl_broadcast_theta) {
       binomial_lpmf_functor_propto, n, m, theta_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBinomial_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistBinomial_opencl_matches_cpu_big) {
   int N = 153;
 
   std::vector<int> n(N);
@@ -154,7 +154,7 @@ TEST_F(OpenCLRevTests, probdistributionsBinomial_opencl_matches_cpu_big) {
                                                 m, theta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsBinomial_opencl_n_N_scalar) {
+TEST_F(OpenCLRevTests, probdistBinomial_opencl_n_N_scalar) {
   int N = 3;
 
   int n = 1;
diff --git a/test/unit/math/opencl/rev/categorical_logit_glm_lpmf_test.cpp b/test/unit/math/opencl/rev/categorical_logit_glm_lpmf_test.cpp
index 384a0cb32eb..9361ae27c62 100644
--- a/test/unit/math/opencl/rev/categorical_logit_glm_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/categorical_logit_glm_lpmf_test.cpp
@@ -12,7 +12,7 @@ using stan::math::matrix_cl;
 using stan::math::var;
 using std::vector;
 
-TEST_F(OpenCLRevTests, probdistributionsCategoricalLogitGLM_error_checking) {
+TEST_F(OpenCLRevTests, probdistCategoricalLogitGLM_error_checking) {
   int N = 3;
   int M = 2;
   int C = 3;
@@ -104,7 +104,7 @@ auto categorical_logit_glm_lpmf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsCategoricalLogitGLM_opencl_matches_cpu_small_simple) {
+       probdistCategoricalLogitGLM_opencl_matches_cpu_small_simple) {
   int N = 3;
   int M = 2;
   int C = 3;
@@ -124,7 +124,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsCategoricalLogitGLM_opencl_broadcast_y) {
+       probdistCategoricalLogitGLM_opencl_broadcast_y) {
   int N = 3;
   int M = 2;
   int C = 3;
@@ -144,7 +144,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsCategoricalLogitGLM_opencl_matches_cpu_zero_instances) {
+       probdistCategoricalLogitGLM_opencl_matches_cpu_zero_instances) {
   int N = 0;
   int M = 2;
   int C = 3;
@@ -164,7 +164,7 @@ TEST_F(OpenCLRevTests,
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsCategoricalLogitGLM_opencl_matches_cpu_zero_attributes) {
+    probdistCategoricalLogitGLM_opencl_matches_cpu_zero_attributes) {
   int N = 3;
   int M = 0;
   int C = 3;
@@ -182,7 +182,7 @@ TEST_F(
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsCategoricalLogitGLM_opencl_matches_cpu_single_class) {
+       probdistCategoricalLogitGLM_opencl_matches_cpu_single_class) {
   int N = 3;
   int M = 2;
   int C = 1;
@@ -202,7 +202,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsCategoricalLogitGLM_opencl_matches_cpu_all_vars) {
+       probdistCategoricalLogitGLM_opencl_matches_cpu_all_vars) {
   int N = 5;
   int M = 3;
   int C = 2;
@@ -224,7 +224,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsCategoricalLogitGLM_opencl_matches_cpu_big) {
+       probdistCategoricalLogitGLM_opencl_matches_cpu_big) {
   int N = 153;
   int M = 71;
   int C = 43;
diff --git a/test/unit/math/opencl/rev/cauchy_cdf_test.cpp b/test/unit/math/opencl/rev/cauchy_cdf_test.cpp
index e92d027f02d..d012e7b4a6e 100644
--- a/test/unit/math/opencl/rev/cauchy_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/cauchy_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsCauchyCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistCauchyCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -60,7 +60,7 @@ auto cauchy_cdf_functor = [](const auto& y, const auto& mu, const auto& sigma) {
   return stan::math::cauchy_cdf(y, mu, sigma);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsCauchyCdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistCauchyCdf_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -78,7 +78,7 @@ TEST_F(OpenCLRevTests, probdistributionsCauchyCdf_opencl_matches_cpu_small) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsCauchyCdf_opencl_matches_cpu_small_y_neg_inf) {
+       probdistCauchyCdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -95,7 +95,7 @@ TEST_F(OpenCLRevTests,
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsCauchyCdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistCauchyCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -110,7 +110,7 @@ TEST_F(OpenCLRevTests, probdistributionsCauchyCdf_opencl_broadcast_y) {
       cauchy_cdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsCauchyCdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistCauchyCdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -125,7 +125,7 @@ TEST_F(OpenCLRevTests, probdistributionsCauchyCdf_opencl_broadcast_mu) {
       cauchy_cdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsCauchyCdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistCauchyCdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -140,7 +140,7 @@ TEST_F(OpenCLRevTests, probdistributionsCauchyCdf_opencl_broadcast_sigma) {
       cauchy_cdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsCauchyCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistCauchyCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/cauchy_lccdf_test.cpp b/test/unit/math/opencl/rev/cauchy_lccdf_test.cpp
index 29e1e85ad6d..96d6c22f469 100644
--- a/test/unit/math/opencl/rev/cauchy_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/cauchy_lccdf_test.cpp
@@ -6,7 +6,7 @@
 #include <vector>
 
 namespace cauchy_lccdf_test {
-TEST_F(OpenCLRevTests, probdistributionsCauchyLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistCauchyLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -62,7 +62,7 @@ auto cauchy_lccdf_functor
         return stan::math::cauchy_lccdf(y, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsCauchyLccdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistCauchyLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -80,7 +80,7 @@ TEST_F(OpenCLRevTests, probdistributionsCauchyLccdf_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsCauchyLccdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistCauchyLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -95,7 +95,7 @@ TEST_F(OpenCLRevTests, probdistributionsCauchyLccdf_opencl_broadcast_y) {
       cauchy_lccdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsCauchyLccdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistCauchyLccdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -110,7 +110,7 @@ TEST_F(OpenCLRevTests, probdistributionsCauchyLccdf_opencl_broadcast_mu) {
       cauchy_lccdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsCauchyLccdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistCauchyLccdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -125,7 +125,7 @@ TEST_F(OpenCLRevTests, probdistributionsCauchyLccdf_opencl_broadcast_sigma) {
       cauchy_lccdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsCauchyLccdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistCauchyLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/cauchy_lpdf_test.cpp b/test/unit/math/opencl/rev/cauchy_lpdf_test.cpp
index 9f8f00a0f43..0f9dceae3da 100644
--- a/test/unit/math/opencl/rev/cauchy_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/cauchy_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsCauchy_error_checking) {
+TEST_F(OpenCLRevTests, probdistCauchy_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -65,7 +65,7 @@ auto cauchy_lpdf_functor_propto
         return stan::math::cauchy_lpdf<true>(y, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsCauchy_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistCauchy_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -88,7 +88,7 @@ TEST_F(OpenCLRevTests, probdistributionsCauchy_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsCauchy_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistCauchy_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -107,7 +107,7 @@ TEST_F(OpenCLRevTests, probdistributionsCauchy_opencl_broadcast_y) {
       cauchy_lpdf_functor_propto, y_scal, mu, sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsCauchy_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistCauchy_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -126,7 +126,7 @@ TEST_F(OpenCLRevTests, probdistributionsCauchy_opencl_broadcast_mu) {
       cauchy_lpdf_functor_propto, y, mu_scal, sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsCauchy_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistCauchy_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -145,7 +145,7 @@ TEST_F(OpenCLRevTests, probdistributionsCauchy_opencl_broadcast_sigma) {
       cauchy_lpdf_functor_propto, y, mu.transpose().eval(), sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsCauchy_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistCauchy_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/chi_square_lpdf_test.cpp b/test/unit/math/opencl/rev/chi_square_lpdf_test.cpp
index 08d95c7f77a..9ef7ff3ffc8 100644
--- a/test/unit/math/opencl/rev/chi_square_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/chi_square_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsChiSquare_error_checking) {
+TEST_F(OpenCLRevTests, probdistChiSquare_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -48,7 +48,7 @@ auto chi_square_lpdf_functor_propto = [](const auto& y, const auto& nu) {
   return stan::math::chi_square_lpdf<true>(y, nu);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsChiSquare_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistChiSquare_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -65,7 +65,7 @@ TEST_F(OpenCLRevTests, probdistributionsChiSquare_opencl_matches_cpu_small) {
                                                 y, nu.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsChiSquare_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistChiSquare_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 1.1;
@@ -78,7 +78,7 @@ TEST_F(OpenCLRevTests, probdistributionsChiSquare_opencl_broadcast_y) {
       chi_square_lpdf_functor_propto, y_scal, nu);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsChiSquare_opencl_broadcast_nu) {
+TEST_F(OpenCLRevTests, probdistChiSquare_opencl_broadcast_nu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -91,7 +91,7 @@ TEST_F(OpenCLRevTests, probdistributionsChiSquare_opencl_broadcast_nu) {
       chi_square_lpdf_functor_propto, y, nu_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsChiSquare_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistChiSquare_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/dirichlet_lpdf_test.cpp b/test/unit/math/opencl/rev/dirichlet_lpdf_test.cpp
index 7153df8f15d..3d808f2ac46 100644
--- a/test/unit/math/opencl/rev/dirichlet_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/dirichlet_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsDirichlet_error_checking) {
+TEST_F(OpenCLRevTests, probdistDirichlet_error_checking) {
   int N = 3;
   int M = 2;
 
@@ -74,7 +74,7 @@ auto dirichlet_lpdf_functor_propto = [](const auto& theta, const auto& alpha) {
   return stan::math::dirichlet_lpdf<true>(theta, alpha);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsDirichlet_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistDirichlet_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd theta1(N);
@@ -130,7 +130,7 @@ TEST_F(OpenCLRevTests, probdistributionsDirichlet_opencl_matches_cpu_small) {
                                                 theta4, alpha4);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsDirichlet_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistDirichlet_opencl_matches_cpu_big) {
   int N = 153;
   int M = 11;
   Eigen::VectorXd theta1;
diff --git a/test/unit/math/opencl/rev/double_exponential_cdf_test.cpp b/test/unit/math/opencl/rev/double_exponential_cdf_test.cpp
index 489ab68bc6b..79222af4eb6 100644
--- a/test/unit/math/opencl/rev/double_exponential_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/double_exponential_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsDoubleExponentialCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistDoubleExponentialCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -62,7 +62,7 @@ auto double_exponential_cdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialCdf_opencl_matches_cpu_small) {
+       probdistDoubleExponentialCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -81,7 +81,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialCdf_opencl_broadcast_y) {
+       probdistDoubleExponentialCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -97,7 +97,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialCdf_opencl_broadcast_mu) {
+       probdistDoubleExponentialCdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -113,7 +113,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialCdf_opencl_broadcast_sigma) {
+       probdistDoubleExponentialCdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -129,7 +129,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialCdf_opencl_matches_cpu_big) {
+       probdistDoubleExponentialCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/double_exponential_lccdf_test.cpp b/test/unit/math/opencl/rev/double_exponential_lccdf_test.cpp
index 2e00ab2f6fc..e4f38cf83e8 100644
--- a/test/unit/math/opencl/rev/double_exponential_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/double_exponential_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsDoubleExponentialLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistDoubleExponentialLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -65,7 +65,7 @@ auto double_exponential_lccdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialLccdf_opencl_matches_cpu_small) {
+       probdistDoubleExponentialLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -84,7 +84,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialLccdf_opencl_broadcast_y) {
+       probdistDoubleExponentialLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -100,7 +100,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialLccdf_opencl_broadcast_mu) {
+       probdistDoubleExponentialLccdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -116,7 +116,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialLccdf_opencl_broadcast_sigma) {
+       probdistDoubleExponentialLccdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -132,7 +132,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialLccdf_opencl_matches_cpu_big) {
+       probdistDoubleExponentialLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/double_exponential_lcdf_test.cpp b/test/unit/math/opencl/rev/double_exponential_lcdf_test.cpp
index 26fb698b19d..1772a623990 100644
--- a/test/unit/math/opencl/rev/double_exponential_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/double_exponential_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsDoubleExponentialLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistDoubleExponentialLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -62,7 +62,7 @@ auto double_exponential_lcdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialLcdf_opencl_matches_cpu_small) {
+       probdistDoubleExponentialLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -81,7 +81,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialLcdf_opencl_broadcast_y) {
+       probdistDoubleExponentialLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -97,7 +97,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialLcdf_opencl_broadcast_mu) {
+       probdistDoubleExponentialLcdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -113,7 +113,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialLcdf_opencl_broadcast_sigma) {
+       probdistDoubleExponentialLcdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -129,7 +129,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponentialLcdf_opencl_matches_cpu_big) {
+       probdistDoubleExponentialLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/double_exponential_lpdf_test.cpp b/test/unit/math/opencl/rev/double_exponential_lpdf_test.cpp
index c9ac65fe73c..47249766313 100644
--- a/test/unit/math/opencl/rev/double_exponential_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/double_exponential_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsDoubleExponential_error_checking) {
+TEST_F(OpenCLRevTests, probdistDoubleExponential_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -64,7 +64,7 @@ auto double_exponential_lpdf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponential_opencl_matches_cpu_small) {
+       probdistDoubleExponential_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -86,7 +86,7 @@ TEST_F(OpenCLRevTests,
       mu.transpose().eval(), sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsDoubleExponential_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistDoubleExponential_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = -2.3;
@@ -106,7 +106,7 @@ TEST_F(OpenCLRevTests, probdistributionsDoubleExponential_opencl_broadcast_y) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsDoubleExponential_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistDoubleExponential_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -126,7 +126,7 @@ TEST_F(OpenCLRevTests, probdistributionsDoubleExponential_opencl_broadcast_mu) {
       sigma.transpose().eval());
 }
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponential_opencl_broadcast_sigma) {
+       probdistDoubleExponential_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -147,7 +147,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExponential_opencl_matches_cpu_big) {
+       probdistDoubleExponential_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
@@ -169,7 +169,7 @@ TEST_F(OpenCLRevTests,
       mu.transpose().eval(), sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsDoubleExponential_opencl_y_mu_scalar) {
+TEST_F(OpenCLRevTests, probdistDoubleExponential_opencl_y_mu_scalar) {
   int N = 3;
 
   double y = -0.3;
diff --git a/test/unit/math/opencl/rev/exp_mod_normal_cdf2_test.cpp b/test/unit/math/opencl/rev/exp_mod_normal_cdf2_test.cpp
index 48507745701..8a8261ff55c 100644
--- a/test/unit/math/opencl/rev/exp_mod_normal_cdf2_test.cpp
+++ b/test/unit/math/opencl/rev/exp_mod_normal_cdf2_test.cpp
@@ -13,7 +13,7 @@ auto exp_mod_normal_cdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalCdf_opencl_broadcast_sigma) {
+       probdistDoubleExpModNormalCdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -32,7 +32,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalCdf_opencl_broadcast_lambda) {
+       probdistDoubleExpModNormalCdf_opencl_broadcast_lambda) {
   int N = 3;
 
   Eigen::VectorXd y(N);
diff --git a/test/unit/math/opencl/rev/exp_mod_normal_cdf_test.cpp b/test/unit/math/opencl/rev/exp_mod_normal_cdf_test.cpp
index 2b175948c81..6d1c8dd65ab 100644
--- a/test/unit/math/opencl/rev/exp_mod_normal_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/exp_mod_normal_cdf_test.cpp
@@ -7,7 +7,7 @@
 
 namespace exp_mod_normal_cdf_test {
 
-TEST_F(OpenCLRevTests, probdistributionsDoubleExpModNormalCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistDoubleExpModNormalCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -87,7 +87,7 @@ auto exp_mod_normal_cdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalCdf_opencl_matches_cpu_small) {
+       probdistDoubleExpModNormalCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests,
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsDoubleExpModNormalCdf_opencl_matches_cpu_small_y_neg_inf) {
+    probdistDoubleExpModNormalCdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
   int M = 2;
 
@@ -130,7 +130,7 @@ TEST_F(
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalCdf_opencl_broadcast_y) {
+       probdistDoubleExpModNormalCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -149,7 +149,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalCdf_opencl_broadcast_mu) {
+       probdistDoubleExpModNormalCdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -168,7 +168,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalCdf_opencl_matches_cpu_big) {
+       probdistDoubleExpModNormalCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/exp_mod_normal_lccdf2_test.cpp b/test/unit/math/opencl/rev/exp_mod_normal_lccdf2_test.cpp
index af073bc6c6a..e9b2073b8c6 100644
--- a/test/unit/math/opencl/rev/exp_mod_normal_lccdf2_test.cpp
+++ b/test/unit/math/opencl/rev/exp_mod_normal_lccdf2_test.cpp
@@ -13,7 +13,7 @@ auto exp_mod_normal_lccdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLccdf_opencl_broadcast_mu) {
+       probdistDoubleExpModNormalLccdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
diff --git a/test/unit/math/opencl/rev/exp_mod_normal_lccdf3_test.cpp b/test/unit/math/opencl/rev/exp_mod_normal_lccdf3_test.cpp
index 5eb7ca16be1..cd9b5cdfb24 100644
--- a/test/unit/math/opencl/rev/exp_mod_normal_lccdf3_test.cpp
+++ b/test/unit/math/opencl/rev/exp_mod_normal_lccdf3_test.cpp
@@ -13,7 +13,7 @@ auto exp_mod_normal_lccdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLccdf_opencl_broadcast_sigma) {
+       probdistDoubleExpModNormalLccdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
diff --git a/test/unit/math/opencl/rev/exp_mod_normal_lccdf4_test.cpp b/test/unit/math/opencl/rev/exp_mod_normal_lccdf4_test.cpp
index f9e8a2b6642..cdabb15fefa 100644
--- a/test/unit/math/opencl/rev/exp_mod_normal_lccdf4_test.cpp
+++ b/test/unit/math/opencl/rev/exp_mod_normal_lccdf4_test.cpp
@@ -13,7 +13,7 @@ auto exp_mod_normal_lccdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLccdf_opencl_broadcast_lambda) {
+       probdistDoubleExpModNormalLccdf_opencl_broadcast_lambda) {
   int N = 3;
 
   Eigen::VectorXd y(N);
diff --git a/test/unit/math/opencl/rev/exp_mod_normal_lccdf_test.cpp b/test/unit/math/opencl/rev/exp_mod_normal_lccdf_test.cpp
index 198620b37b3..50593554da3 100644
--- a/test/unit/math/opencl/rev/exp_mod_normal_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/exp_mod_normal_lccdf_test.cpp
@@ -8,7 +8,7 @@
 namespace exp_mod_normal_lccdf_test {
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLccdf_error_checking) {
+       probdistDoubleExpModNormalLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -88,7 +88,7 @@ auto exp_mod_normal_lccdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLccdf_opencl_matches_cpu_small) {
+       probdistDoubleExpModNormalLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -110,7 +110,7 @@ TEST_F(OpenCLRevTests,
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsDoubleExpModNormalLccdf_opencl_matches_cpu_small_y_pos_inf) {
+    probdistDoubleExpModNormalLccdf_opencl_matches_cpu_small_y_pos_inf) {
   int N = 3;
   int M = 2;
 
@@ -132,7 +132,7 @@ TEST_F(
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsDoubleExpModNormalLccdf_opencl_matches_cpu_small_y_neg_inf) {
+    probdistDoubleExpModNormalLccdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
   int M = 2;
 
@@ -153,7 +153,7 @@ TEST_F(
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLccdf_opencl_broadcast_y) {
+       probdistDoubleExpModNormalLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -172,7 +172,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLccdf_opencl_matches_cpu_big) {
+       probdistDoubleExpModNormalLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/exp_mod_normal_lcdf2_test.cpp b/test/unit/math/opencl/rev/exp_mod_normal_lcdf2_test.cpp
index e0afaff0b6f..5d8132e42e6 100644
--- a/test/unit/math/opencl/rev/exp_mod_normal_lcdf2_test.cpp
+++ b/test/unit/math/opencl/rev/exp_mod_normal_lcdf2_test.cpp
@@ -13,7 +13,7 @@ auto exp_mod_normal_lcdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLcdf_opencl_broadcast_mu) {
+       probdistDoubleExpModNormalLcdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
diff --git a/test/unit/math/opencl/rev/exp_mod_normal_lcdf3_test.cpp b/test/unit/math/opencl/rev/exp_mod_normal_lcdf3_test.cpp
index 414a53690c5..8e06faec661 100644
--- a/test/unit/math/opencl/rev/exp_mod_normal_lcdf3_test.cpp
+++ b/test/unit/math/opencl/rev/exp_mod_normal_lcdf3_test.cpp
@@ -13,7 +13,7 @@ auto exp_mod_normal_lcdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLcdf_opencl_broadcast_sigma) {
+       probdistDoubleExpModNormalLcdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
diff --git a/test/unit/math/opencl/rev/exp_mod_normal_lcdf4_test.cpp b/test/unit/math/opencl/rev/exp_mod_normal_lcdf4_test.cpp
index 483de22d68c..0f1722ea6c6 100644
--- a/test/unit/math/opencl/rev/exp_mod_normal_lcdf4_test.cpp
+++ b/test/unit/math/opencl/rev/exp_mod_normal_lcdf4_test.cpp
@@ -13,7 +13,7 @@ auto exp_mod_normal_lcdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLcdf_opencl_broadcast_lambda) {
+       probdistDoubleExpModNormalLcdf_opencl_broadcast_lambda) {
   int N = 3;
 
   Eigen::VectorXd y(N);
diff --git a/test/unit/math/opencl/rev/exp_mod_normal_lcdf_test.cpp b/test/unit/math/opencl/rev/exp_mod_normal_lcdf_test.cpp
index 3506e083b38..f84e3c63a8b 100644
--- a/test/unit/math/opencl/rev/exp_mod_normal_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/exp_mod_normal_lcdf_test.cpp
@@ -7,7 +7,7 @@
 
 namespace exp_mod_normal_lcdf_test {
 
-TEST_F(OpenCLRevTests, probdistributionsDoubleExpModNormalLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistDoubleExpModNormalLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -87,7 +87,7 @@ auto exp_mod_normal_lcdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLcdf_opencl_matches_cpu_small) {
+       probdistDoubleExpModNormalLcdf_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -108,7 +108,7 @@ TEST_F(OpenCLRevTests,
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsDoubleExpModNormalLcdf_opencl_matches_cpu_small_y_pos_inf) {
+    probdistDoubleExpModNormalLcdf_opencl_matches_cpu_small_y_pos_inf) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -129,7 +129,7 @@ TEST_F(
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsDoubleExpModNormalLcdf_opencl_matches_cpu_small_y_neg_inf) {
+    probdistDoubleExpModNormalLcdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -149,7 +149,7 @@ TEST_F(
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLcdf_opencl_broadcast_y) {
+       probdistDoubleExpModNormalLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -168,7 +168,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsDoubleExpModNormalLcdf_opencl_matches_cpu_big) {
+       probdistDoubleExpModNormalLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/exp_mod_normal_lpdf_test.cpp b/test/unit/math/opencl/rev/exp_mod_normal_lpdf_test.cpp
index af096325a55..eb7b1bda16a 100644
--- a/test/unit/math/opencl/rev/exp_mod_normal_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/exp_mod_normal_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsExpModNormal_error_checking) {
+TEST_F(OpenCLRevTests, probdistExpModNormal_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -103,7 +103,7 @@ auto exp_mod_normal_lpdf_functor_propto
         return stan::math::exp_mod_normal_lpdf<true>(y, mu, sigma, lambda);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsExpModNormal_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistExpModNormal_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -128,7 +128,7 @@ TEST_F(OpenCLRevTests, probdistributionsExpModNormal_opencl_matches_cpu_small) {
       lambda.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExpModNormal_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistExpModNormal_opencl_broadcast_y) {
   int N = 3;
 
   double y = 0.3;
@@ -151,7 +151,7 @@ TEST_F(OpenCLRevTests, probdistributionsExpModNormal_opencl_broadcast_y) {
       lambda.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExpModNormal_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistExpModNormal_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -174,7 +174,7 @@ TEST_F(OpenCLRevTests, probdistributionsExpModNormal_opencl_broadcast_mu) {
       lambda.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExpModNormal_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistExpModNormal_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -197,7 +197,7 @@ TEST_F(OpenCLRevTests, probdistributionsExpModNormal_opencl_broadcast_sigma) {
       mu.transpose().eval(), sigma, lambda);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExpModNormal_opencl_broadcast_lambda) {
+TEST_F(OpenCLRevTests, probdistExpModNormal_opencl_broadcast_lambda) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -220,7 +220,7 @@ TEST_F(OpenCLRevTests, probdistributionsExpModNormal_opencl_broadcast_lambda) {
       sigma.transpose().eval(), lambda);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExpModNormal_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistExpModNormal_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/exponential_cdf_test.cpp b/test/unit/math/opencl/rev/exponential_cdf_test.cpp
index 898899fe6a5..51dffec09f1 100644
--- a/test/unit/math/opencl/rev/exponential_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/exponential_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsExponentialCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistExponentialCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -47,7 +47,7 @@ auto exponential_cdf_functor = [](const auto& y, const auto& beta) {
 };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsExponentialCdf_opencl_matches_cpu_small) {
+       probdistExponentialCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -62,7 +62,7 @@ TEST_F(OpenCLRevTests,
       exponential_cdf_functor, y.transpose().eval(), beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExponentialCdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistExponentialCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -73,7 +73,7 @@ TEST_F(OpenCLRevTests, probdistributionsExponentialCdf_opencl_broadcast_y) {
       exponential_cdf_functor, y_scal, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExponentialCdf_opencl_broadcast_beta) {
+TEST_F(OpenCLRevTests, probdistExponentialCdf_opencl_broadcast_beta) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -84,7 +84,7 @@ TEST_F(OpenCLRevTests, probdistributionsExponentialCdf_opencl_broadcast_beta) {
       exponential_cdf_functor, y, beta_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExponentialCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistExponentialCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/exponential_lccdf_test.cpp b/test/unit/math/opencl/rev/exponential_lccdf_test.cpp
index 4a182f724b5..c6e824084d4 100644
--- a/test/unit/math/opencl/rev/exponential_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/exponential_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsExponentialLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistExponentialLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -47,7 +47,7 @@ auto exponential_lccdf_functor = [](const auto& y, const auto& beta) {
 };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsExponentialLccdf_opencl_matches_cpu_small) {
+       probdistExponentialLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -62,7 +62,7 @@ TEST_F(OpenCLRevTests,
       exponential_lccdf_functor, y.transpose().eval(), beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExponentialLccdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistExponentialLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -74,7 +74,7 @@ TEST_F(OpenCLRevTests, probdistributionsExponentialLccdf_opencl_broadcast_y) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsExponentialLccdf_opencl_broadcast_beta) {
+       probdistExponentialLccdf_opencl_broadcast_beta) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -86,7 +86,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsExponentialLccdf_opencl_matches_cpu_big) {
+       probdistExponentialLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/exponential_lcdf_test.cpp b/test/unit/math/opencl/rev/exponential_lcdf_test.cpp
index fb8e8155759..3aeb0f32148 100644
--- a/test/unit/math/opencl/rev/exponential_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/exponential_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsExponentialLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistExponentialLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -47,7 +47,7 @@ auto exponential_lcdf_functor = [](const auto& y, const auto& beta) {
 };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsExponentialLcdf_opencl_matches_cpu_small) {
+       probdistExponentialLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -62,7 +62,7 @@ TEST_F(OpenCLRevTests,
       exponential_lcdf_functor, y.transpose().eval(), beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExponentialLcdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistExponentialLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -73,7 +73,7 @@ TEST_F(OpenCLRevTests, probdistributionsExponentialLcdf_opencl_broadcast_y) {
       exponential_lcdf_functor, y_scal, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExponentialLcdf_opencl_broadcast_beta) {
+TEST_F(OpenCLRevTests, probdistExponentialLcdf_opencl_broadcast_beta) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -85,7 +85,7 @@ TEST_F(OpenCLRevTests, probdistributionsExponentialLcdf_opencl_broadcast_beta) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsExponentialLcdf_opencl_matches_cpu_big) {
+       probdistExponentialLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/exponential_lpdf_test.cpp b/test/unit/math/opencl/rev/exponential_lpdf_test.cpp
index 3d4927d0f31..c9b74796ece 100644
--- a/test/unit/math/opencl/rev/exponential_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/exponential_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsExponential_error_checking) {
+TEST_F(OpenCLRevTests, probdistExponential_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -55,7 +55,7 @@ auto exponential_lpdf_functor_propto = [](const auto& y, const auto& beta) {
   return stan::math::exponential_lpdf<true>(y, beta);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsExponential_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistExponential_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -74,7 +74,7 @@ TEST_F(OpenCLRevTests, probdistributionsExponential_opencl_matches_cpu_small) {
                                                 y, beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExponential_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistExponential_opencl_broadcast_y) {
   int N = 3;
 
   double y = 0.5;
@@ -87,7 +87,7 @@ TEST_F(OpenCLRevTests, probdistributionsExponential_opencl_broadcast_y) {
       exponential_lpdf_functor_propto, y, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExponential_opencl_broadcast_beta) {
+TEST_F(OpenCLRevTests, probdistExponential_opencl_broadcast_beta) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -100,7 +100,7 @@ TEST_F(OpenCLRevTests, probdistributionsExponential_opencl_broadcast_beta) {
       exponential_lpdf_functor_propto, y, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsExponential_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistExponential_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/frechet_cdf_test.cpp b/test/unit/math/opencl/rev/frechet_cdf_test.cpp
index 108009f0435..0f363f788fc 100644
--- a/test/unit/math/opencl/rev/frechet_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/frechet_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistFrechetCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto frechet_cdf_functor
         return stan::math::frechet_cdf(y, alpha, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetCdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistFrechetCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -79,7 +79,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechetCdf_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetCdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistFrechetCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -94,7 +94,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechetCdf_opencl_broadcast_y) {
       frechet_cdf_functor, y_scal, alpha.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetCdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistFrechetCdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechetCdf_opencl_broadcast_alpha) {
       frechet_cdf_functor, y.transpose().eval(), alpha_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetCdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistFrechetCdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -124,7 +124,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechetCdf_opencl_broadcast_sigma) {
       frechet_cdf_functor, y.transpose().eval(), alpha, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistFrechetCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/frechet_lccdf_test.cpp b/test/unit/math/opencl/rev/frechet_lccdf_test.cpp
index 7fc9852ab67..d2f42bdf738 100644
--- a/test/unit/math/opencl/rev/frechet_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/frechet_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistFrechetLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto frechet_lccdf_functor
         return stan::math::frechet_lccdf(y, alpha, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetLccdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistFrechetLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -79,7 +79,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechetLccdf_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetLccdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistFrechetLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -94,7 +94,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechetLccdf_opencl_broadcast_y) {
       frechet_lccdf_functor, y_scal, alpha.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetLccdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistFrechetLccdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechetLccdf_opencl_broadcast_alpha) {
       frechet_lccdf_functor, y.transpose().eval(), alpha_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetLccdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistFrechetLccdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -124,7 +124,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechetLccdf_opencl_broadcast_sigma) {
       frechet_lccdf_functor, y.transpose().eval(), alpha, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetLccdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistFrechetLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/frechet_lcdf_test.cpp b/test/unit/math/opencl/rev/frechet_lcdf_test.cpp
index 0aa80deacf5..7ed4cab8dd6 100644
--- a/test/unit/math/opencl/rev/frechet_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/frechet_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistFrechetLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto frechet_lcdf_functor
         return stan::math::frechet_lcdf(y, alpha, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetLcdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistFrechetLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -79,7 +79,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechetLcdf_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetLcdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistFrechetLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -94,7 +94,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechetLcdf_opencl_broadcast_y) {
       frechet_lcdf_functor, y_scal, alpha.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetLcdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistFrechetLcdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechetLcdf_opencl_broadcast_alpha) {
       frechet_lcdf_functor, y.transpose().eval(), alpha_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetLcdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistFrechetLcdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -124,7 +124,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechetLcdf_opencl_broadcast_sigma) {
       frechet_lcdf_functor, y.transpose().eval(), alpha, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechetLcdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistFrechetLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/frechet_lpdf_test.cpp b/test/unit/math/opencl/rev/frechet_lpdf_test.cpp
index ca067704c51..2f31ac34116 100644
--- a/test/unit/math/opencl/rev/frechet_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/frechet_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsFrechet_error_checking) {
+TEST_F(OpenCLRevTests, probdistFrechet_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -83,7 +83,7 @@ auto frechet_lpdf_functor_propto
         return stan::math::frechet_lpdf<true>(y, alpha, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsFrechet_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistFrechet_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -105,7 +105,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechet_opencl_matches_cpu_small) {
       alpha.transpose().eval(), sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechet_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistFrechet_opencl_broadcast_y) {
   int N = 3;
 
   double y = 0.3;
@@ -124,7 +124,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechet_opencl_broadcast_y) {
       frechet_lpdf_functor_propto, y, alpha, sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechet_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistFrechet_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -143,7 +143,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechet_opencl_broadcast_alpha) {
       frechet_lpdf_functor_propto, y, alpha, sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechet_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistFrechet_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -164,7 +164,7 @@ TEST_F(OpenCLRevTests, probdistributionsFrechet_opencl_broadcast_sigma) {
       frechet_lpdf_functor_propto, y, alpha.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsFrechet_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistFrechet_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/gamma_lpdf_test.cpp b/test/unit/math/opencl/rev/gamma_lpdf_test.cpp
index 19021615ef5..dbbe5758793 100644
--- a/test/unit/math/opencl/rev/gamma_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/gamma_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsGamma_error_checking) {
+TEST_F(OpenCLRevTests, probdistGamma_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -77,7 +77,7 @@ auto gamma_lpdf_functor_propto
         return stan::math::gamma_lpdf<true>(y, alpha, beta);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsGamma_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistGamma_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -99,7 +99,7 @@ TEST_F(OpenCLRevTests, probdistributionsGamma_opencl_matches_cpu_small) {
       beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGamma_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistGamma_opencl_broadcast_y) {
   int N = 3;
 
   double y = 0.3;
@@ -118,7 +118,7 @@ TEST_F(OpenCLRevTests, probdistributionsGamma_opencl_broadcast_y) {
       gamma_lpdf_functor_propto, y, alpha, beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGamma_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistGamma_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -137,7 +137,7 @@ TEST_F(OpenCLRevTests, probdistributionsGamma_opencl_broadcast_alpha) {
       gamma_lpdf_functor_propto, y, alpha, beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGamma_opencl_broadcast_beta) {
+TEST_F(OpenCLRevTests, probdistGamma_opencl_broadcast_beta) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -156,7 +156,7 @@ TEST_F(OpenCLRevTests, probdistributionsGamma_opencl_broadcast_beta) {
       gamma_lpdf_functor_propto, y, alpha.transpose().eval(), beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGamma_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistGamma_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/gumbel_cdf_test.cpp b/test/unit/math/opencl/rev/gumbel_cdf_test.cpp
index 995ae95c7a4..3f4099793cb 100644
--- a/test/unit/math/opencl/rev/gumbel_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/gumbel_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistGumbelCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -60,7 +60,7 @@ auto gumbel_cdf_functor = [](const auto& y, const auto& mu, const auto& sigma) {
   return stan::math::gumbel_cdf(y, mu, sigma);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelCdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistGumbelCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -78,7 +78,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbelCdf_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelCdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistGumbelCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -93,7 +93,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbelCdf_opencl_broadcast_y) {
       gumbel_cdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelCdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistGumbelCdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -108,7 +108,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbelCdf_opencl_broadcast_mu) {
       gumbel_cdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelCdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistGumbelCdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -123,7 +123,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbelCdf_opencl_broadcast_sigma) {
       gumbel_cdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistGumbelCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/gumbel_lccdf_test.cpp b/test/unit/math/opencl/rev/gumbel_lccdf_test.cpp
index 4830f11d6ea..498027d0720 100644
--- a/test/unit/math/opencl/rev/gumbel_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/gumbel_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistGumbelLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto gumbel_lccdf_functor
         return stan::math::gumbel_lccdf(y, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelLccdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistGumbelLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -79,7 +79,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbelLccdf_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelLccdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistGumbelLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -94,7 +94,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbelLccdf_opencl_broadcast_y) {
       gumbel_lccdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelLccdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistGumbelLccdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbelLccdf_opencl_broadcast_mu) {
       gumbel_lccdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelLccdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistGumbelLccdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -124,7 +124,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbelLccdf_opencl_broadcast_sigma) {
       gumbel_lccdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelLccdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistGumbelLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/gumbel_lcdf_test.cpp b/test/unit/math/opencl/rev/gumbel_lcdf_test.cpp
index 371327d07cc..218a5922af4 100644
--- a/test/unit/math/opencl/rev/gumbel_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/gumbel_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistGumbelLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto gumbel_lcdf_functor
         return stan::math::gumbel_lcdf(y, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelLcdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistGumbelLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -79,7 +79,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbelLcdf_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelLcdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistGumbelLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -94,7 +94,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbelLcdf_opencl_broadcast_y) {
       gumbel_lcdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelLcdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistGumbelLcdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbelLcdf_opencl_broadcast_mu) {
       gumbel_lcdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelLcdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistGumbelLcdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -124,7 +124,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbelLcdf_opencl_broadcast_sigma) {
       gumbel_lcdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbelLcdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistGumbelLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/gumbel_lpdf_test.cpp b/test/unit/math/opencl/rev/gumbel_lpdf_test.cpp
index 03e990cc767..acf058a45ff 100644
--- a/test/unit/math/opencl/rev/gumbel_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/gumbel_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsGumbel_error_checking) {
+TEST_F(OpenCLRevTests, probdistGumbel_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -76,7 +76,7 @@ auto gumbel_lpdf_functor_propto
         return stan::math::gumbel_lpdf<true>(y, mu, beta);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsGumbel_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistGumbel_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -98,7 +98,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbel_opencl_matches_cpu_small) {
       beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbel_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistGumbel_opencl_broadcast_y) {
   int N = 3;
 
   double y = 0.3;
@@ -117,7 +117,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbel_opencl_broadcast_y) {
       gumbel_lpdf_functor_propto, y, mu, beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbel_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistGumbel_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -136,7 +136,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbel_opencl_broadcast_mu) {
       gumbel_lpdf_functor_propto, y, mu, beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbel_opencl_broadcast_beta) {
+TEST_F(OpenCLRevTests, probdistGumbel_opencl_broadcast_beta) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -155,7 +155,7 @@ TEST_F(OpenCLRevTests, probdistributionsGumbel_opencl_broadcast_beta) {
       gumbel_lpdf_functor_propto, y, mu.transpose().eval(), beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsGumbel_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistGumbel_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/inv_chi_square_lpdf_test.cpp b/test/unit/math/opencl/rev/inv_chi_square_lpdf_test.cpp
index 6c9b127c4ed..0e4f8f027b0 100644
--- a/test/unit/math/opencl/rev/inv_chi_square_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/inv_chi_square_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsInvChiSquare_error_checking) {
+TEST_F(OpenCLRevTests, probdistInvChiSquare_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -54,7 +54,7 @@ auto inv_chi_square_lpdf_functor_propto = [](const auto& y, const auto& nu) {
   return stan::math::inv_chi_square_lpdf<true>(y, nu);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsInvChiSquare_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistInvChiSquare_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -73,7 +73,7 @@ TEST_F(OpenCLRevTests, probdistributionsInvChiSquare_opencl_matches_cpu_small) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsInvChiSquare_opencl_matches_cpu_small_y_zero) {
+       probdistInvChiSquare_opencl_matches_cpu_small_y_zero) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -87,7 +87,7 @@ TEST_F(OpenCLRevTests,
       inv_chi_square_lpdf_functor_propto, y, nu);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsInvChiSquare_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistInvChiSquare_opencl_broadcast_y) {
   int N = 3;
 
   double y = 0.3;
@@ -100,7 +100,7 @@ TEST_F(OpenCLRevTests, probdistributionsInvChiSquare_opencl_broadcast_y) {
       inv_chi_square_lpdf_functor_propto, y, nu);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsInvChiSquare_opencl_broadcast_nu) {
+TEST_F(OpenCLRevTests, probdistInvChiSquare_opencl_broadcast_nu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -113,7 +113,7 @@ TEST_F(OpenCLRevTests, probdistributionsInvChiSquare_opencl_broadcast_nu) {
       inv_chi_square_lpdf_functor_propto, y, nu);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsInvChiSquare_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistInvChiSquare_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/inv_gamma_lpdf_test.cpp b/test/unit/math/opencl/rev/inv_gamma_lpdf_test.cpp
index 068d62cd5f8..8e50ae4d5d9 100644
--- a/test/unit/math/opencl/rev/inv_gamma_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/inv_gamma_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsInvGamma_error_checking) {
+TEST_F(OpenCLRevTests, probdistInvGamma_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -77,7 +77,7 @@ auto inv_gamma_lpdf_functor_propto
         return stan::math::inv_gamma_lpdf<true>(y, alpha, beta);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsInvGamma_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistInvGamma_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -101,7 +101,7 @@ TEST_F(OpenCLRevTests, probdistributionsInvGamma_opencl_matches_cpu_small) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsInvGamma_opencl_matches_cpu_small_zero_y) {
+       probdistInvGamma_opencl_matches_cpu_small_zero_y) {
   int N = 3;
   int M = 2;
 
@@ -118,7 +118,7 @@ TEST_F(OpenCLRevTests,
                                                 y, alpha, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsInvGamma_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistInvGamma_opencl_broadcast_y) {
   int N = 3;
 
   double y = 0.3;
@@ -137,7 +137,7 @@ TEST_F(OpenCLRevTests, probdistributionsInvGamma_opencl_broadcast_y) {
       inv_gamma_lpdf_functor_propto, y, alpha, beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsInvGamma_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistInvGamma_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -156,7 +156,7 @@ TEST_F(OpenCLRevTests, probdistributionsInvGamma_opencl_broadcast_alpha) {
       inv_gamma_lpdf_functor_propto, y, alpha, beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsInvGamma_opencl_broadcast_beta) {
+TEST_F(OpenCLRevTests, probdistInvGamma_opencl_broadcast_beta) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -175,7 +175,7 @@ TEST_F(OpenCLRevTests, probdistributionsInvGamma_opencl_broadcast_beta) {
       inv_gamma_lpdf_functor_propto, y, alpha.transpose().eval(), beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsInvGamma_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistInvGamma_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/logistic_cdf_test.cpp b/test/unit/math/opencl/rev/logistic_cdf_test.cpp
index a18cd73ae0f..4b4557b49bd 100644
--- a/test/unit/math/opencl/rev/logistic_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/logistic_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistLogisticCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto logistic_cdf_functor
         return stan::math::logistic_cdf(y, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticCdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistLogisticCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -80,7 +80,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogisticCdf_opencl_matches_cpu_small) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsLogisticCdf_opencl_matches_cpu_small_y_neg_inf) {
+       probdistLogisticCdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
   int M = 2;
 
@@ -98,7 +98,7 @@ TEST_F(OpenCLRevTests,
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticCdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistLogisticCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -113,7 +113,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogisticCdf_opencl_broadcast_y) {
       logistic_cdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticCdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistLogisticCdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -128,7 +128,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogisticCdf_opencl_broadcast_mu) {
       logistic_cdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticCdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistLogisticCdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -143,7 +143,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogisticCdf_opencl_broadcast_sigma) {
       logistic_cdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistLogisticCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/logistic_lccdf_test.cpp b/test/unit/math/opencl/rev/logistic_lccdf_test.cpp
index 69a07ca8482..3fb9e76800d 100644
--- a/test/unit/math/opencl/rev/logistic_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/logistic_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistLogisticLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -62,7 +62,7 @@ auto logistic_lccdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsLogisticLccdf_opencl_matches_cpu_small) {
+       probdistLogisticLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -81,7 +81,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsLogisticLccdf_opencl_matches_cpu_small_y_neg_inf) {
+       probdistLogisticLccdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
   int M = 2;
 
@@ -99,7 +99,7 @@ TEST_F(OpenCLRevTests,
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticLccdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistLogisticLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -114,7 +114,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogisticLccdf_opencl_broadcast_y) {
       logistic_lccdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticLccdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistLogisticLccdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -129,7 +129,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogisticLccdf_opencl_broadcast_mu) {
       logistic_lccdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticLccdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistLogisticLccdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -144,7 +144,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogisticLccdf_opencl_broadcast_sigma) {
       logistic_lccdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticLccdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistLogisticLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/logistic_lcdf_test.cpp b/test/unit/math/opencl/rev/logistic_lcdf_test.cpp
index 4abd7b3c620..af9d8d3d3ab 100644
--- a/test/unit/math/opencl/rev/logistic_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/logistic_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistLogisticLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto logistic_lcdf_functor
         return stan::math::logistic_lcdf(y, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticLcdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistLogisticLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -80,7 +80,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogisticLcdf_opencl_matches_cpu_small) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsLogisticLcdf_opencl_matches_cpu_small_y_neg_inf) {
+       probdistLogisticLcdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
   int M = 2;
 
@@ -98,7 +98,7 @@ TEST_F(OpenCLRevTests,
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticLcdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistLogisticLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -113,7 +113,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogisticLcdf_opencl_broadcast_y) {
       logistic_lcdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticLcdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistLogisticLcdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -128,7 +128,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogisticLcdf_opencl_broadcast_mu) {
       logistic_lcdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticLcdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistLogisticLcdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -143,7 +143,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogisticLcdf_opencl_broadcast_sigma) {
       logistic_lcdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogisticLcdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistLogisticLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/logistic_lpdf_test.cpp b/test/unit/math/opencl/rev/logistic_lpdf_test.cpp
index 87bf8b2b747..986204abb3e 100644
--- a/test/unit/math/opencl/rev/logistic_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/logistic_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsLogistic_error_checking) {
+TEST_F(OpenCLRevTests, probdistLogistic_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -77,7 +77,7 @@ auto logistic_lpdf_functor_propto
         return stan::math::logistic_lpdf<true>(y, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsLogistic_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistLogistic_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -100,7 +100,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogistic_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogistic_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistLogistic_opencl_broadcast_y) {
   int N = 3;
 
   double y = 0.3;
@@ -119,7 +119,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogistic_opencl_broadcast_y) {
       logistic_lpdf_functor_propto, y, mu, sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogistic_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistLogistic_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -138,7 +138,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogistic_opencl_broadcast_mu) {
       logistic_lpdf_functor_propto, y, mu, sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogistic_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistLogistic_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -157,7 +157,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogistic_opencl_broadcast_sigma) {
       logistic_lpdf_functor_propto, y, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogistic_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistLogistic_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
@@ -179,7 +179,7 @@ TEST_F(OpenCLRevTests, probdistributionsLogistic_opencl_matches_cpu_big) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLogistic_opencl_sigma_mu_scalar) {
+TEST_F(OpenCLRevTests, probdistLogistic_opencl_sigma_mu_scalar) {
   int N = 3;
   int M = 2;
 
diff --git a/test/unit/math/opencl/rev/lognormal_cdf_test.cpp b/test/unit/math/opencl/rev/lognormal_cdf_test.cpp
index 2384c311a56..07f746a5c6d 100644
--- a/test/unit/math/opencl/rev/lognormal_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/lognormal_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistLognormalCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto lognormal_cdf_functor
         return stan::math::lognormal_cdf(y, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalCdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistLognormalCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -80,7 +80,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormalCdf_opencl_matches_cpu_small) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsLognormalCdf_opencl_matches_cpu_small_y_zero) {
+       probdistLognormalCdf_opencl_matches_cpu_small_y_zero) {
   int N = 3;
   int M = 2;
 
@@ -98,7 +98,7 @@ TEST_F(OpenCLRevTests,
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalCdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistLognormalCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -113,7 +113,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormalCdf_opencl_broadcast_y) {
       lognormal_cdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalCdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistLognormalCdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -128,7 +128,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormalCdf_opencl_broadcast_mu) {
       lognormal_cdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalCdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistLognormalCdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -143,7 +143,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormalCdf_opencl_broadcast_sigma) {
       lognormal_cdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistLognormalCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/lognormal_lccdf_test.cpp b/test/unit/math/opencl/rev/lognormal_lccdf_test.cpp
index 73546c3dc8a..49cf71d4400 100644
--- a/test/unit/math/opencl/rev/lognormal_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/lognormal_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistLognormalLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -62,7 +62,7 @@ auto lognormal_lccdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsLognormalLccdf_opencl_matches_cpu_small) {
+       probdistLognormalLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -81,7 +81,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsLognormalLccdf_opencl_matches_cpu_small_y_zero) {
+       probdistLognormalLccdf_opencl_matches_cpu_small_y_zero) {
   int N = 3;
   int M = 2;
 
@@ -99,7 +99,7 @@ TEST_F(OpenCLRevTests,
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalLccdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistLognormalLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -114,7 +114,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormalLccdf_opencl_broadcast_y) {
       lognormal_lccdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalLccdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistLognormalLccdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -129,7 +129,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormalLccdf_opencl_broadcast_mu) {
       lognormal_lccdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalLccdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistLognormalLccdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -144,7 +144,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormalLccdf_opencl_broadcast_sigma) {
       lognormal_lccdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalLccdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistLognormalLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/lognormal_lcdf_test.cpp b/test/unit/math/opencl/rev/lognormal_lcdf_test.cpp
index 2959110931e..11c04c49906 100644
--- a/test/unit/math/opencl/rev/lognormal_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/lognormal_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistLognormalLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -62,7 +62,7 @@ auto lognormal_lcdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsLognormalLcdf_opencl_matches_cpu_small) {
+       probdistLognormalLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -81,7 +81,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsLognormalLcdf_opencl_matches_cpu_small_y_zero) {
+       probdistLognormalLcdf_opencl_matches_cpu_small_y_zero) {
   int N = 3;
   int M = 2;
 
@@ -99,7 +99,7 @@ TEST_F(OpenCLRevTests,
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalLcdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistLognormalLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -114,7 +114,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormalLcdf_opencl_broadcast_y) {
       lognormal_lcdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalLcdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistLognormalLcdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -129,7 +129,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormalLcdf_opencl_broadcast_mu) {
       lognormal_lcdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalLcdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistLognormalLcdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -144,7 +144,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormalLcdf_opencl_broadcast_sigma) {
       lognormal_lcdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormalLcdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistLognormalLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/lognormal_lpdf_test.cpp b/test/unit/math/opencl/rev/lognormal_lpdf_test.cpp
index 0c98de1d556..1218052e36c 100644
--- a/test/unit/math/opencl/rev/lognormal_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/lognormal_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsLognormal_error_checking) {
+TEST_F(OpenCLRevTests, probdistLognormal_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -83,7 +83,7 @@ auto lognormal_lpdf_functor_propto
         return stan::math::lognormal_lpdf<true>(y, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsLognormal_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistLognormal_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -106,7 +106,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormal_opencl_matches_cpu_small) {
       mu.transpose().eval(), sigma.transpose().eval());
 }
 TEST_F(OpenCLRevTests,
-       probdistributionsLognormal_opencl_matches_cpu_small_zero_y) {
+       probdistLognormal_opencl_matches_cpu_small_zero_y) {
   int N = 3;
   int M = 2;
 
@@ -123,7 +123,7 @@ TEST_F(OpenCLRevTests,
                                                 y, mu, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormal_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistLognormal_opencl_broadcast_y) {
   int N = 3;
 
   double y = 0.3;
@@ -142,7 +142,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormal_opencl_broadcast_y) {
       lognormal_lpdf_functor_propto, y, mu, sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormal_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistLognormal_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -161,7 +161,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormal_opencl_broadcast_mu) {
       lognormal_lpdf_functor_propto, y, mu, sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormal_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistLognormal_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -180,7 +180,7 @@ TEST_F(OpenCLRevTests, probdistributionsLognormal_opencl_broadcast_sigma) {
       lognormal_lpdf_functor_propto, y, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsLognormal_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistLognormal_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/multi_normal_cholesky_lpdf_test.cpp b/test/unit/math/opencl/rev/multi_normal_cholesky_lpdf_test.cpp
index acd22bf8663..685b46c4611 100644
--- a/test/unit/math/opencl/rev/multi_normal_cholesky_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/multi_normal_cholesky_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsMultiNormalCholesky_error_checking) {
+TEST_F(OpenCLRevTests, probdistMultiNormalCholesky_error_checking) {
   int N = 3;
   int M = 2;
 
@@ -89,7 +89,7 @@ auto multi_normal_cholesky_lpdf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsMultiNormalCholesky_opencl_matches_cpu_small) {
+       probdistMultiNormalCholesky_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -149,7 +149,7 @@ TEST_F(OpenCLRevTests,
 }
 
 // TEST_F(OpenCLRevTests,
-// probdistributionsMultiNormalCholesky_opencl_matches_cpu_big) {
+// probdistMultiNormalCholesky_opencl_matches_cpu_big) {
 //   int N = 73;
 //   int M = 11;
 //   Eigen::VectorXd y1;
diff --git a/test/unit/math/opencl/rev/neg_binomial_2_log_glm_lpmf_test.cpp b/test/unit/math/opencl/rev/neg_binomial_2_log_glm_lpmf_test.cpp
index 413fdfc96c7..a23cc902bb5 100644
--- a/test/unit/math/opencl/rev/neg_binomial_2_log_glm_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/neg_binomial_2_log_glm_lpmf_test.cpp
@@ -13,7 +13,7 @@ using stan::math::var;
 using stan::test::expect_near_rel;
 using std::vector;
 
-TEST_F(OpenCLRevTests, probdistributionsNegBinomial2LogGLM_error_checking) {
+TEST_F(OpenCLRevTests, probdistNegBinomial2LogGLM_error_checking) {
   int N = 3;
   int M = 2;
 
@@ -128,7 +128,7 @@ auto neg_binomial_2_log_glm_lpmf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsNegBinomial2LogGLM_opencl_matches_cpu_small_simple) {
+       probdistNegBinomial2LogGLM_opencl_matches_cpu_small_simple) {
   int N = 3;
   int M = 2;
 
@@ -146,7 +146,7 @@ TEST_F(OpenCLRevTests,
       neg_binomial_2_log_glm_lpmf_functor_propto, y, x, alpha, beta, phi);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNegBinomial2LogGLM_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistNegBinomial2LogGLM_opencl_broadcast_y) {
   int N = 3;
   int M = 2;
 
@@ -165,7 +165,7 @@ TEST_F(OpenCLRevTests, probdistributionsNegBinomial2LogGLM_opencl_broadcast_y) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsNegBinomial2LogGLM_opencl_matches_cpu_zero_instances) {
+       probdistNegBinomial2LogGLM_opencl_matches_cpu_zero_instances) {
   int N = 0;
   int M = 2;
 
@@ -183,7 +183,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsNegBinomial2LogGLM_opencl_matches_cpu_zero_attributes) {
+       probdistNegBinomial2LogGLM_opencl_matches_cpu_zero_attributes) {
   int N = 3;
   int M = 0;
 
@@ -201,7 +201,7 @@ TEST_F(OpenCLRevTests,
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsNegBinomial2LogGLM_opencl_matches_cpu_small_vector_alpha_phi) {
+    probdistNegBinomial2LogGLM_opencl_matches_cpu_small_vector_alpha_phi) {
   int N = 3;
   int M = 2;
 
@@ -222,7 +222,7 @@ TEST_F(
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsNegBinomial2LogGLM_opencl_matches_cpu_big) {
+       probdistNegBinomial2LogGLM_opencl_matches_cpu_big) {
   int N = 153;
   int M = 71;
 
diff --git a/test/unit/math/opencl/rev/neg_binomial_2_log_lpmf_test.cpp b/test/unit/math/opencl/rev/neg_binomial_2_log_lpmf_test.cpp
index 3a4d66c0d23..274cc547dc9 100644
--- a/test/unit/math/opencl/rev/neg_binomial_2_log_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/neg_binomial_2_log_lpmf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsNegBinomial2Log_error_checking) {
+TEST_F(OpenCLRevTests, probdistNegBinomial2Log_error_checking) {
   int N = 3;
 
   std::vector<int> n{1, 0, 12};
@@ -68,7 +68,7 @@ auto neg_binomial_2_log_lpmf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsNegBinomial2Log_opencl_matches_cpu_small) {
+       probdistNegBinomial2Log_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -90,7 +90,7 @@ TEST_F(OpenCLRevTests,
       phi.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNegBinomial2Log_opencl_broadcast_n) {
+TEST_F(OpenCLRevTests, probdistNegBinomial2Log_opencl_broadcast_n) {
   int N = 3;
 
   int n = 2;
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests, probdistributionsNegBinomial2Log_opencl_broadcast_n) {
       neg_binomial_2_log_lpmf_functor_propto, n, eta, phi.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNegBinomial2Log_opencl_broadcast_eta) {
+TEST_F(OpenCLRevTests, probdistNegBinomial2Log_opencl_broadcast_eta) {
   int N = 3;
 
   std::vector<int> n{1, 0, 12};
@@ -127,7 +127,7 @@ TEST_F(OpenCLRevTests, probdistributionsNegBinomial2Log_opencl_broadcast_eta) {
       neg_binomial_2_log_lpmf_functor_propto, n, eta, phi.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNegBinomial2Log_opencl_broadcast_phi) {
+TEST_F(OpenCLRevTests, probdistNegBinomial2Log_opencl_broadcast_phi) {
   int N = 3;
 
   std::vector<int> n{1, 0, 12};
@@ -146,7 +146,7 @@ TEST_F(OpenCLRevTests, probdistributionsNegBinomial2Log_opencl_broadcast_phi) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsNegBinomial2Log_opencl_matches_cpu_big) {
+       probdistNegBinomial2Log_opencl_matches_cpu_big) {
   int N = 153;
 
   std::vector<int> n(N);
@@ -171,7 +171,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsNegBinomial2Log_opencl_matches_cpu_eta_phi_scalar) {
+       probdistNegBinomial2Log_opencl_matches_cpu_eta_phi_scalar) {
   int N = 3;
   int M = 2;
 
diff --git a/test/unit/math/opencl/rev/neg_binomial_2_lpmf_test.cpp b/test/unit/math/opencl/rev/neg_binomial_2_lpmf_test.cpp
index c2ae3a58644..94e92cc6f1e 100644
--- a/test/unit/math/opencl/rev/neg_binomial_2_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/neg_binomial_2_lpmf_test.cpp
@@ -174,7 +174,7 @@ TEST_F(OpenCLRevTests, muProbDistributionsNegBinomial2_opencl_matches_cpu_big) {
       phi.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNegBinomial2_opencl_scalar_n_mu) {
+TEST_F(OpenCLRevTests, probdistNegBinomial2_opencl_scalar_n_mu) {
   int N = 3;
   int M = 2;
 
diff --git a/test/unit/math/opencl/rev/normal_cdf_test.cpp b/test/unit/math/opencl/rev/normal_cdf_test.cpp
index 5730560ad54..0510b644d05 100644
--- a/test/unit/math/opencl/rev/normal_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/normal_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsNormalCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistNormalCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -60,7 +60,7 @@ auto normal_cdf_functor = [](const auto& y, const auto& mu, const auto& sigma) {
   return stan::math::normal_cdf(y, mu, sigma);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsNormalCdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistNormalCdf_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -77,7 +77,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalCdf_opencl_matches_cpu_small) {
   //      sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalCdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistNormalCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -92,7 +92,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalCdf_opencl_broadcast_y) {
       normal_cdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalCdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistNormalCdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -107,7 +107,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalCdf_opencl_broadcast_mu) {
       normal_cdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalCdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistNormalCdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -122,7 +122,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalCdf_opencl_broadcast_sigma) {
       normal_cdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistNormalCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/normal_id_glm_lpdf_test.cpp b/test/unit/math/opencl/rev/normal_id_glm_lpdf_test.cpp
index 701775e07de..55f51e43a4d 100644
--- a/test/unit/math/opencl/rev/normal_id_glm_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/normal_id_glm_lpdf_test.cpp
@@ -11,7 +11,7 @@ using stan::math::matrix_cl;
 using stan::math::var;
 using stan::test::expect_near_rel;
 
-TEST_F(OpenCLRevTests, probdistributionsNormalIdGLM_error_checking) {
+TEST_F(OpenCLRevTests, probdistNormalIdGLM_error_checking) {
   int N = 3;
   int M = 2;
 
@@ -116,7 +116,7 @@ auto normal_id_glm_lpdf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsNormalIdGLM_opencl_matches_cpu_small_simple) {
+       probdistNormalIdGLM_opencl_matches_cpu_small_simple) {
   int N = 3;
   int M = 2;
 
@@ -135,7 +135,7 @@ TEST_F(OpenCLRevTests,
       normal_id_glm_lpdf_functor_propto, y, x, alpha, beta, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalIdGLM_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistNormalIdGLM_opencl_broadcast_y) {
   int N = 3;
   int M = 2;
 
@@ -154,7 +154,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalIdGLM_opencl_broadcast_y) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsNormalIdGLM_opencl_matches_cpu_zero_instances) {
+       probdistNormalIdGLM_opencl_matches_cpu_zero_instances) {
   int N = 0;
   int M = 2;
 
@@ -172,7 +172,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsNormalIdGLM_opencl_matches_cpu_zero_attributes) {
+       probdistNormalIdGLM_opencl_matches_cpu_zero_attributes) {
   int N = 3;
   int M = 0;
 
@@ -191,7 +191,7 @@ TEST_F(OpenCLRevTests,
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsNormalIdGLM_opencl_matches_cpu_small_vector_alpha_sigma) {
+    probdistNormalIdGLM_opencl_matches_cpu_small_vector_alpha_sigma) {
   int N = 3;
   int M = 2;
 
@@ -212,7 +212,7 @@ TEST_F(
       normal_id_glm_lpdf_functor_propto, y, x, alpha, beta, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalIdGLM_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistNormalIdGLM_opencl_matches_cpu_big) {
   int N = 153;
   int M = 71;
 
diff --git a/test/unit/math/opencl/rev/normal_lccdf_test.cpp b/test/unit/math/opencl/rev/normal_lccdf_test.cpp
index 33d3eaf380e..bef7184aeaf 100644
--- a/test/unit/math/opencl/rev/normal_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/normal_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsNormalLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistNormalLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto normal_lccdf_functor
         return stan::math::normal_lccdf(y, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsNormalLccdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistNormalLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -79,7 +79,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalLccdf_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalLccdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistNormalLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -94,7 +94,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalLccdf_opencl_broadcast_y) {
       normal_lccdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalLccdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistNormalLccdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalLccdf_opencl_broadcast_mu) {
       normal_lccdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalLccdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistNormalLccdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -124,7 +124,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalLccdf_opencl_broadcast_sigma) {
       normal_lccdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalLccdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistNormalLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/normal_lcdf_test.cpp b/test/unit/math/opencl/rev/normal_lcdf_test.cpp
index 5ef54d36543..cfd21dc48c9 100644
--- a/test/unit/math/opencl/rev/normal_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/normal_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsNormalLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistNormalLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto normal_lcdf_functor
         return stan::math::normal_lcdf(y, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsNormalLcdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistNormalLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -79,7 +79,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalLcdf_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalLcdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistNormalLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -94,7 +94,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalLcdf_opencl_broadcast_y) {
       normal_lcdf_functor, y_scal, mu.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalLcdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistNormalLcdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalLcdf_opencl_broadcast_mu) {
       normal_lcdf_functor, y.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalLcdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistNormalLcdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -124,7 +124,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormalLcdf_opencl_broadcast_sigma) {
       normal_lcdf_functor, y.transpose().eval(), mu, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormalLcdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistNormalLcdf_opencl_matches_cpu_big) {
   int N = 15379;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/normal_lpdf_test.cpp b/test/unit/math/opencl/rev/normal_lpdf_test.cpp
index 8d73aafd088..f9fcacbd772 100644
--- a/test/unit/math/opencl/rev/normal_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/normal_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsNormal_error_checking) {
+TEST_F(OpenCLRevTests, probdistNormal_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -65,7 +65,7 @@ auto normal_lpdf_functor_propto
         return stan::math::normal_lpdf<true>(y, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsNormal_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistNormal_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -87,7 +87,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormal_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormal_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistNormal_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -106,7 +106,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormal_opencl_broadcast_y) {
       normal_lpdf_functor_propto, y_scal, mu, sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormal_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistNormal_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -125,7 +125,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormal_opencl_broadcast_mu) {
       normal_lpdf_functor_propto, y, mu_scal, sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormal_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistNormal_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -144,7 +144,7 @@ TEST_F(OpenCLRevTests, probdistributionsNormal_opencl_broadcast_sigma) {
       normal_lpdf_functor_propto, y, mu.transpose().eval(), sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsNormal_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistNormal_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/ordered_logistic_glm_lpmf_test.cpp b/test/unit/math/opencl/rev/ordered_logistic_glm_lpmf_test.cpp
index dad473e0c31..752255fa986 100644
--- a/test/unit/math/opencl/rev/ordered_logistic_glm_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/ordered_logistic_glm_lpmf_test.cpp
@@ -12,7 +12,7 @@ using stan::math::matrix_cl;
 using stan::math::var;
 using std::vector;
 
-TEST_F(OpenCLRevTests, probdistributionsOrderedLogisitcGLM_error_checking) {
+TEST_F(OpenCLRevTests, probdistOrderedLogisitcGLM_error_checking) {
   int N = 3;
   int M = 2;
   int C = 5;
@@ -103,7 +103,7 @@ auto ordered_logistic_glm_lpmf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsOrderedLogisitcGLM_opencl_matches_cpu_small_simple) {
+       probdistOrderedLogisitcGLM_opencl_matches_cpu_small_simple) {
   int N = 3;
   int M = 2;
   int C = 5;
@@ -123,7 +123,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsOrderedLogisitcGLM_opencl_matches_cpu_broadcast_y) {
+       probdistOrderedLogisitcGLM_opencl_matches_cpu_broadcast_y) {
   int N = 3;
   int M = 2;
   int C = 3;
@@ -143,7 +143,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsOrderedLogisitcGLM_opencl_matches_cpu_zero_instances) {
+       probdistOrderedLogisitcGLM_opencl_matches_cpu_zero_instances) {
   int N = 0;
   int M = 2;
   int C = 5;
@@ -167,7 +167,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsOrderedLogisitcGLM_opencl_matches_cpu_zero_attributes) {
+       probdistOrderedLogisitcGLM_opencl_matches_cpu_zero_attributes) {
   int N = 3;
   int M = 0;
   int C = 5;
@@ -185,7 +185,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsOrderedLogisitcGLM_opencl_matches_cpu_single_class) {
+       probdistOrderedLogisitcGLM_opencl_matches_cpu_single_class) {
   int N = 3;
   int M = 2;
   int C = 1;
@@ -204,7 +204,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsOrderedLogisitcGLM_opencl_matches_cpu_big) {
+       probdistOrderedLogisitcGLM_opencl_matches_cpu_big) {
   int N = 153;
   int M = 71;
   int C = 43;
diff --git a/test/unit/math/opencl/rev/ordered_logistic_lpmf_test.cpp b/test/unit/math/opencl/rev/ordered_logistic_lpmf_test.cpp
index 3625a7222ff..62627dc89dd 100644
--- a/test/unit/math/opencl/rev/ordered_logistic_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/ordered_logistic_lpmf_test.cpp
@@ -12,7 +12,7 @@ using stan::math::matrix_cl;
 using stan::math::var;
 using std::vector;
 
-TEST_F(OpenCLRevTests, probdistributionsOrderedLogisitc_error_checking) {
+TEST_F(OpenCLRevTests, probdistOrderedLogisitc_error_checking) {
   int N = 3;
   int C = 5;
 
@@ -83,7 +83,7 @@ auto ordered_logistic_lpmf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsOrderedLogisitc_opencl_matches_cpu_small_simple) {
+       probdistOrderedLogisitc_opencl_matches_cpu_small_simple) {
   int N = 3;
   int C = 5;
 
@@ -107,7 +107,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsOrderedLogisitc_opencl_matches_cpu_zero_instances) {
+       probdistOrderedLogisitc_opencl_matches_cpu_zero_instances) {
   int N = 0;
   int C = 5;
 
@@ -128,7 +128,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsOrderedLogisitc_opencl_matches_cpu_single_class) {
+       probdistOrderedLogisitc_opencl_matches_cpu_single_class) {
   int N = 3;
   int C = 1;
 
@@ -149,7 +149,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsOrderedLogisitc_opencl_matches_cpu_big) {
+       probdistOrderedLogisitc_opencl_matches_cpu_big) {
   int N = 153;
   int C = 43;
 
diff --git a/test/unit/math/opencl/rev/pareto_cdf_test.cpp b/test/unit/math/opencl/rev/pareto_cdf_test.cpp
index bbdafe8f8b8..ae79fabc8f1 100644
--- a/test/unit/math/opencl/rev/pareto_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/pareto_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsParetoCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistParetoCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto pareto_cdf_functor
         return stan::math::pareto_cdf(y, y_min, alpha);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsParetoCdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistParetoCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -80,7 +80,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoCdf_opencl_matches_cpu_small) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsParetoCdf_opencl_matches_cpu_small_y_lower_than_y_min) {
+       probdistParetoCdf_opencl_matches_cpu_small_y_lower_than_y_min) {
   int N = 3;
   int M = 2;
 
@@ -98,7 +98,7 @@ TEST_F(OpenCLRevTests,
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoCdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistParetoCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -113,7 +113,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoCdf_opencl_broadcast_y) {
       pareto_cdf_functor, y_scal, y_min.transpose().eval(), alpha);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoCdf_opencl_broadcast_y_min) {
+TEST_F(OpenCLRevTests, probdistParetoCdf_opencl_broadcast_y_min) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -128,7 +128,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoCdf_opencl_broadcast_y_min) {
       pareto_cdf_functor, y.transpose().eval(), y_min_scal, alpha);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoCdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistParetoCdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -143,7 +143,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoCdf_opencl_broadcast_alpha) {
       pareto_cdf_functor, y.transpose().eval(), y_min, alpha_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistParetoCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y_min
diff --git a/test/unit/math/opencl/rev/pareto_lccdf_test.cpp b/test/unit/math/opencl/rev/pareto_lccdf_test.cpp
index bb3eaf7a0a6..6adf9a3d86c 100644
--- a/test/unit/math/opencl/rev/pareto_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/pareto_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsParetoLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistParetoLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto pareto_lccdf_functor
         return stan::math::pareto_lccdf(y, y_min, alpha);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsParetoLccdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistParetoLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -81,7 +81,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoLccdf_opencl_matches_cpu_small) {
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsParetoLccdf_opencl_matches_cpu_small_y_lower_than_y_min) {
+    probdistParetoLccdf_opencl_matches_cpu_small_y_lower_than_y_min) {
   int N = 3;
   int M = 2;
 
@@ -99,7 +99,7 @@ TEST_F(
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoLccdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistParetoLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -114,7 +114,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoLccdf_opencl_broadcast_y) {
       pareto_lccdf_functor, y_scal, y_min.transpose().eval(), alpha);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoLccdf_opencl_broadcast_y_min) {
+TEST_F(OpenCLRevTests, probdistParetoLccdf_opencl_broadcast_y_min) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -129,7 +129,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoLccdf_opencl_broadcast_y_min) {
       pareto_lccdf_functor, y.transpose().eval(), y_min_scal, alpha);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoLccdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistParetoLccdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -144,7 +144,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoLccdf_opencl_broadcast_alpha) {
       pareto_lccdf_functor, y.transpose().eval(), y_min, alpha_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoLccdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistParetoLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y_min
diff --git a/test/unit/math/opencl/rev/pareto_lcdf_test.cpp b/test/unit/math/opencl/rev/pareto_lcdf_test.cpp
index fccfe82a663..b8e3a2eff57 100644
--- a/test/unit/math/opencl/rev/pareto_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/pareto_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsParetoLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistParetoLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto pareto_lcdf_functor
         return stan::math::pareto_lcdf(y, y_min, alpha);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsParetoLcdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistParetoLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -81,7 +81,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoLcdf_opencl_matches_cpu_small) {
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsParetoLcdf_opencl_matches_cpu_small_y_lower_than_y_min) {
+    probdistParetoLcdf_opencl_matches_cpu_small_y_lower_than_y_min) {
   int N = 3;
   int M = 2;
 
@@ -99,7 +99,7 @@ TEST_F(
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoLcdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistParetoLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -114,7 +114,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoLcdf_opencl_broadcast_y) {
       pareto_lcdf_functor, y_scal, y_min.transpose().eval(), alpha);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoLcdf_opencl_broadcast_y_min) {
+TEST_F(OpenCLRevTests, probdistParetoLcdf_opencl_broadcast_y_min) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -129,7 +129,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoLcdf_opencl_broadcast_y_min) {
       pareto_lcdf_functor, y.transpose().eval(), y_min_scal, alpha);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoLcdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistParetoLcdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -144,7 +144,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoLcdf_opencl_broadcast_alpha) {
       pareto_lcdf_functor, y.transpose().eval(), y_min, alpha_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoLcdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistParetoLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y_min
diff --git a/test/unit/math/opencl/rev/pareto_lpdf_test.cpp b/test/unit/math/opencl/rev/pareto_lpdf_test.cpp
index 667ebfd7e16..3e9cde48c4a 100644
--- a/test/unit/math/opencl/rev/pareto_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/pareto_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsPareto_error_checking) {
+TEST_F(OpenCLRevTests, probdistPareto_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -75,7 +75,7 @@ auto pareto_lpdf_functor_propto
         return stan::math::pareto_lpdf<true>(y, y_min, alpha);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsPareto_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistPareto_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -98,7 +98,7 @@ TEST_F(OpenCLRevTests, probdistributionsPareto_opencl_matches_cpu_small) {
       y_min.transpose().eval(), alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsPareto_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistPareto_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -118,7 +118,7 @@ TEST_F(OpenCLRevTests, probdistributionsPareto_opencl_broadcast_y) {
       pareto_lpdf_functor_propto, y_scal, y_min, alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsPareto_opencl_broadcast_y_min) {
+TEST_F(OpenCLRevTests, probdistPareto_opencl_broadcast_y_min) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -137,7 +137,7 @@ TEST_F(OpenCLRevTests, probdistributionsPareto_opencl_broadcast_y_min) {
       pareto_lpdf_functor_propto, y, y_min_scal, alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsPareto_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistPareto_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -156,7 +156,7 @@ TEST_F(OpenCLRevTests, probdistributionsPareto_opencl_broadcast_alpha) {
       pareto_lpdf_functor_propto, y, y_min.transpose().eval(), alpha_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsPareto_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistPareto_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/pareto_type_2_cdf_test.cpp b/test/unit/math/opencl/rev/pareto_type_2_cdf_test.cpp
index 91aa3a404b5..2635093c191 100644
--- a/test/unit/math/opencl/rev/pareto_type_2_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/pareto_type_2_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2Cdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistParetoType2Cdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -85,7 +85,7 @@ auto pareto_type_2_cdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsParetoType2Cdf_opencl_matches_cpu_small) {
+       probdistParetoType2Cdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -105,7 +105,7 @@ TEST_F(OpenCLRevTests,
       lambda.transpose().eval(), alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2Cdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistParetoType2Cdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -123,7 +123,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoType2Cdf_opencl_broadcast_y) {
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2Cdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistParetoType2Cdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -142,7 +142,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoType2Cdf_opencl_broadcast_mu) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsParetoType2Cdf_opencl_broadcast_lambda) {
+       probdistParetoType2Cdf_opencl_broadcast_lambda) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -160,7 +160,7 @@ TEST_F(OpenCLRevTests,
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2Cdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistParetoType2Cdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -178,7 +178,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoType2Cdf_opencl_broadcast_alpha) {
       lambda.transpose().eval(), alpha_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2Cdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistParetoType2Cdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> mu
diff --git a/test/unit/math/opencl/rev/pareto_type_2_lccdf_test.cpp b/test/unit/math/opencl/rev/pareto_type_2_lccdf_test.cpp
index 4d97c9e27ac..ce7135701a6 100644
--- a/test/unit/math/opencl/rev/pareto_type_2_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/pareto_type_2_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2Lccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistParetoType2Lccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -85,7 +85,7 @@ auto pareto_type_2_lccdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsParetoType2Lccdf_opencl_matches_cpu_small) {
+       probdistParetoType2Lccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -105,7 +105,7 @@ TEST_F(OpenCLRevTests,
       lambda.transpose().eval(), alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2Lccdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistParetoType2Lccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -123,7 +123,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoType2Lccdf_opencl_broadcast_y) {
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2Lccdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistParetoType2Lccdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -142,7 +142,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoType2Lccdf_opencl_broadcast_mu) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsParetoType2Lccdf_opencl_broadcast_lambda) {
+       probdistParetoType2Lccdf_opencl_broadcast_lambda) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -161,7 +161,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsParetoType2Lccdf_opencl_broadcast_alpha) {
+       probdistParetoType2Lccdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -180,7 +180,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsParetoType2Lccdf_opencl_matches_cpu_big) {
+       probdistParetoType2Lccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> mu
diff --git a/test/unit/math/opencl/rev/pareto_type_2_lcdf_test.cpp b/test/unit/math/opencl/rev/pareto_type_2_lcdf_test.cpp
index d9975f09542..fb34c05fa86 100644
--- a/test/unit/math/opencl/rev/pareto_type_2_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/pareto_type_2_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2Lcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistParetoType2Lcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -85,7 +85,7 @@ auto pareto_type_2_lcdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsParetoType2Lcdf_opencl_matches_cpu_small) {
+       probdistParetoType2Lcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -105,7 +105,7 @@ TEST_F(OpenCLRevTests,
       lambda.transpose().eval(), alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2Lcdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistParetoType2Lcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -123,7 +123,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoType2Lcdf_opencl_broadcast_y) {
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2Lcdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistParetoType2Lcdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -142,7 +142,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoType2Lcdf_opencl_broadcast_mu) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsParetoType2Lcdf_opencl_broadcast_lambda) {
+       probdistParetoType2Lcdf_opencl_broadcast_lambda) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -161,7 +161,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsParetoType2Lcdf_opencl_broadcast_alpha) {
+       probdistParetoType2Lcdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -180,7 +180,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsParetoType2Lcdf_opencl_matches_cpu_big) {
+       probdistParetoType2Lcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> mu
diff --git a/test/unit/math/opencl/rev/pareto_type_2_lpdf_test.cpp b/test/unit/math/opencl/rev/pareto_type_2_lpdf_test.cpp
index c81d20b33ed..b5da7ef50ac 100644
--- a/test/unit/math/opencl/rev/pareto_type_2_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/pareto_type_2_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2_error_checking) {
+TEST_F(OpenCLRevTests, probdistParetoType2_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -103,7 +103,7 @@ auto pareto_type_2_lpdf_functor_propto
         return stan::math::pareto_type_2_lpdf<true>(y, mu, lambda, alpha);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistParetoType2_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -128,7 +128,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoType2_opencl_matches_cpu_small) {
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistParetoType2_opencl_broadcast_y) {
   int N = 3;
 
   double y = 30.3;
@@ -151,7 +151,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoType2_opencl_broadcast_y) {
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistParetoType2_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -174,7 +174,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoType2_opencl_broadcast_mu) {
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2_opencl_broadcast_lambda) {
+TEST_F(OpenCLRevTests, probdistParetoType2_opencl_broadcast_lambda) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -197,7 +197,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoType2_opencl_broadcast_lambda) {
       mu.transpose().eval(), lambda, alpha);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistParetoType2_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -220,7 +220,7 @@ TEST_F(OpenCLRevTests, probdistributionsParetoType2_opencl_broadcast_alpha) {
       lambda.transpose().eval(), alpha);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsParetoType2_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistParetoType2_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/poisson_log_glm_lpmf_test.cpp b/test/unit/math/opencl/rev/poisson_log_glm_lpmf_test.cpp
index 4696cf641af..b933118482c 100644
--- a/test/unit/math/opencl/rev/poisson_log_glm_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/poisson_log_glm_lpmf_test.cpp
@@ -13,7 +13,7 @@ using stan::math::var;
 using stan::test::expect_near_rel;
 using std::vector;
 
-TEST_F(OpenCLRevTests, probdistributionsPoissonLogGLM_error_checking) {
+TEST_F(OpenCLRevTests, probdistPoissonLogGLM_error_checking) {
   int N = 3;
   int M = 2;
 
@@ -101,7 +101,7 @@ auto poisson_log_glm_lpmf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsPoissonLogGLM_opencl_matches_cpu_small_simple) {
+       probdistPoissonLogGLM_opencl_matches_cpu_small_simple) {
   int N = 3;
   int M = 2;
 
@@ -118,7 +118,7 @@ TEST_F(OpenCLRevTests,
       poisson_log_glm_lpmf_functor_propto, y, x, alpha, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsPoissonLogGLM_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistPoissonLogGLM_opencl_broadcast_y) {
   int N = 3;
   int M = 2;
 
@@ -136,7 +136,7 @@ TEST_F(OpenCLRevTests, probdistributionsPoissonLogGLM_opencl_broadcast_y) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsPoissonLogGLM_opencl_matches_cpu_zero_instances) {
+       probdistPoissonLogGLM_opencl_matches_cpu_zero_instances) {
   int N = 0;
   int M = 2;
 
@@ -153,7 +153,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsPoissonLogGLM_opencl_matches_cpu_zero_attributes) {
+       probdistPoissonLogGLM_opencl_matches_cpu_zero_attributes) {
   int N = 3;
   int M = 0;
 
@@ -169,7 +169,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsPoissonLogGLM_opencl_matches_cpu_small_vector_alpha) {
+       probdistPoissonLogGLM_opencl_matches_cpu_small_vector_alpha) {
   int N = 3;
   int M = 2;
 
@@ -187,7 +187,7 @@ TEST_F(OpenCLRevTests,
       poisson_log_glm_lpmf_functor_propto, y, x, alpha, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsPoissonLogGLM_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistPoissonLogGLM_opencl_matches_cpu_big) {
   int N = 153;
   int M = 71;
 
diff --git a/test/unit/math/opencl/rev/poisson_log_lpmf_test.cpp b/test/unit/math/opencl/rev/poisson_log_lpmf_test.cpp
index 619ce095b2d..22e8fed12f0 100644
--- a/test/unit/math/opencl/rev/poisson_log_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/poisson_log_lpmf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsPoissonLog_error_checking) {
+TEST_F(OpenCLRevTests, probdistPoissonLog_error_checking) {
   int N = 3;
 
   std::vector<int> n{1, 0, 5};
@@ -45,7 +45,7 @@ auto poisson_log_lpmf_functor_propto = [](const auto& n, const auto& alpha) {
   return stan::math::poisson_log_lpmf<true>(n, alpha);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsPoissonLog_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistPoissonLog_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -63,7 +63,7 @@ TEST_F(OpenCLRevTests, probdistributionsPoissonLog_opencl_matches_cpu_small) {
                                                 n, alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsPoissonLog_opencl_broadcast_n) {
+TEST_F(OpenCLRevTests, probdistPoissonLog_opencl_broadcast_n) {
   int N = 3;
 
   int n_scal = 1;
@@ -76,7 +76,7 @@ TEST_F(OpenCLRevTests, probdistributionsPoissonLog_opencl_broadcast_n) {
       poisson_log_lpmf_functor_propto, n_scal, alpha);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsPoissonLog_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistPoissonLog_opencl_broadcast_alpha) {
   int N = 3;
 
   std::vector<int> n{0, 1, 5};
@@ -88,7 +88,7 @@ TEST_F(OpenCLRevTests, probdistributionsPoissonLog_opencl_broadcast_alpha) {
       poisson_log_lpmf_functor_propto, n, alpha_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsPoissonLog_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistPoissonLog_opencl_matches_cpu_big) {
   int N = 153;
 
   std::vector<int> n(N);
diff --git a/test/unit/math/opencl/rev/poisson_lpmf_test.cpp b/test/unit/math/opencl/rev/poisson_lpmf_test.cpp
index 4a38f0ecf20..9378b68296a 100644
--- a/test/unit/math/opencl/rev/poisson_lpmf_test.cpp
+++ b/test/unit/math/opencl/rev/poisson_lpmf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsPoisson_error_checking) {
+TEST_F(OpenCLRevTests, probdistPoisson_error_checking) {
   int N = 3;
 
   std::vector<int> n{1, 0, 5};
@@ -45,7 +45,7 @@ auto poisson_lpmf_functor_propto = [](const auto& n, const auto& alpha) {
   return stan::math::poisson_lpmf<true>(n, alpha);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsPoisson_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistPoisson_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -61,7 +61,7 @@ TEST_F(OpenCLRevTests, probdistributionsPoisson_opencl_matches_cpu_small) {
                                                 alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsPoisson_opencl_broadcast_n) {
+TEST_F(OpenCLRevTests, probdistPoisson_opencl_broadcast_n) {
   int N = 3;
 
   int n_scal = 1;
@@ -74,7 +74,7 @@ TEST_F(OpenCLRevTests, probdistributionsPoisson_opencl_broadcast_n) {
       poisson_lpmf_functor_propto, n_scal, alpha);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsPoisson_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistPoisson_opencl_broadcast_alpha) {
   int N = 3;
 
   std::vector<int> n{0, 1, 5};
@@ -86,7 +86,7 @@ TEST_F(OpenCLRevTests, probdistributionsPoisson_opencl_broadcast_alpha) {
       poisson_lpmf_functor_propto, n, alpha_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsPoisson_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistPoisson_opencl_matches_cpu_big) {
   int N = 153;
 
   std::vector<int> n(N);
diff --git a/test/unit/math/opencl/rev/rayleigh_cdf_test.cpp b/test/unit/math/opencl/rev/rayleigh_cdf_test.cpp
index 292add5bfc6..48f30dfa64f 100644
--- a/test/unit/math/opencl/rev/rayleigh_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/rayleigh_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistRayleighCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -44,7 +44,7 @@ auto rayleigh_cdf_functor = [](const auto& y, const auto& mu) {
   return stan::math::rayleigh_cdf(y, mu);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighCdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistRayleighCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -58,7 +58,7 @@ TEST_F(OpenCLRevTests, probdistributionsRayleighCdf_opencl_matches_cpu_small) {
       rayleigh_cdf_functor, y.transpose().eval(), mu.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighCdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistRayleighCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -69,7 +69,7 @@ TEST_F(OpenCLRevTests, probdistributionsRayleighCdf_opencl_broadcast_y) {
                                                          y_scal, mu);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighCdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistRayleighCdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -80,7 +80,7 @@ TEST_F(OpenCLRevTests, probdistributionsRayleighCdf_opencl_broadcast_mu) {
                                                          y, mu_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistRayleighCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/rayleigh_lccdf_test.cpp b/test/unit/math/opencl/rev/rayleigh_lccdf_test.cpp
index 7787ef24849..b44edfdfe87 100644
--- a/test/unit/math/opencl/rev/rayleigh_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/rayleigh_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistRayleighLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -47,7 +47,7 @@ auto rayleigh_lccdf_functor = [](const auto& y, const auto& mu) {
 };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsRayleighLccdf_opencl_matches_cpu_small) {
+       probdistRayleighLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -61,7 +61,7 @@ TEST_F(OpenCLRevTests,
       rayleigh_lccdf_functor, y.transpose().eval(), mu.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighLccdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistRayleighLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -72,7 +72,7 @@ TEST_F(OpenCLRevTests, probdistributionsRayleighLccdf_opencl_broadcast_y) {
                                                          y_scal, mu);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighLccdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistRayleighLccdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -83,7 +83,7 @@ TEST_F(OpenCLRevTests, probdistributionsRayleighLccdf_opencl_broadcast_mu) {
                                                          y, mu_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighLccdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistRayleighLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/rayleigh_lcdf_test.cpp b/test/unit/math/opencl/rev/rayleigh_lcdf_test.cpp
index ef7dc86534c..7534d10714a 100644
--- a/test/unit/math/opencl/rev/rayleigh_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/rayleigh_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistRayleighLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -44,7 +44,7 @@ auto rayleigh_lcdf_functor = [](const auto& y, const auto& mu) {
   return stan::math::rayleigh_lcdf(y, mu);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighLcdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistRayleighLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -58,7 +58,7 @@ TEST_F(OpenCLRevTests, probdistributionsRayleighLcdf_opencl_matches_cpu_small) {
       rayleigh_lcdf_functor, y.transpose().eval(), mu.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighLcdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistRayleighLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -69,7 +69,7 @@ TEST_F(OpenCLRevTests, probdistributionsRayleighLcdf_opencl_broadcast_y) {
                                                          y_scal, mu);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighLcdf_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistRayleighLcdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -80,7 +80,7 @@ TEST_F(OpenCLRevTests, probdistributionsRayleighLcdf_opencl_broadcast_mu) {
                                                          y, mu_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsRayleighLcdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistRayleighLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/rayleigh_lpdf_test.cpp b/test/unit/math/opencl/rev/rayleigh_lpdf_test.cpp
index a3e6570750d..483bab47a4d 100644
--- a/test/unit/math/opencl/rev/rayleigh_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/rayleigh_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsRayleigh_error_checking) {
+TEST_F(OpenCLRevTests, probdistRayleigh_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -50,7 +50,7 @@ auto rayleigh_lpdf_functor_propto = [](const auto& y, const auto& sigma) {
   return stan::math::rayleigh_lpdf<true>(y, sigma);
 };
 
-TEST_F(OpenCLRevTests, probdistributionsRayleigh_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistRayleigh_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -69,7 +69,7 @@ TEST_F(OpenCLRevTests, probdistributionsRayleigh_opencl_matches_cpu_small) {
                                                 sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsRayleigh_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistRayleigh_opencl_broadcast_y) {
   int N = 3;
 
   double y = 0.5;
@@ -82,7 +82,7 @@ TEST_F(OpenCLRevTests, probdistributionsRayleigh_opencl_broadcast_y) {
       rayleigh_lpdf_functor_propto, y, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsRayleigh_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistRayleigh_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -95,7 +95,7 @@ TEST_F(OpenCLRevTests, probdistributionsRayleigh_opencl_broadcast_sigma) {
       rayleigh_lpdf_functor_propto, y, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsRayleigh_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistRayleigh_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/scaled_inv_chi_square_lpdf_test.cpp b/test/unit/math/opencl/rev/scaled_inv_chi_square_lpdf_test.cpp
index d677e1b7ced..ece64c91dbe 100644
--- a/test/unit/math/opencl/rev/scaled_inv_chi_square_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/scaled_inv_chi_square_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsScaledInvChiSquare_error_checking) {
+TEST_F(OpenCLRevTests, probdistScaledInvChiSquare_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -76,7 +76,7 @@ auto scaled_inv_chi_square_lpdf_functor_propto
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsScaledInvChiSquare_opencl_matches_cpu_small) {
+       probdistScaledInvChiSquare_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -100,7 +100,7 @@ TEST_F(OpenCLRevTests,
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsScaledInvChiSquare_opencl_matches_cpu_small_y_negative) {
+    probdistScaledInvChiSquare_opencl_matches_cpu_small_y_negative) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -116,7 +116,7 @@ TEST_F(
       scaled_inv_chi_square_lpdf_functor_propto, y, nu, s);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsScaledInvChiSquare_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistScaledInvChiSquare_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -137,7 +137,7 @@ TEST_F(OpenCLRevTests, probdistributionsScaledInvChiSquare_opencl_broadcast_y) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsScaledInvChiSquare_opencl_broadcast_nu) {
+       probdistScaledInvChiSquare_opencl_broadcast_nu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -157,7 +157,7 @@ TEST_F(OpenCLRevTests,
       s.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsScaledInvChiSquare_opencl_broadcast_s) {
+TEST_F(OpenCLRevTests, probdistScaledInvChiSquare_opencl_broadcast_s) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -178,7 +178,7 @@ TEST_F(OpenCLRevTests, probdistributionsScaledInvChiSquare_opencl_broadcast_s) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsScaledInvChiSquare_opencl_matches_cpu_big) {
+       probdistScaledInvChiSquare_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/skew_double_exponential_cdf2_test.cpp b/test/unit/math/opencl/rev/skew_double_exponential_cdf2_test.cpp
index a6de4983c3f..ba7f988fa9e 100644
--- a/test/unit/math/opencl/rev/skew_double_exponential_cdf2_test.cpp
+++ b/test/unit/math/opencl/rev/skew_double_exponential_cdf2_test.cpp
@@ -13,7 +13,7 @@ auto skew_double_exponential_cdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialCdf_opencl_broadcast_sigma) {
+       probdistSkewDoubleExponentialCdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -32,7 +32,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialCdf_opencl_broadcast_tau) {
+       probdistSkewDoubleExponentialCdf_opencl_broadcast_tau) {
   int N = 3;
 
   Eigen::VectorXd y(N);
diff --git a/test/unit/math/opencl/rev/skew_double_exponential_cdf_test.cpp b/test/unit/math/opencl/rev/skew_double_exponential_cdf_test.cpp
index 7d4d748d331..bb50068b4be 100644
--- a/test/unit/math/opencl/rev/skew_double_exponential_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/skew_double_exponential_cdf_test.cpp
@@ -8,7 +8,7 @@
 namespace skew_double_exponential_cdf_test {
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialCdf_error_checking) {
+       probdistSkewDoubleExponentialCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -88,7 +88,7 @@ auto skew_double_exponential_cdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialCdf_opencl_matches_cpu_small) {
+       probdistSkewDoubleExponentialCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -110,7 +110,7 @@ TEST_F(OpenCLRevTests,
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsSkewDoubleExponentialCdf_opencl_matches_cpu_small_y_neg_inf) {
+    probdistSkewDoubleExponentialCdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
   int M = 2;
 
@@ -131,7 +131,7 @@ TEST_F(
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialCdf_opencl_broadcast_y) {
+       probdistSkewDoubleExponentialCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -150,7 +150,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialCdf_opencl_broadcast_mu) {
+       probdistSkewDoubleExponentialCdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -169,7 +169,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialCdf_opencl_matches_cpu_big) {
+       probdistSkewDoubleExponentialCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/skew_double_exponential_lccdf2_test.cpp b/test/unit/math/opencl/rev/skew_double_exponential_lccdf2_test.cpp
index eedfe8c65ac..dc14ed5e025 100644
--- a/test/unit/math/opencl/rev/skew_double_exponential_lccdf2_test.cpp
+++ b/test/unit/math/opencl/rev/skew_double_exponential_lccdf2_test.cpp
@@ -13,7 +13,7 @@ auto skew_double_exponential_lccdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLccdf_opencl_broadcast_sigma) {
+       probdistSkewDoubleExponentialLccdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -32,7 +32,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLccdf_opencl_broadcast_tau) {
+       probdistSkewDoubleExponentialLccdf_opencl_broadcast_tau) {
   int N = 3;
 
   Eigen::VectorXd y(N);
diff --git a/test/unit/math/opencl/rev/skew_double_exponential_lccdf_test.cpp b/test/unit/math/opencl/rev/skew_double_exponential_lccdf_test.cpp
index ab5ce053e63..07f44f49f94 100644
--- a/test/unit/math/opencl/rev/skew_double_exponential_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/skew_double_exponential_lccdf_test.cpp
@@ -8,7 +8,7 @@
 namespace skew_double_exponential_lccdf_test {
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLccdf_error_checking) {
+       probdistSkewDoubleExponentialLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -88,7 +88,7 @@ auto skew_double_exponential_lccdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLccdf_opencl_matches_cpu_small) {
+       probdistSkewDoubleExponentialLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -110,7 +110,7 @@ TEST_F(OpenCLRevTests,
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsSkewDoubleExponentialLccdf_opencl_matches_cpu_small_y_neg_inf) {
+    probdistSkewDoubleExponentialLccdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
   int M = 2;
 
@@ -131,7 +131,7 @@ TEST_F(
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLccdf_opencl_broadcast_y) {
+       probdistSkewDoubleExponentialLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -150,7 +150,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLccdf_opencl_broadcast_mu) {
+       probdistSkewDoubleExponentialLccdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -169,7 +169,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLccdf_opencl_matches_cpu_big) {
+       probdistSkewDoubleExponentialLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/skew_double_exponential_lcdf2_test.cpp b/test/unit/math/opencl/rev/skew_double_exponential_lcdf2_test.cpp
index 7271b9407c3..e3cd9b6756c 100644
--- a/test/unit/math/opencl/rev/skew_double_exponential_lcdf2_test.cpp
+++ b/test/unit/math/opencl/rev/skew_double_exponential_lcdf2_test.cpp
@@ -13,7 +13,7 @@ auto skew_double_exponential_lcdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLcdf_opencl_broadcast_sigma) {
+       probdistSkewDoubleExponentialLcdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -32,7 +32,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLcdf_opencl_broadcast_tau) {
+       probdistSkewDoubleExponentialLcdf_opencl_broadcast_tau) {
   int N = 3;
 
   Eigen::VectorXd y(N);
diff --git a/test/unit/math/opencl/rev/skew_double_exponential_lcdf_test.cpp b/test/unit/math/opencl/rev/skew_double_exponential_lcdf_test.cpp
index 7262a8f9a34..f6d121c0a97 100644
--- a/test/unit/math/opencl/rev/skew_double_exponential_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/skew_double_exponential_lcdf_test.cpp
@@ -8,7 +8,7 @@
 namespace skew_double_exponential_lcdf_test {
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLcdf_error_checking) {
+       probdistSkewDoubleExponentialLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -88,7 +88,7 @@ auto skew_double_exponential_lcdf_functor
       };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLcdf_opencl_matches_cpu_small) {
+       probdistSkewDoubleExponentialLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -110,7 +110,7 @@ TEST_F(OpenCLRevTests,
 
 TEST_F(
     OpenCLRevTests,
-    probdistributionsSkewDoubleExponentialLcdf_opencl_matches_cpu_small_y_neg_inf) {
+    probdistSkewDoubleExponentialLcdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
   int M = 2;
 
@@ -131,7 +131,7 @@ TEST_F(
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLcdf_opencl_broadcast_y) {
+       probdistSkewDoubleExponentialLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -150,7 +150,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLcdf_opencl_broadcast_mu) {
+       probdistSkewDoubleExponentialLcdf_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -169,7 +169,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponentialLcdf_opencl_matches_cpu_big) {
+       probdistSkewDoubleExponentialLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/skew_double_exponential_lpdf_test.cpp b/test/unit/math/opencl/rev/skew_double_exponential_lpdf_test.cpp
index c56dc2a788f..7c9740c7180 100644
--- a/test/unit/math/opencl/rev/skew_double_exponential_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/skew_double_exponential_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsSkewDoubleExponential_error_checking) {
+TEST_F(OpenCLRevTests, probdistSkewDoubleExponential_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -104,7 +104,7 @@ auto skew_double_exponential_lpdf_functor_propto =
     };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponential_opencl_matches_cpu_small) {
+       probdistSkewDoubleExponential_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -129,7 +129,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponential_opencl_broadcast_y) {
+       probdistSkewDoubleExponential_opencl_broadcast_y) {
   int N = 3;
 
   double y = 0.3;
@@ -153,7 +153,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponential_opencl_broadcast_mu) {
+       probdistSkewDoubleExponential_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -177,7 +177,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponential_opencl_broadcast_sigma) {
+       probdistSkewDoubleExponential_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -201,7 +201,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponential_opencl_broadcast_tau) {
+       probdistSkewDoubleExponential_opencl_broadcast_tau) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -225,7 +225,7 @@ TEST_F(OpenCLRevTests,
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsSkewDoubleExponential_opencl_matches_cpu_big) {
+       probdistSkewDoubleExponential_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/skew_normal_lpdf_test.cpp b/test/unit/math/opencl/rev/skew_normal_lpdf_test.cpp
index 89033bd9350..79ce9ad1bcf 100644
--- a/test/unit/math/opencl/rev/skew_normal_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/skew_normal_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsSkewNormal_error_checking) {
+TEST_F(OpenCLRevTests, probdistSkewNormal_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -88,7 +88,7 @@ auto skew_normal_lpdf_functor_propto
         return stan::math::skew_normal_lpdf<true>(y, mu, sigma, alpha);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsSkewNormal_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistSkewNormal_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -114,7 +114,7 @@ TEST_F(OpenCLRevTests, probdistributionsSkewNormal_opencl_matches_cpu_small) {
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsSkewNormal_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistSkewNormal_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -137,7 +137,7 @@ TEST_F(OpenCLRevTests, probdistributionsSkewNormal_opencl_broadcast_y) {
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsSkewNormal_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistSkewNormal_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -160,7 +160,7 @@ TEST_F(OpenCLRevTests, probdistributionsSkewNormal_opencl_broadcast_mu) {
       alpha.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsSkewNormal_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistSkewNormal_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -183,7 +183,7 @@ TEST_F(OpenCLRevTests, probdistributionsSkewNormal_opencl_broadcast_sigma) {
       mu.transpose().eval(), sigma_scal, alpha);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsSkewNormal_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistSkewNormal_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -206,7 +206,7 @@ TEST_F(OpenCLRevTests, probdistributionsSkewNormal_opencl_broadcast_alpha) {
       sigma.transpose().eval(), alpha_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsSkewNormal_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistSkewNormal_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/std_normal_cdf_test.cpp b/test/unit/math/opencl/rev/std_normal_cdf_test.cpp
index c09c99f366f..373da03ee35 100644
--- a/test/unit/math/opencl/rev/std_normal_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/std_normal_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsStdNormalCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistStdNormalCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -24,7 +24,7 @@ TEST_F(OpenCLRevTests, probdistributionsStdNormalCdf_error_checking) {
 auto std_normal_cdf_functor
     = [](const auto& y) { return stan::math::std_normal_cdf(y); };
 
-TEST_F(OpenCLRevTests, probdistributionsStdNormalCdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistStdNormalCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -36,7 +36,7 @@ TEST_F(OpenCLRevTests, probdistributionsStdNormalCdf_opencl_matches_cpu_small) {
                                                 y.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsStdNormalCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistStdNormalCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/std_normal_lccdf_test.cpp b/test/unit/math/opencl/rev/std_normal_lccdf_test.cpp
index 57890663b32..6e5513cce3a 100644
--- a/test/unit/math/opencl/rev/std_normal_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/std_normal_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsStdNormalLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistStdNormalLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -25,7 +25,7 @@ auto std_normal_lccdf_functor
     = [](const auto& y) { return stan::math::std_normal_lccdf(y); };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsStdNormalLccdf_opencl_matches_cpu_small) {
+       probdistStdNormalLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -37,7 +37,7 @@ TEST_F(OpenCLRevTests,
                                                 y.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsStdNormalLccdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistStdNormalLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/std_normal_lcdf_test.cpp b/test/unit/math/opencl/rev/std_normal_lcdf_test.cpp
index 3ca291b2e49..f49c8a6ebd6 100644
--- a/test/unit/math/opencl/rev/std_normal_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/std_normal_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsStdNormalLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistStdNormalLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -25,7 +25,7 @@ auto std_normal_lcdf_functor
     = [](const auto& y) { return stan::math::std_normal_lcdf(y); };
 
 TEST_F(OpenCLRevTests,
-       probdistributionsStdNormalLcdf_opencl_matches_cpu_small) {
+       probdistStdNormalLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -37,7 +37,7 @@ TEST_F(OpenCLRevTests,
                                                 y.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsStdNormalLcdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistStdNormalLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/std_normal_lpdf_test.cpp b/test/unit/math/opencl/rev/std_normal_lpdf_test.cpp
index db979a5acc0..5d3007f0d4a 100644
--- a/test/unit/math/opencl/rev/std_normal_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/std_normal_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsStdNormal_error_checking) {
+TEST_F(OpenCLRevTests, probdistStdNormal_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -25,7 +25,7 @@ auto std_normal_lpdf_functor
 auto std_normal_lpdf_functor_propto
     = [](const auto& y) { return stan::math::std_normal_lpdf<true>(y); };
 
-TEST_F(OpenCLRevTests, probdistributionsStdNormal_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistStdNormal_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -41,7 +41,7 @@ TEST_F(OpenCLRevTests, probdistributionsStdNormal_opencl_matches_cpu_small) {
                                                 y.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsStdNormal_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistStdNormal_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/student_t_lpdf2_test.cpp b/test/unit/math/opencl/rev/student_t_lpdf2_test.cpp
index 24d71bd9ae8..c91fac0a784 100644
--- a/test/unit/math/opencl/rev/student_t_lpdf2_test.cpp
+++ b/test/unit/math/opencl/rev/student_t_lpdf2_test.cpp
@@ -14,7 +14,7 @@ auto student_t_lpdf2_functor_propto
         return stan::math::student_t_lpdf<true>(y, nu, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsStudentT_opencl_broadcast_nu) {
+TEST_F(OpenCLRevTests, probdistStudentT_opencl_broadcast_nu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -37,7 +37,7 @@ TEST_F(OpenCLRevTests, probdistributionsStudentT_opencl_broadcast_nu) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsStudentT_opencl_broadcast_mu) {
+TEST_F(OpenCLRevTests, probdistStudentT_opencl_broadcast_mu) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -60,7 +60,7 @@ TEST_F(OpenCLRevTests, probdistributionsStudentT_opencl_broadcast_mu) {
       nu.transpose().eval(), mu_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsStudentT_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistStudentT_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
diff --git a/test/unit/math/opencl/rev/student_t_lpdf_test.cpp b/test/unit/math/opencl/rev/student_t_lpdf_test.cpp
index b3b072c78d2..881b7f4ba69 100644
--- a/test/unit/math/opencl/rev/student_t_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/student_t_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsStudentT_error_checking) {
+TEST_F(OpenCLRevTests, probdistStudentT_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -89,7 +89,7 @@ auto student_t_lpdf_functor_propto
         return stan::math::student_t_lpdf<true>(y, nu, mu, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsStudentT_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistStudentT_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -113,7 +113,7 @@ TEST_F(OpenCLRevTests, probdistributionsStudentT_opencl_matches_cpu_small) {
       nu.transpose().eval(), mu.transpose().eval(), sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsStudentT_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistStudentT_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -136,7 +136,7 @@ TEST_F(OpenCLRevTests, probdistributionsStudentT_opencl_broadcast_y) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsStudentT_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistStudentT_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/uniform_cdf_test.cpp b/test/unit/math/opencl/rev/uniform_cdf_test.cpp
index 5c6e15bf029..2368f65df01 100644
--- a/test/unit/math/opencl/rev/uniform_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/uniform_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsUniformCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistUniformCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto uniform_cdf_functor
         return stan::math::uniform_cdf(y, alpha, beta);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsUniformCdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistUniformCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -80,7 +80,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniformCdf_opencl_matches_cpu_small) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsUniformCdf_opencl_matches_cpu_small_y_neg_inf) {
+       probdistUniformCdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
   int M = 2;
 
@@ -98,7 +98,7 @@ TEST_F(OpenCLRevTests,
       beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniformCdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistUniformCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -113,7 +113,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniformCdf_opencl_broadcast_y) {
       uniform_cdf_functor, y_scal, alpha.transpose().eval(), beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniformCdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistUniformCdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -128,7 +128,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniformCdf_opencl_broadcast_alpha) {
       uniform_cdf_functor, y.transpose().eval(), alpha_scal, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniformCdf_opencl_broadcast_beta) {
+TEST_F(OpenCLRevTests, probdistUniformCdf_opencl_broadcast_beta) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -143,7 +143,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniformCdf_opencl_broadcast_beta) {
       uniform_cdf_functor, y.transpose().eval(), alpha, beta_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniformCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistUniformCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/uniform_lccdf_test.cpp b/test/unit/math/opencl/rev/uniform_lccdf_test.cpp
index 31fb85a29d4..6168c232995 100644
--- a/test/unit/math/opencl/rev/uniform_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/uniform_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsUniformLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistUniformLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto uniform_lccdf_functor
         return stan::math::uniform_lccdf(y, alpha, beta);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsUniformLccdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistUniformLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -80,7 +80,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniformLccdf_opencl_matches_cpu_small) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsUniformLccdf_opencl_matches_cpu_small_y_neg_inf) {
+       probdistUniformLccdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
   int M = 2;
 
@@ -98,7 +98,7 @@ TEST_F(OpenCLRevTests,
       beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniformLccdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistUniformLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -113,7 +113,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniformLccdf_opencl_broadcast_y) {
       uniform_lccdf_functor, y_scal, alpha.transpose().eval(), beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniformLccdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistUniformLccdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -128,7 +128,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniformLccdf_opencl_broadcast_alpha) {
       uniform_lccdf_functor, y.transpose().eval(), alpha_scal, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniformLccdf_opencl_broadcast_beta) {
+TEST_F(OpenCLRevTests, probdistUniformLccdf_opencl_broadcast_beta) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -143,7 +143,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniformLccdf_opencl_broadcast_beta) {
       uniform_lccdf_functor, y.transpose().eval(), alpha, beta_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniformLccdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistUniformLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/uniform_lcdf_test.cpp b/test/unit/math/opencl/rev/uniform_lcdf_test.cpp
index 2ed36b9d721..0540cb3b910 100644
--- a/test/unit/math/opencl/rev/uniform_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/uniform_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsUniformLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistUniformLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto uniform_lcdf_functor
         return stan::math::uniform_lcdf(y, alpha, beta);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsUniformLcdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistUniformLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -80,7 +80,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniformLcdf_opencl_matches_cpu_small) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsUniformLcdf_opencl_matches_cpu_small_y_neg_inf) {
+       probdistUniformLcdf_opencl_matches_cpu_small_y_neg_inf) {
   int N = 3;
   int M = 2;
 
@@ -98,7 +98,7 @@ TEST_F(OpenCLRevTests,
       beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniformLcdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistUniformLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -113,7 +113,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniformLcdf_opencl_broadcast_y) {
       uniform_lcdf_functor, y_scal, alpha.transpose().eval(), beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniformLcdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistUniformLcdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -128,7 +128,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniformLcdf_opencl_broadcast_alpha) {
       uniform_lcdf_functor, y.transpose().eval(), alpha_scal, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniformLcdf_opencl_broadcast_beta) {
+TEST_F(OpenCLRevTests, probdistUniformLcdf_opencl_broadcast_beta) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -143,7 +143,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniformLcdf_opencl_broadcast_beta) {
       uniform_lcdf_functor, y.transpose().eval(), alpha, beta_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniformLcdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistUniformLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/uniform_lpdf_test.cpp b/test/unit/math/opencl/rev/uniform_lpdf_test.cpp
index 2e5754f3e0f..2f836c2684c 100644
--- a/test/unit/math/opencl/rev/uniform_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/uniform_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsUniform_error_checking) {
+TEST_F(OpenCLRevTests, probdistUniform_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -70,7 +70,7 @@ auto uniform_lpdf_functor_propto
         return stan::math::uniform_lpdf<true>(y, alpha, beta);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsUniform_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistUniform_opencl_matches_cpu_small) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -93,7 +93,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniform_opencl_matches_cpu_small) {
 }
 
 TEST_F(OpenCLRevTests,
-       probdistributionsUniform_opencl_matches_cpu_small_y_out_of_bounds) {
+       probdistUniform_opencl_matches_cpu_small_y_out_of_bounds) {
   int N = 3;
   int M = 2;
 
@@ -110,7 +110,7 @@ TEST_F(OpenCLRevTests,
                                                 alpha, beta);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniform_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistUniform_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 0.7;
@@ -129,7 +129,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniform_opencl_broadcast_y) {
       uniform_lpdf_functor_propto, y_scal, alpha, beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniform_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistUniform_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -148,7 +148,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniform_opencl_broadcast_alpha) {
       uniform_lpdf_functor_propto, y, alpha_scal, beta.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniform_opencl_broadcast_beta) {
+TEST_F(OpenCLRevTests, probdistUniform_opencl_broadcast_beta) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -167,7 +167,7 @@ TEST_F(OpenCLRevTests, probdistributionsUniform_opencl_broadcast_beta) {
       uniform_lpdf_functor_propto, y, alpha.transpose().eval(), beta_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsUniform_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistUniform_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> alpha
diff --git a/test/unit/math/opencl/rev/weibull_cdf_test.cpp b/test/unit/math/opencl/rev/weibull_cdf_test.cpp
index b89b03c974f..ce596a49b9d 100644
--- a/test/unit/math/opencl/rev/weibull_cdf_test.cpp
+++ b/test/unit/math/opencl/rev/weibull_cdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullCdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistWeibullCdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto weibull_cdf_functor
         return stan::math::weibull_cdf(y, alpha, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullCdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistWeibullCdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -79,7 +79,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibullCdf_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullCdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistWeibullCdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -94,7 +94,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibullCdf_opencl_broadcast_y) {
       weibull_cdf_functor, y_scal, alpha.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullCdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistWeibullCdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibullCdf_opencl_broadcast_alpha) {
       weibull_cdf_functor, y.transpose().eval(), alpha_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullCdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistWeibullCdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -124,7 +124,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibullCdf_opencl_broadcast_sigma) {
       weibull_cdf_functor, y.transpose().eval(), alpha, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullCdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistWeibullCdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/weibull_lccdf_test.cpp b/test/unit/math/opencl/rev/weibull_lccdf_test.cpp
index 213d3fcd186..7f8fbd36f8d 100644
--- a/test/unit/math/opencl/rev/weibull_lccdf_test.cpp
+++ b/test/unit/math/opencl/rev/weibull_lccdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullLccdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistWeibullLccdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto weibull_lccdf_functor
         return stan::math::weibull_lccdf(y, alpha, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullLccdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistWeibullLccdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -79,7 +79,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibullLccdf_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullLccdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistWeibullLccdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -94,7 +94,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibullLccdf_opencl_broadcast_y) {
       weibull_lccdf_functor, y_scal, alpha.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullLccdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistWeibullLccdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibullLccdf_opencl_broadcast_alpha) {
       weibull_lccdf_functor, y.transpose().eval(), alpha_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullLccdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistWeibullLccdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -124,7 +124,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibullLccdf_opencl_broadcast_sigma) {
       weibull_lccdf_functor, y.transpose().eval(), alpha, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullLccdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistWeibullLccdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/weibull_lcdf_test.cpp b/test/unit/math/opencl/rev/weibull_lcdf_test.cpp
index aece5a342cf..c45b6c8728a 100644
--- a/test/unit/math/opencl/rev/weibull_lcdf_test.cpp
+++ b/test/unit/math/opencl/rev/weibull_lcdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullLcdf_error_checking) {
+TEST_F(OpenCLRevTests, probdistWeibullLcdf_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -61,7 +61,7 @@ auto weibull_lcdf_functor
         return stan::math::weibull_lcdf(y, alpha, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullLcdf_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistWeibullLcdf_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -79,7 +79,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibullLcdf_opencl_matches_cpu_small) {
       sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullLcdf_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistWeibullLcdf_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -94,7 +94,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibullLcdf_opencl_broadcast_y) {
       weibull_lcdf_functor, y_scal, alpha.transpose().eval(), sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullLcdf_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistWeibullLcdf_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -109,7 +109,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibullLcdf_opencl_broadcast_alpha) {
       weibull_lcdf_functor, y.transpose().eval(), alpha_scal, sigma);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullLcdf_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistWeibullLcdf_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -124,7 +124,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibullLcdf_opencl_broadcast_sigma) {
       weibull_lcdf_functor, y.transpose().eval(), alpha, sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibullLcdf_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistWeibullLcdf_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y
diff --git a/test/unit/math/opencl/rev/weibull_lpdf_test.cpp b/test/unit/math/opencl/rev/weibull_lpdf_test.cpp
index 2d7ab44a5fc..de563fe5edb 100644
--- a/test/unit/math/opencl/rev/weibull_lpdf_test.cpp
+++ b/test/unit/math/opencl/rev/weibull_lpdf_test.cpp
@@ -5,7 +5,7 @@
 #include <test/unit/math/opencl/util.hpp>
 #include <vector>
 
-TEST_F(OpenCLRevTests, probdistributionsWeibull_error_checking) {
+TEST_F(OpenCLRevTests, probdistWeibull_error_checking) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -75,7 +75,7 @@ auto weibull_lpdf_functor_propto
         return stan::math::weibull_lpdf<true>(y, alpha, sigma);
       };
 
-TEST_F(OpenCLRevTests, probdistributionsWeibull_opencl_matches_cpu_small) {
+TEST_F(OpenCLRevTests, probdistWeibull_opencl_matches_cpu_small) {
   int N = 3;
   int M = 2;
 
@@ -98,7 +98,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibull_opencl_matches_cpu_small) {
       alpha.transpose().eval(), sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibull_opencl_broadcast_y) {
+TEST_F(OpenCLRevTests, probdistWeibull_opencl_broadcast_y) {
   int N = 3;
 
   double y_scal = 12.3;
@@ -117,7 +117,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibull_opencl_broadcast_y) {
       weibull_lpdf_functor_propto, y_scal, alpha, sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibull_opencl_broadcast_alpha) {
+TEST_F(OpenCLRevTests, probdistWeibull_opencl_broadcast_alpha) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -136,7 +136,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibull_opencl_broadcast_alpha) {
       weibull_lpdf_functor_propto, y, alpha_scal, sigma.transpose().eval());
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibull_opencl_broadcast_sigma) {
+TEST_F(OpenCLRevTests, probdistWeibull_opencl_broadcast_sigma) {
   int N = 3;
 
   Eigen::VectorXd y(N);
@@ -155,7 +155,7 @@ TEST_F(OpenCLRevTests, probdistributionsWeibull_opencl_broadcast_sigma) {
       weibull_lpdf_functor_propto, y, alpha.transpose().eval(), sigma_scal);
 }
 
-TEST_F(OpenCLRevTests, probdistributionsWeibull_opencl_matches_cpu_big) {
+TEST_F(OpenCLRevTests, probdistWeibull_opencl_matches_cpu_big) {
   int N = 153;
 
   Eigen::Matrix<double, Eigen::Dynamic, 1> y