From cdad8c8951c646c85eb99b8a7c72df79d85a4cdf Mon Sep 17 00:00:00 2001
From: Yang Hau <yuanyanghau@gmail.com>
Date: Mon, 30 Oct 2023 11:23:50 +0100
Subject: [PATCH] test: Amend tests

---
 .github/workflows/github_actions.yml |   2 +-
 scripts/check-format.sh              |   2 -
 scripts/cross-test.sh                |   4 -
 tests/impl.cpp                       | 276 +++++++++++++--------------
 4 files changed, 139 insertions(+), 145 deletions(-)

diff --git a/.github/workflows/github_actions.yml b/.github/workflows/github_actions.yml
index 509f402..77e5ef0 100644
--- a/.github/workflows/github_actions.yml
+++ b/.github/workflows/github_actions.yml
@@ -40,6 +40,6 @@ jobs:
         uses: actions/checkout@v3.2.0
       - name: style check
         run: |
-            sudo apt-get install -q -y clang-format-15
+            sudo apt-get install -q -y clang-format
             sh scripts/check-format.sh
         shell: bash
diff --git a/scripts/check-format.sh b/scripts/check-format.sh
index cfb4330..b22c668 100755
--- a/scripts/check-format.sh
+++ b/scripts/check-format.sh
@@ -1,7 +1,5 @@
 #!/usr/bin/env bash
 
-. .ci/common.sh
-
 set -x
 
 for file in ${SOURCES};
diff --git a/scripts/cross-test.sh b/scripts/cross-test.sh
index aa34551..dcb1764 100755
--- a/scripts/cross-test.sh
+++ b/scripts/cross-test.sh
@@ -1,9 +1,5 @@
 #!/usr/bin/env bash
 
-. .ci/common.sh
-
-check_platform
-
 # Clang/LLVM is natively a cross-compiler.
 # TODO: Do cross-compilation using Clang
 # https://clang.llvm.org/docs/CrossCompilation.html
diff --git a/tests/impl.cpp b/tests/impl.cpp
index bffe386..45e1076 100644
--- a/tests/impl.cpp
+++ b/tests/impl.cpp
@@ -406,7 +406,7 @@ result_t test_mm_shuffle_pi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter);
 __m128i do_mm_set_epi32(int32_t x, int32_t y, int32_t z, int32_t w)
 {
     __m128i a = _mm_set_epi32(x, y, z, w);
-    validateInt32(a, w, z, y, x);
+    validate_int32(a, w, z, y, x);
     return a;
 }
 
@@ -2149,7 +2149,7 @@ result_t test_mm_loadu_si16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128i ret = _mm_loadu_si16((const void *) addr);
 
-    return validateInt16(ret, addr[0], 0, 0, 0, 0, 0, 0, 0);
+    return validate_int16(ret, addr[0], 0, 0, 0, 0, 0, 0, 0);
 #endif
 }
 
@@ -2165,7 +2165,7 @@ result_t test_mm_loadu_si64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128i ret = _mm_loadu_si64((const void *) addr);
 
-    return validateInt64(ret, addr[0], 0);
+    return validate_int64(ret, addr[0], 0);
 #endif
 }
 
@@ -2625,7 +2625,7 @@ result_t test_m_psadbw(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m64 a = load_m64(_a);
     __m64 b = load_m64(_b);
     __m64 c = _m_psadbw(a, b);
-    return validateUInt16(c, d, 0, 0, 0);
+    return validate_uint16(c, d, 0, 0, 0);
 }
 
 result_t test_m_pshufw(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -2705,7 +2705,7 @@ result_t test_mm_sad_pu8(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m64 a = load_m64(_a);
     __m64 b = load_m64(_b);
     __m64 c = _mm_sad_pu8(a, b);
-    return validateUInt16(c, d, 0, 0, 0);
+    return validate_uint16(c, d, 0, 0, 0);
 }
 
 result_t test_mm_set_flush_zero_mode(const SSE2RVV_TEST_IMPL &impl,
@@ -3064,7 +3064,7 @@ result_t test_mm_storeu_si16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     _mm_storeu_si16(&b, a);
     int16_t *_b = (int16_t *) &b;
     int16_t *_c = (int16_t *) &a;
-    return validateInt16(b, _c[0], _b[1], _b[2], _b[3], _b[4], _b[5], _b[6],
+    return validate_int16(b, _c[0], _b[1], _b[2], _b[3], _b[4], _b[5], _b[6],
                          _b[7]);
 #endif
 }
@@ -3083,7 +3083,7 @@ result_t test_mm_storeu_si64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     _mm_storeu_si64(&b, a);
     int64_t *_b = (int64_t *) &b;
     int64_t *_c = (int64_t *) &a;
-    return validateInt64(b, _c[0], _b[1]);
+    return validate_int64(b, _c[0], _b[1]);
 #endif
 }
 
@@ -3094,7 +3094,7 @@ result_t test_mm_stream_pi(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m64 p;
 
     _mm_stream_pi(&p, a);
-    return validateInt64(p, _a[0]);
+    return validate_int64(p, _a[0]);
 }
 
 result_t test_mm_stream_ps(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3286,7 +3286,7 @@ result_t test_mm_add_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i b = load_m128i(_b);
     __m128i c = _mm_add_epi64(a, b);
 
-    return validateInt64(c, d0, d1);
+    return validate_int64(c, d0, d1);
 }
 
 result_t test_mm_add_epi8(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3327,7 +3327,7 @@ result_t test_mm_add_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d b = load_m128d(_b);
     __m128d c = _mm_add_pd(a, b);
-    return validateDouble(c, d0, d1);
+    return validate_double(c, d0, d1);
 }
 
 result_t test_mm_add_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3340,7 +3340,7 @@ result_t test_mm_add_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d b = load_m128d(_b);
     __m128d c = _mm_add_sd(a, b);
-    return validateDouble(c, d0, d1);
+    return validate_double(c, d0, d1);
 }
 
 result_t test_mm_add_si64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3354,7 +3354,7 @@ result_t test_mm_add_si64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m64 b = load_m64(_b);
     __m64 c = _mm_add_si64(a, b);
 
