test/**.cc: use using instead of typedef

created with clang-tidy --fix --checks=-*,modernize-use-using

This change required some clean up using clang-tidy 19.1.7; 'using Name
= enum/struct {' instances were corrected and parameter names were
restored to function pointer parameter lists.

Change-Id: Ia1793b2de3ff46a46f6b81b3182dbc6e52ed42ee

Author: jzern

test/add_noise_test.cc

@@ -24,11 +24,11 @@ namespace {
 
 static const int kNoiseSize = 3072;
 
-typedef void (*AddNoiseFunc)(uint8_t *start, const int8_t *noise,
-                             int blackclamp, int whiteclamp, int width,
-                             int height, int pitch);
+using AddNoiseFunc = void (*)(uint8_t *start, const int8_t *noise,
+                              int blackclamp, int whiteclamp, int width,
+                              int height, int pitch);
 
-typedef std::tuple<double, AddNoiseFunc> AddNoiseTestFPParam;
+using AddNoiseTestFPParam = std::tuple<double, AddNoiseFunc>;
 
 class AddNoiseTest : public ::testing::Test,
                      public ::testing::WithParamInterface<AddNoiseTestFPParam> {

test/avg_test.cc

@@ -94,9 +94,9 @@ class AverageTestBase : public ::testing::Test {
 
   ACMRandom rnd_;
 };
-typedef unsigned int (*AverageFunction)(const uint8_t *s, int pitch);
+using AverageFunction = unsigned int (*)(const uint8_t *s, int pitch);
 
-typedef std::tuple<int, int, int, int, AverageFunction> AvgFunc;
+using AvgFunc = std::tuple<int, int, int, int, AverageFunction>;
 
 class AverageTest : public AverageTestBase<uint8_t>,
                     public ::testing::WithParamInterface<AvgFunc> {
@@ -153,10 +153,10 @@ class AverageTestHBD : public AverageTestBase<uint16_t>,
 #endif  // CONFIG_VP9_HIGHBITDEPTH
 
 #if HAVE_NEON || HAVE_SSE2 || HAVE_MSA
-typedef void (*IntProRowFunc)(int16_t hbuf[16], uint8_t const *ref,
-                              const int ref_stride, const int height);
+using IntProRowFunc = void (*)(int16_t hbuf[16], uint8_t const *ref,
+                               const int ref_stride, const int height);
 
-typedef std::tuple<int, IntProRowFunc, IntProRowFunc> IntProRowParam;
+using IntProRowParam = std::tuple<int, IntProRowFunc, IntProRowFunc>;
 
 class IntProRowTest : public AverageTestBase<uint8_t>,
                       public ::testing::WithParamInterface<IntProRowParam> {
@@ -205,9 +205,9 @@ class IntProRowTest : public AverageTestBase<uint8_t>,
 };
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(IntProRowTest);
 
-typedef int16_t (*IntProColFunc)(uint8_t const *ref, const int width);
+using IntProColFunc = int16_t (*)(uint8_t const *ref, const int width);
 
-typedef std::tuple<int, IntProColFunc, IntProColFunc> IntProColParam;
+using IntProColParam = std::tuple<int, IntProColFunc, IntProColFunc>;
 
 class IntProColTest : public AverageTestBase<uint8_t>,
                       public ::testing::WithParamInterface<IntProColParam> {
@@ -233,8 +233,8 @@ class IntProColTest : public AverageTestBase<uint8_t>,
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(IntProColTest);
 #endif  // HAVE_NEON || HAVE_SSE2 || HAVE_MSA
 
-typedef int (*SatdFunc)(const tran_low_t *coeffs, int length);
-typedef std::tuple<int, SatdFunc> SatdTestParam;
+using SatdFunc = int (*)(const tran_low_t *coeffs, int length);
+using SatdTestParam = std::tuple<int, SatdFunc>;
 
 class SatdTest : public ::testing::Test,
                  public ::testing::WithParamInterface<SatdTestParam> {
@@ -285,9 +285,9 @@ class SatdLowbdTest : public SatdTest {
   }
 };
 
-typedef int64_t (*BlockErrorFunc)(const tran_low_t *coeff,
-                                  const tran_low_t *dqcoeff, int block_size);
-typedef std::tuple<int, BlockErrorFunc> BlockErrorTestFPParam;
+using BlockErrorFunc = int64_t (*)(const tran_low_t *coeff,
+                                   const tran_low_t *dqcoeff, int block_size);
+using BlockErrorTestFPParam = std::tuple<int, BlockErrorFunc>;
 
 class BlockErrorTestFP
     : public ::testing::Test,

test/blockiness_test.cc

@@ -139,7 +139,7 @@ class BlockinessTestBase : public ::testing::Test {
 };
 
 #if CONFIG_VP9_ENCODER
-typedef std::tuple<int, int> BlockinessParam;
+using BlockinessParam = std::tuple<int, int>;
 class BlockinessVP9Test
     : public BlockinessTestBase,
       public ::testing::WithParamInterface<BlockinessParam> {

test/consistency_test.cc

@@ -128,7 +128,7 @@ class ConsistencyTestBase : public ::testing::Test {
 };
 
 #if CONFIG_VP9_ENCODER
-typedef std::tuple<int, int> ConsistencyParam;
+using ConsistencyParam = std::tuple<int, int>;
 class ConsistencyVP9Test
     : public ConsistencyTestBase,
       public ::testing::WithParamInterface<ConsistencyParam> {

test/convolve_test.cc

@@ -32,24 +32,24 @@ namespace {
 
 static const unsigned int kMaxDimension = 64;
 
-typedef void (*ConvolveFunc)(const uint8_t *src, ptrdiff_t src_stride,
-                             uint8_t *dst, ptrdiff_t dst_stride,
-                             const InterpKernel *filter, int x0_q4,
-                             int x_step_q4, int y0_q4, int y_step_q4, int w,
-                             int h);
+using ConvolveFunc = void (*)(const uint8_t *src, ptrdiff_t src_stride,
+                              uint8_t *dst, ptrdiff_t dst_stride,
+                              const InterpKernel *filter, int x0_q4,
+                              int x_step_q4, int y0_q4, int y_step_q4, int w,
+                              int h);
 #if !CONFIG_REALTIME_ONLY && CONFIG_VP9_ENCODER
-typedef void (*ConvolveFunc12Tap)(const uint8_t *src, ptrdiff_t src_stride,
-                                  uint8_t *dst, ptrdiff_t dst_stride,
-                                  const InterpKernel12 *filter, int x0_q4,
-                                  int x_step_q4, int y0_q4, int y_step_q4,
-                                  int w, int h);
+using ConvolveFunc12Tap = void (*)(const uint8_t *src, ptrdiff_t src_stride,
+                                   uint8_t *dst, ptrdiff_t dst_stride,
+                                   const InterpKernel12 *filter, int x0_q4,
+                                   int x_step_q4, int y0_q4, int y_step_q4,
+                                   int w, int h);
 #endif
 
-typedef void (*WrapperFilterBlock2d8Func)(
-    const uint8_t *src_ptr, const unsigned int src_stride,
-    const int16_t *hfilter, const int16_t *vfilter, uint8_t *dst_ptr,
-    unsigned int dst_stride, unsigned int output_width,
-    unsigned int output_height, int use_highbd);
+using WrapperFilterBlock2d8Func =
+    void (*)(const uint8_t *src_ptr, const unsigned int src_stride,
+             const int16_t *hfilter, const int16_t *vfilter, uint8_t *dst_ptr,
+             unsigned int dst_stride, unsigned int output_width,
+             unsigned int output_height, int use_highbd);
 
 struct ConvolveFunctions {
   ConvolveFunctions(ConvolveFunc copy, ConvolveFunc avg, ConvolveFunc h8,
@@ -85,7 +85,7 @@ struct ConvolveFunctions {
   int use_highbd_;  // 0 if high bitdepth not used, else the actual bit depth.
 };
 
-typedef std::tuple<int, int, const ConvolveFunctions *> ConvolveParam;
+using ConvolveParam = std::tuple<int, int, const ConvolveFunctions *>;
 
 #if !CONFIG_REALTIME_ONLY && CONFIG_VP9_ENCODER
 struct ConvolveFunctions12Tap {
@@ -103,7 +103,7 @@ struct ConvolveFunctions12Tap {
   int use_highbd_;  // 0 if high bitdepth not used, else the actual bit depth.
 };
 
-typedef std::tuple<int, int, const ConvolveFunctions12Tap *> Convolve12TapParam;
+using Convolve12TapParam = std::tuple<int, int, const ConvolveFunctions12Tap *>;
 #endif
 
 #define ALL_SIZES(convolve_fn)                                            \

test/cq_test.cc

@@ -28,7 +28,7 @@ class CQTest : public ::libvpx_test::EncoderTest,
                public ::libvpx_test::CodecTestWithParam<int> {
  public:
   // maps the cqlevel to the bitrate produced.
-  typedef std::map<int, uint32_t> BitrateMap;
+  using BitrateMap = std::map<int, uint32_t>;
 
   static void SetUpTestSuite() { bitrates_.clear(); }
 

test/dct16x16_test.cc

@@ -224,16 +224,16 @@ void reference_16x16_dct_2d(int16_t input[256], double output[256]) {
   }
 }
 
-typedef void (*FdctFunc)(const int16_t *in, tran_low_t *out, int stride);
-typedef void (*IdctFunc)(const tran_low_t *in, uint8_t *out, int stride);
-typedef void (*FhtFunc)(const int16_t *in, tran_low_t *out, int stride,
-                        int tx_type);
-typedef void (*IhtFunc)(const tran_low_t *in, uint8_t *out, int stride,
-                        int tx_type);
-
-typedef std::tuple<FdctFunc, IdctFunc, int, vpx_bit_depth_t> Dct16x16Param;
-typedef std::tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t> Ht16x16Param;
-typedef std::tuple<IdctFunc, IdctFunc, int, vpx_bit_depth_t> Idct16x16Param;
+using FdctFunc = void (*)(const int16_t *in, tran_low_t *out, int stride);
+using IdctFunc = void (*)(const tran_low_t *in, uint8_t *out, int stride);
+using FhtFunc = void (*)(const int16_t *in, tran_low_t *out, int stride,
+                         int tx_type);
+using IhtFunc = void (*)(const tran_low_t *in, uint8_t *out, int stride,
+                         int tx_type);
+
+using Dct16x16Param = std::tuple<FdctFunc, IdctFunc, int, vpx_bit_depth_t>;
+using Ht16x16Param = std::tuple<FhtFunc, IhtFunc, int, vpx_bit_depth_t>;
+using Idct16x16Param = std::tuple<IdctFunc, IdctFunc, int, vpx_bit_depth_t>;
 
 void fdct16x16_ref(const int16_t *in, tran_low_t *out, int stride,
                    int /*tx_type*/) {

test/dct32x32_test.cc

@@ -66,14 +66,14 @@ void reference_32x32_dct_2d(const int16_t input[kNumCoeffs],
   }
 }
 
