gtests: tidy: various fixes

Author: dzarukin

tests/gtests/dnnl_test_common.hpp

@@ -297,15 +297,15 @@ inline memory::dim right_padding(memory::dim i, memory::dim o, memory::dim k,
 
 template <typename data_t>
 struct acc_t {
-    typedef data_t type;
+    using type = data_t;
 };
 template <>
 struct acc_t<int8_t> {
-    typedef int type;
+    using type = int;
 };
 template <>
 struct acc_t<uint8_t> {
-    typedef int type;
+    using type = int;
 };
 
 // Smart pointer for map/unmap operations with unique_ptr semantics
@@ -314,9 +314,8 @@ struct mapped_ptr_t {
     using nonconst_type = typename std::remove_cv<T>::type;
 
     mapped_ptr_t(std::nullptr_t) : mem_(nullptr), ptr_(nullptr) {}
-    mapped_ptr_t(const memory *mem) : mem_(mem) {
-        ptr_ = mem->map_data<nonconst_type>();
-    }
+    mapped_ptr_t(const memory *mem)
+        : mem_(mem), ptr_(mem->map_data<nonconst_type>()) {}
     mapped_ptr_t(mapped_ptr_t &&other) : mem_(other.mem_), ptr_(other.ptr_) {
         other.mem_ = nullptr;
         other.ptr_ = nullptr;
@@ -368,12 +367,12 @@ void check_zero_tail(int set_zero_flag, const memory &src) {
 
     for (memory::dim i = 0; i < nelems; ++i) {
         memory::dim off = 0;
-        bool flag = 0;
+        bool flag = false;
         for (int j = 0; j < ndims; ++j) {
             off += idx[j] * str[j];
-            if (idx[j] >= dims[ndims - j - 1]) flag = 1;
+            if (idx[j] >= dims[ndims - j - 1]) flag = true;
         }
-        if (flag == 1) {
+        if (flag == true) {
             memory::dim blk_off = mdw.off_l(off, true);
             if (set_zero_flag) {
                 src_data[blk_off] = 0.0;
@@ -391,8 +390,8 @@ void check_zero_tail(int set_zero_flag, const memory &src) {
     }
 }
 
-inline memory::desc create_md(memory::dims dims, memory::data_type data_type,
-        memory::format_tag fmt_tag) {
+inline memory::desc create_md(const memory::dims &dims,
+        memory::data_type data_type, memory::format_tag fmt_tag) {
     return memory::desc(dims, data_type, fmt_tag);
 }
 
@@ -566,7 +565,8 @@ inline dnnl_status_t get_conv_impl_status(
         const_dnnl_primitive_desc_t pd, const char *match_str) {
     const char *conv_str = query_impl_info(pd);
 
-    if (strstr(conv_str, match_str) != NULL) return dnnl_status_t::dnnl_success;
+    if (strstr(conv_str, match_str) != nullptr)
+        return dnnl_status_t::dnnl_success;
     return dnnl_status_t::dnnl_unimplemented;
 };
 
@@ -608,7 +608,7 @@ struct test_convolution_attr_t {
 
         bool is_def() const { return policy != NONE; }
 
-        scale_t(float s, policy_t p = NONE) : scale(s) { policy = p; }
+        scale_t(float s, policy_t p = NONE) : policy(p), scale(s) {}
 
         policy_t policy;
         float scale;
@@ -632,7 +632,7 @@ struct test_convolution_attr_t {
 
     test_convolution_attr_t(
             float s, scale_t::policy_t p = scale_t::policy_t::NONE)
-        : src_scale(s, p), wei_scale(s, p), dst_scale(s, p), dnnl_attr() {}
+        : src_scale(s, p), wei_scale(s, p), dst_scale(s, p) {}
 
     test_convolution_attr_t() : test_convolution_attr_t(1.f) {}
 
@@ -785,7 +785,7 @@ static char *test_malloc(size_t size) {
 #else
     int rc = ::posix_memalign(&ptr, align, padded_size);
 #endif /* _WIN32 */
-    return rc == 0 ? (char *)ptr + TEST_MALLOC_OFFSET : 0;
+    return rc == 0 ? (char *)ptr + TEST_MALLOC_OFFSET : nullptr;
 }
 
 static void test_free(char *ptr) {
@@ -801,11 +801,11 @@ static void test_free(char *ptr) {
 //NOLINTNEXTLINE(readability-identifier-naming)
 class test_memory {
 public:
-    test_memory(const memory::desc &d, const dnnl::engine &e) {
+    test_memory(const memory::desc &d, const dnnl::engine &e)
+        : size_(d.get_size()) {
         bool is_cpu_native = (e.get_kind() == dnnl::engine::kind::cpu)
                 && DNNL_CPU_RUNTIME != DNNL_RUNTIME_SYCL;
 
-        size_ = d.get_size();
         if (is_cpu_native) {
             data_.reset(test_malloc(size_), test_free);
             mem_ = test::make_memory(d, e, data_.get());
@@ -1091,10 +1091,9 @@ void test_bwd_pd_allow_empty(const pd_t &pd, const hint_pd_t &hint,
 
 // Note: requires a valid primitive descriptor!
 template <typename pd_t, typename hint_pd_t, typename... prim_params_t>
-void test_bwd_pd_constructors(const pd_t &pd, const hint_pd_t &hint,
+void test_bwd_pd_constructors(const pd_t &pd, const hint_pd_t &hint_pd,
         const allows_attr_t &aa, const prim_params_t &...prim_params) {
     auto test_pd = pd_t();
-    auto hint_pd = hint;
     auto eng = pd.get_engine();
     // ctor from C pd, should not throw
     ASSERT_NO_THROW(test_pd = pd_t(pd.get()));
@@ -1112,7 +1111,7 @@ void test_bwd_pd_constructors(const pd_t &pd, const hint_pd_t &hint,
     test_bwd_pd_allow_empty<pd_t>(test_pd, hint_pd, prim_params...);
 }
 
-inline dnnl::stream make_stream(dnnl::engine engine,
+inline dnnl::stream make_stream(const dnnl::engine &engine,
         dnnl::stream::flags flags = dnnl::stream::flags::default_flags) {
 #if DNNL_CPU_THREADING_RUNTIME == DNNL_RUNTIME_THREADPOOL
     if (engine.get_kind() == dnnl::engine::kind::cpu)

tests/gtests/dnnl_test_macros.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2019-2023 Intel Corporation
+* Copyright 2019-2025 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -124,6 +124,7 @@
     } \
     void Testing()
 
+//NOLINTBEGIN(bugprone-macro-parentheses)
 // Wrapper around TEST from gtest, intended to catch exceptions thrown by a unit
 // test.
 #define HANDLE_EXCEPTIONS_FOR_TEST(test_fixture, test_name) \
@@ -193,4 +194,6 @@
     TEST_P(test_fixture, test_name)
 #endif
 
+//NOLINTEND(bugprone-macro-parentheses)
+
 #endif

tests/gtests/test_convolution_backward_data_common.hpp

@@ -89,7 +89,7 @@ template <typename data_t_diff_dst, typename data_t_wei, typename data_t_acc,
 class convolution_backward_data_test_t
     : public ::testing::TestWithParam<test_convolution_params_t> {
 protected:
-    virtual void SetUp() {
+    void SetUp() override {
         auto p = ::testing::TestWithParam<
                 test_convolution_params_t>::GetParam();
 

tests/gtests/test_convolution_backward_weights_common.hpp

@@ -121,7 +121,7 @@ template <typename data_t_src, typename data_t_diff_dst,
 class convolution_backward_weights_test_t
     : public ::testing::TestWithParam<test_convolution_params_t> {
 protected:
-    virtual void SetUp() {
+    void SetUp() override {
         auto p = ::testing::TestWithParam<
                 test_convolution_params_t>::GetParam();
 

tests/gtests/test_convolution_eltwise_forward_common.hpp

@@ -114,7 +114,7 @@ template <typename data_t_src, typename data_t_wei, typename data_t_acc,
 class convolution_eltwise_test_t
     : public ::testing::TestWithParam<test_convolution_eltwise_params_t> {
 protected:
-    virtual void SetUp() {
+    void SetUp() override {
         memory::data_type data_type_src = data_traits_t<data_t_src>::data_type;
         memory::data_type data_type_dst = data_traits_t<data_t_dst>::data_type;
         memory::data_type data_type_wei = data_traits_t<data_t_wei>::data_type;

tests/gtests/test_convolution_forward_common.hpp

@@ -115,7 +115,7 @@ template <typename data_t_src, typename data_t_wei, typename data_t_acc,
 class convolution_forward_test_t
     : public ::testing::TestWithParam<test_convolution_params_t> {
 protected:
-    virtual void SetUp() {
+    void SetUp() override {
         memory::data_type data_type_src = data_traits_t<data_t_src>::data_type;
         memory::data_type data_type_dst = data_traits_t<data_t_dst>::data_type;
         memory::data_type data_type_wei = data_traits_t<data_t_wei>::data_type;

tests/gtests/test_gemm_common.hpp

@@ -590,7 +590,7 @@ struct run_test_gemm_t {
 template <typename a_dt, typename b_dt, typename c_dt>
 class gemm_test_common_t : public ::testing::TestWithParam<test_params_t> {
 protected:
-    virtual void SetUp() {
+    void SetUp() override {
         const auto &p = ::testing::TestWithParam<test_params_t>::GetParam();
 
         SKIP_IF(get_test_engine_kind() == engine::kind::gpu,

tests/gtests/test_gemm_data_preparation.hpp

@@ -53,12 +53,7 @@ static constexpr int N_test_max = 53;
  * a surjective function from {0, ..., dim-1} onto {0, ..., dim_test-1}.
  */
 struct mapper_t {
-    mapper_t(const mapper_t &other)
-        : dim_(other.dim_)
-        , dim_test_(other.dim_test_)
-        , gen_(other.gen_)
-        , gen_start_(other.gen_start_)
-        , mapper_(other.mapper_) {}
+    mapper_t(const mapper_t &other) = default;
 
     mapper_t(mapper_t &&other) noexcept
         : dim_(other.dim_)
@@ -260,19 +255,19 @@ void prepare_data_for_gemm_testing(
     size_t sizeA, sizeB, sizeC;
     get_matrix_size(p, sizeA, sizeB, sizeC);
 
-    gemm_data.a_mem.reset(
-            new test_memory(get_matrix_md<a_dt>(sizeA, p.off.a), eng));
-    gemm_data.b_mem.reset(
-            new test_memory(get_matrix_md<b_dt>(sizeB, p.off.b), eng));
-    gemm_data.c_mem.reset(
-            new test_memory(get_matrix_md<c_dt>(sizeC, p.off.c), eng));
-    gemm_data.c_ref_mem.reset(
-            new test_memory(get_matrix_md<c_dt>(sizeC, p.off.c), eng));
-    gemm_data.oc_mem.reset(
-            new test_memory(get_matrix_md<c_dt>(p.size_oc(), p.off.co), eng));
-
-    gemm_data.mapper_m.reset(new mapper_t(p.M, M_test_max));
-    gemm_data.mapper_n.reset(new mapper_t(p.N, N_test_max));
+    gemm_data.a_mem = std::make_shared<test_memory>(
+            get_matrix_md<a_dt>(sizeA, p.off.a), eng);
+    gemm_data.b_mem = std::make_shared<test_memory>(
+            get_matrix_md<b_dt>(sizeB, p.off.b), eng);
+    gemm_data.c_mem = std::make_shared<test_memory>(
+            get_matrix_md<c_dt>(sizeC, p.off.c), eng);
+    gemm_data.c_ref_mem = std::make_shared<test_memory>(
+            get_matrix_md<c_dt>(sizeC, p.off.c), eng);
+    gemm_data.oc_mem = std::make_shared<test_memory>(
+            get_matrix_md<c_dt>(p.size_oc(), p.off.co), eng);
+
+    gemm_data.mapper_m = std::make_shared<mapper_t>(p.M, M_test_max);
+    gemm_data.mapper_n = std::make_shared<mapper_t>(p.N, N_test_max);
 
     fill_matrices<a_dt, b_dt, c_dt>(p, *gemm_data.mapper_m, *gemm_data.mapper_n,
             *gemm_data.a_mem, *gemm_data.b_mem, *gemm_data.c_mem,

tests/gtests/test_rnn_forward.cpp

@@ -104,7 +104,7 @@ class rnn_forward_test_t : public ::testing::TestWithParam<test_rnn_params_t> {
         return memory::desc();
     }
 
-    void testExecArgQueries(typename T::primitive_desc pd) {
+    void testExecArgQueries(const typename T::primitive_desc &pd) {
         ASSERT_TRUE(pd.query_md(query::exec_arg_md, DNNL_ARG_WEIGHTS_LAYER)
                 == pd.weights_layer_desc());
         ASSERT_TRUE(pd.query_md(query::exec_arg_md, DNNL_ARG_WEIGHTS_ITER)
@@ -131,7 +131,7 @@ class rnn_forward_test_t : public ::testing::TestWithParam<test_rnn_params_t> {
                 == queryDstIterC(pd));
     };
 
-    void test_primitive_param_queries(typename T::primitive_desc pd) {
+    void test_primitive_param_queries(const typename T::primitive_desc &pd) {
         auto p = ::testing::TestWithParam<test_rnn_params_t>::GetParam();
 
         dnnl::algorithm expected_cell_kind = algorithm::undef;