-    return validateInt64(c, d0);
+    return validate_int64(c, d0);
 }
 
 result_t test_mm_adds_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3526,7 +3526,7 @@ result_t test_mm_and_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_and_pd(a, b);
 
-    return validateDouble(c, *((double *) &d0), *((double *) &d1));
+    return validate_double(c, *((double *) &d0), *((double *) &d1));
 }
 
 result_t test_mm_and_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3569,7 +3569,7 @@ result_t test_mm_andnot_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     const uint64_t *ib = (const uint64_t *) &b;
     uint64_t r0 = ~ia[0] & ib[0];
     uint64_t r1 = ~ia[1] & ib[1];
-    return validateUInt64(*(const __m128i *) &c, r0, r1);
+    return validate_uint64(*(const __m128i *) &c, r0, r1);
 }
 
 result_t test_mm_andnot_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3804,7 +3804,7 @@ result_t test_mm_cmpeq_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpeq_pd(a, b);
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpeq_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3818,7 +3818,7 @@ result_t test_mm_cmpeq_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpeq_sd(a, b);
 
-    return validateDouble(c, *(const double *) &d0, *(const double *) &d1);
+    return validate_double(c, *(const double *) &d0, *(const double *) &d1);
 }
 
 result_t test_mm_cmpge_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3832,7 +3832,7 @@ result_t test_mm_cmpge_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpge_pd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpge_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3846,7 +3846,7 @@ result_t test_mm_cmpge_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpge_sd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpgt_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3927,7 +3927,7 @@ result_t test_mm_cmpgt_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpgt_pd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpgt_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3941,7 +3941,7 @@ result_t test_mm_cmpgt_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpgt_sd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmple_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3955,7 +3955,7 @@ result_t test_mm_cmple_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmple_pd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmple_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -3969,7 +3969,7 @@ result_t test_mm_cmple_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmple_sd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmplt_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4050,7 +4050,7 @@ result_t test_mm_cmplt_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmplt_pd(a, b);
 
-    return validateDouble(c, *(double *) &f0, *(double *) &f1);
+    return validate_double(c, *(double *) &f0, *(double *) &f1);
 }
 
 result_t test_mm_cmplt_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4064,7 +4064,7 @@ result_t test_mm_cmplt_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmplt_sd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpneq_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4079,7 +4079,7 @@ result_t test_mm_cmpneq_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpneq_pd(a, b);
 
-    return validateDouble(c, *(double *) &f0, *(double *) &f1);
+    return validate_double(c, *(double *) &f0, *(double *) &f1);
 }
 
 result_t test_mm_cmpneq_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4094,7 +4094,7 @@ result_t test_mm_cmpneq_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpneq_sd(a, b);
 
-    return validateDouble(c, *(double *) &f0, *(double *) &f1);
+    return validate_double(c, *(double *) &f0, *(double *) &f1);
 }
 
 result_t test_mm_cmpnge_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4108,7 +4108,7 @@ result_t test_mm_cmpnge_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpnge_pd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpnge_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4122,7 +4122,7 @@ result_t test_mm_cmpnge_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpnge_sd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpngt_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4136,7 +4136,7 @@ result_t test_mm_cmpngt_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpngt_pd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpngt_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4150,7 +4150,7 @@ result_t test_mm_cmpngt_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpngt_sd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpnle_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4164,7 +4164,7 @@ result_t test_mm_cmpnle_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpnle_pd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpnle_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4178,7 +4178,7 @@ result_t test_mm_cmpnle_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpnle_sd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpnlt_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4192,7 +4192,7 @@ result_t test_mm_cmpnlt_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpnlt_pd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpnlt_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4206,7 +4206,7 @@ result_t test_mm_cmpnlt_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_cmpnlt_sd(a, b);
 
-    return validateDouble(c, *(double *) &d0, *(double *) &d1);
+    return validate_double(c, *(double *) &d0, *(double *) &d1);
 }
 
 result_t test_mm_cmpord_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4224,7 +4224,7 @@ result_t test_mm_cmpord_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128d ret = _mm_cmpord_pd(a, b);
 
-    return validateDouble(ret, result[0], result[1]);
+    return validate_double(ret, result[0], result[1]);
 }
 
 result_t test_mm_cmpord_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4238,7 +4238,7 @@ result_t test_mm_cmpord_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     double c1 = _a[1];
 
     __m128d ret = _mm_cmpord_sd(a, b);