-typedef void (*FwdTxfmFunc)(const int16_t *in, tran_low_t *out, int stride);
-typedef void (*InvTxfmFunc)(const tran_low_t *in, uint8_t *out, int stride);
+using FwdTxfmFunc = void (*)(const int16_t *in, tran_low_t *out, int stride);
+using InvTxfmFunc = void (*)(const tran_low_t *in, uint8_t *out, int stride);
 
-typedef std::tuple<FwdTxfmFunc, InvTxfmFunc, int, vpx_bit_depth_t>
-    Trans32x32Param;
+using Trans32x32Param =
+    std::tuple<FwdTxfmFunc, InvTxfmFunc, int, vpx_bit_depth_t>;
 
-typedef std::tuple<InvTxfmFunc, InvTxfmFunc, int, vpx_bit_depth_t, int, int>
-    InvTrans32x32Param;
+using InvTrans32x32Param =
+    std::tuple<InvTxfmFunc, InvTxfmFunc, int, vpx_bit_depth_t, int, int>;
 
 #if CONFIG_VP9_HIGHBITDEPTH
 void idct32x32_10(const tran_low_t *in, uint8_t *out, int stride) {

test/dct_partial_test.cc

@@ -33,10 +33,10 @@ using std::make_tuple;
 using std::tuple;
 
 namespace {
-typedef void (*PartialFdctFunc)(const int16_t *in, tran_low_t *out, int stride);
+using PartialFdctFunc = void (*)(const int16_t *in, tran_low_t *out,
+                                 int stride);
 
-typedef tuple<PartialFdctFunc, int /* size */, vpx_bit_depth_t>
-    PartialFdctParam;
+using PartialFdctParam = tuple<PartialFdctFunc, int /*size*/, vpx_bit_depth_t>;
 
 tran_low_t partial_fdct_ref(const Buffer<int16_t> &in, int size) {
   int64_t sum = 0;

test/dct_test.cc

@@ -34,16 +34,16 @@ using std::make_tuple;
 using std::tuple;
 
 namespace {
-typedef void (*FdctFunc)(const int16_t *in, tran_low_t *out, int stride);
-typedef void (*IdctFunc)(const tran_low_t *in, uint8_t *out, int stride);
-typedef void (*FhtFunc)(const int16_t *in, tran_low_t *out, int stride,
-                        int tx_type);
-typedef void (*FhtFuncRef)(const Buffer<int16_t> &in, Buffer<tran_low_t> *out,
-                           int size, int tx_type);
-typedef void (*IhtFunc)(const tran_low_t *in, uint8_t *out, int stride,
-                        int tx_type);
-typedef void (*IhtWithBdFunc)(const tran_low_t *in, uint8_t *out, int stride,
-                              int tx_type, int bd);
+using FdctFunc = void (*)(const int16_t *in, tran_low_t *out, int stride);
+using IdctFunc = void (*)(const tran_low_t *in, uint8_t *out, int stride);
+using FhtFunc = void (*)(const int16_t *in, tran_low_t *out, int stride,
+                         int tx_type);
+using FhtFuncRef = void (*)(const Buffer<int16_t> &in, Buffer<tran_low_t> *out,
+                            int size, int tx_type);
+using IhtFunc = void (*)(const tran_low_t *in, uint8_t *out, int stride,
+                         int tx_type);
+using IhtWithBdFunc = void (*)(const tran_low_t *in, uint8_t *out, int stride,
+                               int tx_type, int bd);
 
 template <FdctFunc fn>
 void fdct_wrapper(const int16_t *in, tran_low_t *out, int stride, int tx_type) {
@@ -67,11 +67,11 @@ void iht_wrapper(const tran_low_t *in, uint8_t *out, int stride, int tx_type,
 }
 
 #if CONFIG_VP9_HIGHBITDEPTH
-typedef void (*HighbdIdctFunc)(const tran_low_t *in, uint16_t *out, int stride,
-                               int bd);
+using HighbdIdctFunc = void (*)(const tran_low_t *in, uint16_t *out, int stride,
+                                int bd);
 
-typedef void (*HighbdIhtFunc)(const tran_low_t *in, uint16_t *out, int stride,
-                              int tx_type, int bd);
+using HighbdIhtFunc = void (*)(const tran_low_t *in, uint16_t *out, int stride,
+                               int tx_type, int bd);
 
 template <HighbdIdctFunc fn>
 void highbd_idct_wrapper(const tran_low_t *in, uint8_t *out, int stride,
@@ -95,7 +95,7 @@ struct FuncInfo {
 };
 
 /* forward transform, inverse transform, size, transform type, bit depth */
-typedef tuple<int, const FuncInfo *, int, vpx_bit_depth_t> DctParam;
+using DctParam = tuple<int, const FuncInfo *, int, vpx_bit_depth_t>;
 
 void fdct_ref(const Buffer<int16_t> &in, Buffer<tran_low_t> *out, int size,
               int /*tx_type*/) {