diff --git a/modules/dnn/test/test_fast_gemm.cpp b/modules/dnn/test/test_fast_gemm.cpp
index 23de8dd0bf..e245389e57 100644
--- a/modules/dnn/test/test_fast_gemm.cpp
+++ b/modules/dnn/test/test_fast_gemm.cpp
@@ -30,56 +30,48 @@ static Mat referenceMatMul(const Mat& A, const Mat& B, bool trans_a, float alpha
     return expected;
 }
 
-// Exercises the fastGemmThin path (constant-B MatMul): M covers every register
+// Exercises the fastGemmThin path (constant-B MatMul). M covers every register
 // block width and the multi-block remainder, N covers full strips and partial
 // column tails for any VLEN <= 512.
-TEST(DNN_FastGemmThin, MatMulAccuracy)
+typedef testing::TestWithParam<tuple<int, int, int, int, float>> DNN_FastGemmThin;
+
+TEST_P(DNN_FastGemmThin, MatMulAccuracy)
 {
-    static const int m_values[] = { 1, 2, 3, 4, 5 };
-    static const int k_values[] = { 1, 3, 4, 7, 16, 64 };
-    static const int n_values[] = { 16, 19, 64, 67, 80, 83 };
-    static const float alpha_values[] = { 1.f, -0.5f };
+    int M = get<0>(GetParam()), N = get<1>(GetParam()), K = get<2>(GetParam());
+    int trans_a = get<3>(GetParam());
+    float alpha = get<4>(GetParam());
 
     RNG rng(0x5EED);
-    for (int M : m_values)
-    {
-        for (int N : n_values)
-        {
-            for (int K : k_values)
-            {
-                Mat B(K, N, CV_32F);
-                rng.fill(B, RNG::UNIFORM, -1.f, 1.f);
+    Mat B(K, N, CV_32F);            rng.fill(B, RNG::UNIFORM, -1.f, 1.f);
+    Mat A(trans_a ? K : M, trans_a ? M : K, CV_32F);
+    rng.fill(A, RNG::UNIFORM, -1.f, 1.f);
 
-                for (int trans_a = 0; trans_a <= 1; trans_a++)
-                {
-                    Mat A(trans_a ? K : M, trans_a ? M : K, CV_32F);
-                    rng.fill(A, RNG::UNIFORM, -1.f, 1.f);
+    LayerParams lp;
+    lp.type = "MatMul";
+    lp.name = "thin_matmul";
+    lp.set("transA", trans_a != 0);
+    lp.set("transB", false);
+    lp.set("alpha", alpha);
+    lp.blobs.push_back(B);
 
-                    for (float alpha : alpha_values)
-                    {
-                        LayerParams lp;
-                        lp.type = "MatMul";
-                        lp.name = "thin_matmul";
-                        lp.set("transA", trans_a != 0);
-                        lp.set("transB", false);
-                        lp.set("alpha", alpha);
-                        lp.blobs.push_back(B);
+    Net net;
+    net.addLayerToPrev(lp.name, lp.type, lp);
+    net.setInputsNames(std::vector<String>{ "A" });
+    net.setInput(A, "A");
+    Mat actual = net.forward();
+    Mat expected = referenceMatMul(A, B, trans_a != 0, alpha);
 
-                        Net net;
-                        net.addLayerToPrev(lp.name, lp.type, lp);
-                        net.setInputsNames(std::vector<String>{ "A" });
-                        net.setInput(A, "A");
-                        Mat actual = net.forward();
-                        Mat expected = referenceMatMul(A, B, trans_a != 0, alpha);
-
-                        EXPECT_LE(cv::norm(expected, actual, NORM_INF), 2e-5f * std::max(K, 1))
-                            << "M=" << M << ", N=" << N << ", K=" << K
-                            << ", trans_a=" << trans_a << ", alpha=" << alpha;
-                    }
-                }
-            }
-        }
-    }
+    EXPECT_LE(cv::norm(expected, actual, NORM_INF), 2e-5f * std::max(K, 1))
+        << "M=" << M << ", N=" << N << ", K=" << K
+        << ", trans_a=" << trans_a << ", alpha=" << alpha;
 }
 
+INSTANTIATE_TEST_CASE_P(/*nothing*/, DNN_FastGemmThin, Combine(
+    Values(1, 2, 3, 4, 5),
+    Values(16, 19, 64, 67, 80, 83),
+    Values(1, 3, 4, 7, 16, 64),
+    Values(0, 1),
+    Values(1.f, -0.5f)
+));
+
 }} // namespace