-    return validateDouble(ret, c0, c1);
+    return validate_double(ret, c0, c1);
 }
 
 result_t test_mm_cmpunord_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4253,7 +4253,7 @@ result_t test_mm_cmpunord_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     result[1] = cmp_hasNaN(_a[1], _b[1]);
 
     __m128d ret = _mm_cmpunord_pd(a, b);
-    return validateDouble(ret, result[0], result[1]);
+    return validate_double(ret, result[0], result[1]);
 }
 
 result_t test_mm_cmpunord_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4268,7 +4268,7 @@ result_t test_mm_cmpunord_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     result[1] = _a[1];
 
     __m128d ret = _mm_cmpunord_sd(a, b);
-    return validateDouble(ret, result[0], result[1]);
+    return validate_double(ret, result[0], result[1]);
 }
 
 result_t test_mm_comieq_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4394,7 +4394,7 @@ result_t test_mm_cvtepi32_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     double trun[2] = {(double) _a[0], (double) _a[1]};
 
     __m128d ret = _mm_cvtepi32_pd(a);
-    return validateDouble(ret, trun[0], trun[1]);
+    return validate_double(ret, trun[0], trun[1]);
 }
 
 result_t test_mm_cvtepi32_ps(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4441,7 +4441,7 @@ result_t test_mm_cvtpd_epi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128i ret = _mm_cvtpd_epi32(a);
 
-    return validateInt32(ret, d[0], d[1], 0, 0);
+    return validate_int32(ret, d[0], d[1], 0, 0);
 }
 
 result_t test_mm_cvtpd_pi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4499,7 +4499,7 @@ result_t test_mm_cvtpi32_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128d ret = _mm_cvtpi32_pd(a);
 
-    return validateDouble(ret, trun[0], trun[1]);
+    return validate_double(ret, trun[0], trun[1]);
 }
 
 result_t test_mm_cvtps_epi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4547,7 +4547,7 @@ result_t test_mm_cvtps_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128d r = _mm_cvtps_pd(a);
 
-    return validateDouble(r, d0, d1);
+    return validate_double(r, d0, d1);
 }
 
 result_t test_mm_cvtsd_f64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4681,7 +4681,7 @@ result_t test_mm_cvtsi32_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d c = _mm_cvtsi32_sd(a, b);
 
-    return validateDouble(c, b, _a[1]);
+    return validate_double(c, b, _a[1]);
 }
 
 result_t test_mm_cvtsi32_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4692,7 +4692,7 @@ result_t test_mm_cvtsi32_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128i c = _mm_cvtsi32_si128(*_a);
 
-    return validateInt32(c, d, 0, 0, 0);
+    return validate_int32(c, d, 0, 0, 0);
 }
 
 result_t test_mm_cvtsi64_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4703,7 +4703,7 @@ result_t test_mm_cvtsi64_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d c = _mm_cvtsi64_sd(a, b);
 
-    return validateDouble(c, b, _a[1]);
+    return validate_double(c, b, _a[1]);
 }
 
 result_t test_mm_cvtsi64_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4714,7 +4714,7 @@ result_t test_mm_cvtsi64_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128i c = _mm_cvtsi64_si128(*_a);
 
-    return validateInt64(c, d, 0);
+    return validate_int64(c, d, 0);
 }
 
 result_t test_mm_cvtsi64x_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4737,7 +4737,7 @@ result_t test_mm_cvtss_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128 b = load_m128(_b);
     __m128d c = _mm_cvtss_sd(a, b);
-    return validateDouble(c, d0, d1);
+    return validate_double(c, d0, d1);
 }
 
 result_t test_mm_cvttpd_epi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4749,7 +4749,7 @@ result_t test_mm_cvttpd_epi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     int32_t d1 = (int32_t) (_a[1]);
 
     __m128i ret = _mm_cvttpd_epi32(a);
-    return validateInt32(ret, d0, d1, 0, 0);
+    return validate_int32(ret, d0, d1, 0, 0);
 }
 
 result_t test_mm_cvttpd_pi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4761,7 +4761,7 @@ result_t test_mm_cvttpd_pi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     int32_t d1 = (int32_t) (_a[1]);
 
     __m64 ret = _mm_cvttpd_pi32(a);
-    return validateInt32(ret, d0, d1);
+    return validate_int32(ret, d0, d1);
 }
 
 result_t test_mm_cvttps_epi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4826,7 +4826,7 @@ result_t test_mm_div_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d b = load_m128d(_b);
     __m128d c = _mm_div_pd(a, b);
-    return validateDouble(c, d0, d1);
+    return validate_double(c, d0, d1);
 }
 
 result_t test_mm_div_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4842,7 +4842,7 @@ result_t test_mm_div_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128d c = _mm_div_sd(a, b);
 
-    return validateDouble(c, d0, d1);
+    return validate_double(c, d0, d1);
 }
 
 result_t test_mm_extract_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4914,21 +4914,21 @@ result_t test_mm_load_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 {
     const double *p = (const double *) impl.test_cases_float_pointer1;
     __m128d a = _mm_load_pd(p);
-    return validateDouble(a, p[0], p[1]);
+    return validate_double(a, p[0], p[1]);
 }
 
 result_t test_mm_load_pd1(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 {
     const double *p = (const double *) impl.test_cases_float_pointer1;
     __m128d a = _mm_load_pd1(p);
-    return validateDouble(a, p[0], p[0]);
+    return validate_double(a, p[0], p[0]);
 }
 
 result_t test_mm_load_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 {
     const double *p = (const double *) impl.test_cases_float_pointer1;
     __m128d a = _mm_load_sd(p);
-    return validateDouble(a, p[0], 0);
+    return validate_double(a, p[0], 0);
 }
 
 result_t test_mm_load_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4946,7 +4946,7 @@ result_t test_mm_load1_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128d ret = _mm_load1_pd(addr);
 
-    return validateDouble(ret, addr[0], addr[0]);
+    return validate_double(ret, addr[0], addr[0]);
 }
 
 result_t test_mm_loadh_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4957,7 +4957,7 @@ result_t test_mm_loadh_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d ret = _mm_loadh_pd(a, addr);
 
-    return validateDouble(ret, _a[0], addr[0]);
+    return validate_double(ret, _a[0], addr[0]);
 }
 
 result_t test_mm_loadl_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4966,7 +4966,7 @@ result_t test_mm_loadl_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128i ret = _mm_loadl_epi64((const __m128i *) addr);
 
-    return validateInt64(ret, addr[0], 0);
+    return validate_int64(ret, addr[0], 0);
 }
 
 result_t test_mm_loadl_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4977,7 +4977,7 @@ result_t test_mm_loadl_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d ret = _mm_loadl_pd(a, addr);
 
-    return validateDouble(ret, addr[0], _a[1]);
+    return validate_double(ret, addr[0], _a[1]);
 }
 
 result_t test_mm_loadr_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -4986,14 +4986,14 @@ result_t test_mm_loadr_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128d ret = _mm_loadr_pd(addr);
 
-    return validateDouble(ret, addr[1], addr[0]);
+    return validate_double(ret, addr[1], addr[0]);
 }
 
 result_t test_mm_loadu_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 {
     const double *p = (const double *) impl.test_cases_float_pointer1;
     __m128d a = _mm_loadu_pd(p);
-    return validateDouble(a, p[0], p[1]);
+    return validate_double(a, p[0], p[1]);
 }
 
 result_t test_mm_loadu_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5015,7 +5015,7 @@ result_t test_mm_loadu_si32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128i ret = _mm_loadu_si32((const void *) addr);
 
-    return validateInt32(ret, addr[0], 0, 0, 0);
+    return validate_int32(ret, addr[0], 0, 0, 0);
 #endif
 }
 
@@ -5140,7 +5140,7 @@ result_t test_mm_max_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_max_pd(a, b);
 
-    return validateDouble(c, f0, f1);
+    return validate_double(c, f0, f1);
 }
 
 result_t test_mm_max_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5154,7 +5154,7 @@ result_t test_mm_max_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_max_sd(a, b);
 
-    return validateDouble(c, d0, d1);
+    return validate_double(c, d0, d1);
 }
 
 result_t test_mm_mfence(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5238,7 +5238,7 @@ result_t test_mm_min_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
 
     __m128d c = _mm_min_pd(a, b);
-    return validateDouble(c, f0, f1);
+    return validate_double(c, f0, f1);
 }
 
 result_t test_mm_min_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5252,7 +5252,7 @@ result_t test_mm_min_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_min_sd(a, b);
 
-    return validateDouble(c, d0, d1);
+    return validate_double(c, d0, d1);
 }
 
 result_t test_mm_move_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5265,7 +5265,7 @@ result_t test_mm_move_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     __m128i c = _mm_move_epi64(a);
 
-    return validateInt64(c, d0, d1);
+    return validate_int64(c, d0, d1);
 }
 
 result_t test_mm_move_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5280,7 +5280,7 @@ result_t test_mm_move_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     result[1] = _a[1];
 
     __m128d ret = _mm_move_sd(a, b);
-    return validateDouble(ret, result[0], result[1]);
+    return validate_double(ret, result[0], result[1]);
 }
 
 result_t test_mm_movemask_epi8(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5325,7 +5325,7 @@ result_t test_mm_movepi64_pi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     __m64 c = _mm_movepi64_pi64(a);
 
-    return validateInt64(c, d0);
+    return validate_int64(c, d0);
 }
 
 result_t test_mm_movpi64_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5337,7 +5337,7 @@ result_t test_mm_movpi64_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m64 a = load_m64(_a);
     __m128i c = _mm_movpi64_epi64(a);
 
-    return validateInt64(c, d0, 0);
+    return validate_int64(c, d0, 0);
 }
 
 result_t test_mm_mul_epu32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5350,7 +5350,7 @@ result_t test_mm_mul_epu32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = _mm_loadu_si128((const __m128i *) _a);
     __m128i b = _mm_loadu_si128((const __m128i *) _b);
     __m128i r = _mm_mul_epu32(a, b);
-    return validateUInt64(r, dx, dy);
+    return validate_uint64(r, dx, dy);
 }
 
 result_t test_mm_mul_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5363,7 +5363,7 @@ result_t test_mm_mul_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = _mm_load_pd(_a);
     __m128d b = _mm_load_pd(_b);
     __m128d c = _mm_mul_pd(a, b);
-    return validateDouble(c, d0, d1);
+    return validate_double(c, d0, d1);
 }
 
 result_t test_mm_mul_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5376,7 +5376,7 @@ result_t test_mm_mul_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d b = load_m128d(_b);
     __m128d c = _mm_mul_sd(a, b);
-    return validateDouble(c, dx, dy);
+    return validate_double(c, dx, dy);
 }
 
 result_t test_mm_mul_su32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5390,7 +5390,7 @@ result_t test_mm_mul_su32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m64 b = load_m64(_b);
     __m64 r = _mm_mul_su32(a, b);
 
-    return validateUInt64(r, u);
+    return validate_uint64(r, u);
 }
 
 result_t test_mm_mulhi_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5457,7 +5457,7 @@ result_t test_mm_or_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_or_pd(a, b);
 
-    return validateDouble(c, *((double *) &d0), *((double *) &d1));
+    return validate_double(c, *((double *) &d0), *((double *) &d1));
 }
 
 result_t test_mm_or_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5602,7 +5602,7 @@ result_t test_mm_sad_epu8(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     const __m128i a = load_m128i(_a);
     const __m128i b = load_m128i(_b);
     __m128i c = _mm_sad_epu8(a, b);
-    return validateUInt16(c, d0, 0, 0, 0, d1, 0, 0, 0);
+    return validate_uint16(c, d0, 0, 0, 0, d1, 0, 0, 0);
 }
 
 result_t test_mm_set_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5639,7 +5639,7 @@ result_t test_mm_set_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128i ret = _mm_set_epi64(load_m64(&_a[1]), load_m64(&_a[0]));
 
-    return validateInt64(ret, _a[0], _a[1]);
+    return validate_int64(ret, _a[0], _a[1]);
 }
 
 result_t test_mm_set_epi64x(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5648,7 +5648,7 @@ result_t test_mm_set_epi64x(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128i ret = _mm_set_epi64x(_a[1], _a[0]);
 
-    return validateInt64(ret, _a[0], _a[1]);
+    return validate_int64(ret, _a[0], _a[1]);
 }
 
 result_t test_mm_set_epi8(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5684,7 +5684,7 @@ result_t test_mm_set_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     double x = p[0];
     double y = p[1];
     __m128d a = _mm_set_pd(x, y);
-    return validateDouble(a, y, x);
+    return validate_double(a, y, x);
 }
 
 result_t test_mm_set_pd1(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5693,7 +5693,7 @@ result_t test_mm_set_pd1(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128d a = _mm_set_pd1(_a);
 
-    return validateDouble(a, _a, _a);
+    return validate_double(a, _a, _a);
 }
 
 result_t test_mm_set_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5704,7 +5704,7 @@ result_t test_mm_set_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     double f1 = 0.0;
 
     __m128d a = _mm_set_sd(_a[0]);
-    return validateDouble(a, f0, f1);
+    return validate_double(a, f0, f1);
 }
 
 result_t test_mm_set1_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5713,14 +5713,14 @@ result_t test_mm_set1_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     int16_t d0 = _a[0];
 
     __m128i c = _mm_set1_epi16(d0);
-    return validateInt16(c, d0, d0, d0, d0, d0, d0, d0, d0);
+    return validate_int16(c, d0, d0, d0, d0, d0, d0, d0, d0);
 }
 
 result_t test_mm_set1_epi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 {
     int32_t x = impl.test_cases_ints[iter];
     __m128i a = _mm_set1_epi32(x);
-    return validateInt32(a, x, x, x, x);
+    return validate_int32(a, x, x, x, x);
 }
 
 result_t test_mm_set1_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5729,7 +5729,7 @@ result_t test_mm_set1_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128i ret = _mm_set1_epi64(load_m64(&_a[0]));
 
-    return validateInt64(ret, _a[0], _a[0]);
+    return validate_int64(ret, _a[0], _a[0]);
 }
 
 result_t test_mm_set1_epi64x(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5738,7 +5738,7 @@ result_t test_mm_set1_epi64x(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128i ret = _mm_set1_epi64x(_a[0]);
 
-    return validateInt64(ret, _a[0], _a[0]);
+    return validate_int64(ret, _a[0], _a[0]);
 }
 
 result_t test_mm_set1_epi8(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5746,7 +5746,7 @@ result_t test_mm_set1_epi8(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     const int8_t *_a = (const int8_t *) impl.test_cases_int_pointer1;
     int8_t d0 = _a[0];
     __m128i c = _mm_set1_epi8(d0);
-    return validateInt8(c, d0, d0, d0, d0, d0, d0, d0, d0, d0, d0, d0, d0, d0,
+    return validate_int8(c, d0, d0, d0, d0, d0, d0, d0, d0, d0, d0, d0, d0, d0,
                         d0, d0, d0);
 }
 
@@ -5755,7 +5755,7 @@ result_t test_mm_set1_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     const double *_a = (const double *) impl.test_cases_float_pointer1;
     double d0 = _a[0];
     __m128d c = _mm_set1_pd(d0);
-    return validateDouble(c, d0, d0);
+    return validate_double(c, d0, d0);
 }
 
 result_t test_mm_setr_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5779,7 +5779,7 @@ result_t test_mm_setr_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 {
     const int64_t *_a = (const int64_t *) impl.test_cases_int_pointer1;
     __m128i c = _mm_setr_epi64(load_m64(&_a[0]), load_m64(&_a[1]));
-    return validateInt64(c, _a[0], _a[1]);
+    return validate_int64(c, _a[0], _a[1]);
 }
 
 result_t test_mm_setr_epi8(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5802,19 +5802,19 @@ result_t test_mm_setr_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128d a = _mm_setr_pd(x, y);
 
-    return validateDouble(a, x, y);
+    return validate_double(a, x, y);
 }
 
 result_t test_mm_setzero_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 {
     __m128d a = _mm_setzero_pd();
-    return validateDouble(a, 0, 0);
+    return validate_double(a, 0, 0);
 }
 
 result_t test_mm_setzero_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 {
     __m128i a = _mm_setzero_si128();
-    return validateInt32(a, 0, 0, 0, 0);
+    return validate_int32(a, 0, 0, 0, 0);
 }
 
 result_t test_mm_shuffle_epi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -5851,7 +5851,7 @@ result_t test_mm_shuffle_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
                                            \
     double d0##IDX = _a[IDX & 0x1];        \
     double d1##IDX = _b[(IDX & 0x2) >> 1]; \
-    CHECK_RESULT(validateDouble(c, d0##IDX, d1##IDX))
+    CHECK_RESULT(validate_double(c, d0##IDX, d1##IDX))
 
     IMM_4_ITER
 #undef TEST_IMPL
@@ -5972,7 +5972,7 @@ result_t test_mm_sll_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     b = _mm_set1_epi64x(IDX);                          \
     c = _mm_sll_epi64(a, b);                           \
                                                        \
-    CHECK_RESULT(validateInt64(c, d0##IDX, d1##IDX))
+    CHECK_RESULT(validate_int64(c, d0##IDX, d1##IDX))
 
     IMM_64_ITER
 #undef TEST_IMPL
@@ -6041,7 +6041,7 @@ result_t test_mm_slli_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128i a = load_m128i(_a);
     __m128i c = _mm_slli_epi64(a, count);
-    return validateInt64(c, d0, d1);
+    return validate_int64(c, d0, d1);
 }
 
 result_t test_mm_slli_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -6234,7 +6234,7 @@ result_t test_mm_srl_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i b = _mm_set1_epi64x(count);
     __m128i c = _mm_srl_epi64(a, b);
 
-    return validateInt64(c, d0, d1);
+    return validate_int64(c, d0, d1);
 }
 
 result_t test_mm_srli_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -6286,7 +6286,7 @@ result_t test_mm_srli_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     __m128i c = _mm_srli_epi64(a, count);
 
-    return validateInt64(c, d0, d1);
+    return validate_int64(c, d0, d1);
 }
 
 result_t test_mm_srli_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -6424,7 +6424,7 @@ result_t test_mm_storer_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     _mm_storer_pd(mem, a);
 
     __m128d res = load_m128d(mem);
-    return validateDouble(res, p[1], p[0]);
+    return validate_double(res, p[1], p[0]);
 }
 
 result_t test_mm_storeu_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -6463,7 +6463,7 @@ result_t test_mm_storeu_si32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     _mm_storeu_si32(&b, a);
     int32_t *_b = (int32_t *) &b;
-    return validateInt32(b, _a[0], _b[1], _b[2], _b[3]);
+    return validate_int32(b, _a[0], _b[1], _b[2], _b[3]);
 #endif
 }
 
@@ -6475,7 +6475,7 @@ result_t test_mm_stream_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     _mm_stream_pd(p, a);
 
-    return validateDouble(a, p[0], p[1]);
+    return validate_double(a, p[0], p[1]);
 }
 
 result_t test_mm_stream_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -6555,7 +6555,7 @@ result_t test_mm_sub_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     __m128i b = load_m128i(_b);
     __m128i c = _mm_sub_epi64(a, b);
-    return validateInt64(c, d0, d1);
+    return validate_int64(c, d0, d1);
 }
 
 result_t test_mm_sub_epi8(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -6596,7 +6596,7 @@ result_t test_mm_sub_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d b = load_m128d(_b);
     __m128d c = _mm_sub_pd(a, b);
-    return validateDouble(c, d0, d1);
+    return validate_double(c, d0, d1);
 }
 
 result_t test_mm_sub_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -6609,7 +6609,7 @@ result_t test_mm_sub_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d b = load_m128d(_b);
     __m128d c = _mm_sub_sd(a, b);
-    return validateDouble(c, d0, d1);
+    return validate_double(c, d0, d1);
 }
 
 result_t test_mm_sub_si64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -6623,7 +6623,7 @@ result_t test_mm_sub_si64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m64 b = load_m64(_b);
     __m64 c = _mm_sub_si64(a, b);
 
-    return validateInt64(c, d);
+    return validate_int64(c, d);
 }
 
 result_t test_mm_subs_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -6807,14 +6807,14 @@ result_t test_mm_undefined_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 {
     __m128d a = _mm_undefined_pd();
     a = _mm_xor_pd(a, a);
-    return validateDouble(a, 0, 0);
+    return validate_double(a, 0, 0);
 }
 
 result_t test_mm_undefined_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 {
     __m128i a = _mm_undefined_si128();
     a = _mm_xor_si128(a, a);
-    return validateInt64(a, 0, 0);
+    return validate_int64(a, 0, 0);
 }
 
 result_t test_mm_unpackhi_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -6869,7 +6869,7 @@ result_t test_mm_unpackhi_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i b = load_m128i(_b);
     __m128i ret = _mm_unpackhi_epi64(a, b);
 
-    return validateInt64(ret, i0, i1);
+    return validate_int64(ret, i0, i1);
 }
 
 result_t test_mm_unpackhi_epi8(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -6911,7 +6911,7 @@ result_t test_mm_unpackhi_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d ret = _mm_unpackhi_pd(a, b);
 
-    return validateDouble(ret, _a[1], _b[1]);
+    return validate_double(ret, _a[1], _b[1]);
 }
 
 result_t test_mm_unpacklo_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -6966,7 +6966,7 @@ result_t test_mm_unpacklo_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i b = load_m128i(_b);
     __m128i ret = _mm_unpacklo_epi64(a, b);
 
-    return validateInt64(ret, i0, i1);
+    return validate_int64(ret, i0, i1);
 }
 
 result_t test_mm_unpacklo_epi8(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -7008,7 +7008,7 @@ result_t test_mm_unpacklo_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d ret = _mm_unpacklo_pd(a, b);
 
-    return validateDouble(ret, _a[0], _b[0]);
+    return validate_double(ret, _a[0], _b[0]);
 }
 
 result_t test_mm_xor_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -7023,7 +7023,7 @@ result_t test_mm_xor_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_xor_pd(a, b);
 
-    return validateDouble(c, *((double *) &d0), *((double *) &d1));
+    return validate_double(c, *((double *) &d0), *((double *) &d1));
 }
 
 result_t test_mm_xor_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -7038,7 +7038,7 @@ result_t test_mm_xor_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i b = load_m128i(_b);
     __m128i c = _mm_xor_si128(a, b);
 
-    return validateInt64(c, d0, d1);
+    return validate_int64(c, d0, d1);
 }
 
 /* SSE3 */
@@ -7054,7 +7054,7 @@ result_t test_mm_addsub_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_addsub_pd(a, b);
 
-    return validateDouble(c, d0, d1);
+    return validate_double(c, d0, d1);
 }
 
 result_t test_mm_addsub_ps(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -7087,7 +7087,7 @@ result_t test_mm_hadd_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_hadd_pd(a, b);
 
-    return validateDouble(c, f0, f1);
+    return validate_double(c, f0, f1);
 }
 
 result_t test_mm_hadd_ps(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -7120,7 +7120,7 @@ result_t test_mm_hsub_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d c = _mm_hsub_pd(a, b);
 
-    return validateDouble(c, f0, f1);
+    return validate_double(c, f0, f1);
 }
 
 result_t test_mm_hsub_ps(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -7152,7 +7152,7 @@ result_t test_mm_loaddup_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128d ret = _mm_loaddup_pd(addr);
 
-    return validateDouble(ret, addr[0], addr[0]);
+    return validate_double(ret, addr[0], addr[0]);
 }
 
 result_t test_mm_movedup_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -7161,7 +7161,7 @@ result_t test_mm_movedup_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(p);
     __m128d b = _mm_movedup_pd(a);
 
-    return validateDouble(b, p[0], p[0]);
+    return validate_double(b, p[0], p[0]);
 }
 
 result_t test_mm_movehdup_ps(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -7937,7 +7937,7 @@ result_t test_mm_blend_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     a = load_m128d(_a);           \
     b = load_m128d(_b);           \
     c = _mm_blend_pd(a, b, IDX);  \
-    CHECK_RESULT(validateDouble(c, _c##IDX[0], _c##IDX[1]))
+    CHECK_RESULT(validate_double(c, _c##IDX[0], _c##IDX[1]))
 
     IMM_4_ITER
 #undef TEST_IMPL
@@ -8027,7 +8027,7 @@ result_t test_mm_blendv_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
 
     __m128d c = _mm_blendv_pd(a, b, mask);
 
-    return validateDouble(c, _c[0], _c[1]);
+    return validate_double(c, _c[0], _c[1]);
 }
 
 result_t test_mm_blendv_ps(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -8068,7 +8068,7 @@ result_t test_mm_ceil_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d ret = _mm_ceil_pd(a);
 
-    return validateDouble(ret, dx, dy);
+    return validate_double(ret, dx, dy);
 }
 
 result_t test_mm_ceil_ps(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -8096,7 +8096,7 @@ result_t test_mm_ceil_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d ret = _mm_ceil_sd(a, b);
 
-    return validateDouble(ret, dx, dy);
+    return validate_double(ret, dx, dy);
 }
 
 result_t test_mm_ceil_ss(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -8123,7 +8123,7 @@ result_t test_mm_cmpeq_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     __m128i b = load_m128i(_b);
     __m128i c = _mm_cmpeq_epi64(a, b);
-    return validateInt64(c, d0, d1);
+    return validate_int64(c, d0, d1);
 }
 
 result_t test_mm_cvtepi16_epi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -8152,7 +8152,7 @@ result_t test_mm_cvtepi16_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     __m128i ret = _mm_cvtepi16_epi64(a);
 
-    return validateInt64(ret, i0, i1);
+    return validate_int64(ret, i0, i1);
 }
 
 result_t test_mm_cvtepi32_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -8165,7 +8165,7 @@ result_t test_mm_cvtepi32_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     __m128i ret = _mm_cvtepi32_epi64(a);
 
-    return validateInt64(ret, i0, i1);
+    return validate_int64(ret, i0, i1);
 }
 
 result_t test_mm_cvtepi8_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -8214,7 +8214,7 @@ result_t test_mm_cvtepi8_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     __m128i ret = _mm_cvtepi8_epi64(a);
 
-    return validateInt64(ret, i0, i1);
+    return validate_int64(ret, i0, i1);
 }
 
 result_t test_mm_cvtepu16_epi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -8243,7 +8243,7 @@ result_t test_mm_cvtepu16_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     __m128i ret = _mm_cvtepu16_epi64(a);
 
-    return validateInt64(ret, i0, i1);
+    return validate_int64(ret, i0, i1);
 }
 
 result_t test_mm_cvtepu32_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -8256,7 +8256,7 @@ result_t test_mm_cvtepu32_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     __m128i ret = _mm_cvtepu32_epi64(a);
 
-    return validateInt64(ret, i0, i1);
+    return validate_int64(ret, i0, i1);
 }
 
 result_t test_mm_cvtepu8_epi16(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -8305,7 +8305,7 @@ result_t test_mm_cvtepu8_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     __m128i ret = _mm_cvtepu8_epi64(a);
 
-    return validateInt64(ret, i0, i1);
+    return validate_int64(ret, i0, i1);
 }
 
 #define MM_DP_PD_TEST_CASE_WITH(imm8)                                       \
@@ -8322,7 +8322,7 @@ result_t test_mm_cvtepu8_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
         __m128d a = load_m128d(_a);                                         \
         __m128d b = load_m128d(_b);                                         \
         __m128d ret = _mm_dp_pd(a, b, imm);                                 \
-        if (validateDouble(ret, d[0], d[1]) != TEST_SUCCESS)                \
+        if (validate_double(ret, d[0], d[1]) != TEST_SUCCESS)                \
             return TEST_FAIL;                                               \
     } while (0)
 
@@ -8456,7 +8456,7 @@ result_t test_mm_floor_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d a = load_m128d(_a);
     __m128d ret = _mm_floor_pd(a);
 
-    return validateDouble(ret, dx, dy);
+    return validate_double(ret, dx, dy);
 }
 
 result_t test_mm_floor_ps(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -8484,7 +8484,7 @@ result_t test_mm_floor_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128d b = load_m128d(_b);
     __m128d ret = _mm_floor_sd(a, b);
 
-    return validateDouble(ret, dx, dy);
+    return validate_double(ret, dx, dy);
 }
 
 result_t test_mm_floor_ss(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -8536,7 +8536,7 @@ result_t test_mm_insert_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     d[IDX] = insert;                      \
     a = load_m128i(_a);                   \
     b = _mm_insert_epi64(a, insert, IDX); \
-    CHECK_RESULT(validateInt64(b, d[0], d[1]));
+    CHECK_RESULT(validate_int64(b, d[0], d[1]));
 
     IMM_2_ITER
 #undef TEST_IMPL
@@ -8822,7 +8822,7 @@ result_t test_mm_mul_epi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i b = _mm_loadu_si128((const __m128i *) _b);
     __m128i r = _mm_mul_epi32(a, b);
 
-    return validateInt64(r, dx, dy);
+    return validate_int64(r, dx, dy);
 }
 
 result_t test_mm_mullo_epi32(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -8934,7 +8934,7 @@ result_t test_mm_round_pd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
         break;
     }
 
-    return validateDouble(ret, d[0], d[1]);
+    return validate_double(ret, d[0], d[1]);
 }
 
 result_t test_mm_round_ps(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -9075,7 +9075,7 @@ result_t test_mm_round_sd(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
         break;
     }
 
-    return validateDouble(ret, d[0], d[1]);
+    return validate_double(ret, d[0], d[1]);
 }
 
 result_t test_mm_round_ss(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
@@ -10574,7 +10574,7 @@ result_t test_mm_cmpgt_epi64(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i b = load_m128i(_b);
     __m128i iret = _mm_cmpgt_epi64(a, b);
 
-    return validateInt64(iret, result[0], result[1]);
+    return validate_int64(iret, result[0], result[1]);
 }
 
 #define IS_CMPISTRI 1
@@ -11677,19 +11677,19 @@ result_t test_mm_clmulepi64_si128(const SSE2RVV_TEST_IMPL &impl, uint32_t iter)
     __m128i a = load_m128i(_a);
     __m128i b = load_m128i(_b);
     auto result = clmul_64(_a[0], _b[0]);
-    if (!validateUInt64(_mm_clmulepi64_si128(a, b, 0x00), result.first,
+    if (!validate_uint64(_mm_clmulepi64_si128(a, b, 0x00), result.first,
                         result.second))
         return TEST_FAIL;
     result = clmul_64(_a[1], _b[0]);
-    if (!validateUInt64(_mm_clmulepi64_si128(a, b, 0x01), result.first,
+    if (!validate_uint64(_mm_clmulepi64_si128(a, b, 0x01), result.first,
                         result.second))
         return TEST_FAIL;
     result = clmul_64(_a[0], _b[1]);
-    if (!validateUInt64(_mm_clmulepi64_si128(a, b, 0x10), result.first,
+    if (!validate_uint64(_mm_clmulepi64_si128(a, b, 0x10), result.first,
                         result.second))
         return TEST_FAIL;
     result = clmul_64(_a[1], _b[1]);
-    if (!validateUInt64(_mm_clmulepi64_si128(a, b, 0x11), result.first,
+    if (!validate_uint64(_mm_clmulepi64_si128(a, b, 0x11), result.first,
                         result.second))
         return TEST_FAIL;
     return TEST_SUCCESS;