diff --git a/Jenkinsfile b/Jenkinsfile
index 0417571e50..694c9c53cd 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -48,6 +48,7 @@ def cmake_build(Map conf=[:]){
 
     if (package_build == true) {
         make_targets = "package"
+        setup_args = " -DMIOPEN_TEST_DISCRETE=OFF " + setup_args
     }
 
     def miopen_install_path = "${env.WORKSPACE}/install"
@@ -953,7 +954,7 @@ pipeline {
                     environment{
                         setup_flags="-DMIOPEN_TEST_DBSYNC=1"
                         make_targets='test_db_sync'
-                        execute_cmd='./bin/test_db_sync'
+                        execute_cmd='MIOPEN_TEST_DBSYNC=1 ./bin/test_db_sync'
                     }
                     steps{
                         buildHipClangJobAndReboot(lfs_pull: true, setup_flags: setup_flags, make_targets: make_targets, execute_cmd: execute_cmd,
@@ -972,7 +973,7 @@ pipeline {
                     environment{
                         setup_flags="-DMIOPEN_TEST_DBSYNC=1"
                         make_targets='test_db_sync'
-                        execute_cmd='./bin/test_db_sync'
+                        execute_cmd='MIOPEN_TEST_DBSYNC=1 ./bin/test_db_sync'
                     }
                     steps{
                         buildHipClangJobAndReboot(lfs_pull: true, setup_flags: setup_flags, make_targets: make_targets, execute_cmd: execute_cmd,
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 9940bfe1ff..d36be3146b 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -68,6 +68,7 @@ option( MIOPEN_TEST_CONV "" OFF)
 option( MIOPEN_TEST_DEEPBENCH "" OFF)
 option( MIOPEN_TEST_DRIVER_ITER_MODE "" OFF)
 option( MIOPEN_TEST_COMPOSABLEKERNEL "Test with composable_kernel library" ${MIOPEN_USE_COMPOSABLEKERNEL} )
+option( MIOPEN_TEST_DISCRETE "Build Discrete Test Binaries" ON)
 
 set_var_to_condition(MIOPEN_TEST_WITH_MIOPENDRIVER_DEFAULT MIOPEN_BUILD_DRIVER)
 option( MIOPEN_TEST_WITH_MIOPENDRIVER "Use MIOpenDriver in tests" ${MIOPEN_TEST_WITH_MIOPENDRIVER_DEFAULT})
@@ -673,20 +674,6 @@ function(add_custom_test NAME)
         set_tests_properties(${NAME} PROPERTIES DISABLED On)
     endif()
 endfunction()
-if(${CODECOV_TEST})
-    add_custom_test(test_conv3d_codecov
-        COMMAND $<TARGET_FILE:test_conv3d> ${MIOPEN_TEST_FLOAT_ARG} --input 2 4 4 4 4 --weights 2 4 1 1 1 --pads_strides_dilations 0 0 0 1 1 1 1 1 1 ${MIOPEN_TEST_FLAGS_ARGS}
-    )
-    add_custom_test(test_immed_conv2d_codecov
-        COMMAND $<TARGET_FILE:test_immed_conv2d> ${MIOPEN_TEST_FLOAT_ARG} --input  2 2 14 14 --weights 8 2 3 3 --pads_strides_dilations 0 0 1 1 1 1 ${MIOPEN_TEST_FLAGS_ARGS}
-    )
-    add_custom_test(test_immed_conv3d_codecov
-        COMMAND $<TARGET_FILE:test_immed_conv3d> ${MIOPEN_TEST_FLOAT_ARG} --input 1 4 4 4 4 --weights 2 4 3 3 3 --pads_strides_dilations 0 0 0 1 1 1 1 1 1 ${MIOPEN_TEST_FLAGS_ARGS}
-    )
-    add_custom_test(test_pooling2d_codecov
-        COMMAND $<TARGET_FILE:test_pooling2d> ${MIOPEN_TEST_FLOAT_ARG} --input 1, 192, 28, 28 --lens 2 2 --strides 2 2 --pads 0 0 ${MIOPEN_TEST_FLAGS_ARGS}
-    )
-endif()
 
 if(${MIOPEN_TEST_WITH_MIOPENDRIVER})
     add_custom_test(test_miopendriver_regression_issue_1576 SKIP_UNLESS_ALL GFX94X_ENABLED GFX103X_ENABLED GFX110X_ENABLED FLOAT_DISABLED HALF_ENABLED
@@ -776,14 +763,6 @@ set(TEST_CONV_VERBOSE_F ${MIOPEN_TEST_FLOAT_ARG} --verbose --disable-backward-da
 set(TEST_CONV_VERBOSE_B ${MIOPEN_TEST_FLOAT_ARG} --verbose --disable-forward --disable-backward-weights)
 set(TEST_CONV_VERBOSE_W ${MIOPEN_TEST_FLOAT_ARG} --verbose --disable-forward --disable-backward-data)
 
-add_custom_test(test_pooling2d_asymmetric SKIP_UNLESS_ALL HALF_ENABLED GFX94X_ENABLED GFX103X_ENABLED GFX110X_ENABLED
-    COMMAND $<TARGET_FILE:test_pooling2d> ${MIOPEN_TEST_FLOAT_ARG} --all --dataset 1 --limit 0 ${MIOPEN_TEST_FLAGS_ARGS}
-)
-
-add_custom_test(test_pooling2d_wide SKIP_UNLESS_ALL HALF_ENABLED GFX94X_ENABLED GFX103X_ENABLED GFX110X_ENABLED
-    COMMAND $<TARGET_FILE:test_pooling2d> ${MIOPEN_TEST_FLOAT_ARG} --all --dataset 2 --limit 0 ${MIOPEN_TEST_FLAGS_ARGS}
-)
-
 set(IMPLICITGEMM_MLIR_ENV_F_XDLOPS ${IMPLICITGEMM_MLIR_ENV_BASE} MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvMlirIgemmFwdXdlops)
 set(IMPLICITGEMM_MLIR_ENV_B_XDLOPS ${IMPLICITGEMM_MLIR_ENV_BASE} MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvMlirIgemmBwdXdlops)
 set(IMPLICITGEMM_MLIR_ENV_W_XDLOPS ${IMPLICITGEMM_MLIR_ENV_BASE} MIOPEN_DEBUG_FIND_ONLY_SOLVER=ConvMlirIgemmWrWXdlops)
diff --git a/test/immed_conv3d.cpp b/test/conv3d.hpp
similarity index 84%
rename from test/immed_conv3d.cpp
rename to test/conv3d.hpp
index a968cd6100..8cb7940ca2 100644
--- a/test/immed_conv3d.cpp
+++ b/test/conv3d.hpp
@@ -23,12 +23,13 @@
  * SOFTWARE.
  *
  *******************************************************************************/
+#include <gtest/gtest.h>
 #include "conv_common.hpp"
 
 template <class T>
-struct conv3d_driver : conv_driver<T, ConvApi::Immediate>
+struct conv3d_driver : conv_driver<T>
 {
-    conv3d_driver() : conv_driver<T, ConvApi::Immediate>()
+    conv3d_driver() : conv_driver<T>()
     {
         this->add(this->input_dims, "input");
         this->add(this->weight_tensor_dims, "weights");
@@ -37,16 +38,16 @@ struct conv3d_driver : conv_driver<T, ConvApi::Immediate>
                   this->generate_data_limited(this->get_batch_sizes(), 1, {8}));
         this->add(this->input_channels,
                   "input_channels",
-                  this->generate_data_limited(this->get_input_channels(), 1, {2}));
+                  this->generate_data_limited(this->get_input_channels(), 1, {32}));
         this->add(this->output_channels,
                   "output_channels",
-                  this->generate_data_limited(this->get_output_channels(), 1, {16}));
+                  this->generate_data_limited(this->get_output_channels(), 1, {32}));
         this->add(this->spatial_dim_elements,
                   "spatial_dim_elements",
                   this->generate_data_limited(this->get_3d_spatial_dims(), 1, {16, 16, 16}));
         this->add(this->filter_dims,
                   "filter_dims",
-                  this->generate_data_limited(this->get_3d_filter_dims(), 2, {5, 5, 5}));
+                  this->generate_data_limited(this->get_3d_filter_dims(), 2, {3, 3, 3}));
         this->add(this->pads_strides_dilations,
                   "pads_strides_dilations",
                   this->generate_data_limited(this->get_3d_pads_strides_dilations(), 2));
@@ -59,4 +60,18 @@ struct conv3d_driver : conv_driver<T, ConvApi::Immediate>
     }
 };
 
-int main(int argc, const char* argv[]) { test_drive<conv3d_driver>(argc, argv); }
+class Conv3dFloat : public testing::TestWithParam<std::vector<std::string>>
+{
+};
+
+class Conv3dHalf : public testing::TestWithParam<std::vector<std::string>>
+{
+};
+
+class Conv3dBFloat16 : public testing::TestWithParam<std::vector<std::string>>
+{
+};
+
+class Conv3dInt8 : public testing::TestWithParam<std::vector<std::string>>
+{
+};
diff --git a/test/driver.hpp b/test/driver.hpp
index 825a0d4511..97896d6c5d 100644
--- a/test/driver.hpp
+++ b/test/driver.hpp
@@ -1242,6 +1242,11 @@ void test_drive_impl_1(std::string program_name, std::vector<std::string> as)
     Driver d{};
     d.program_name = program_name;
 
+    std::cout << program_name << " ";
+    for(const auto& str : as)
+        std::cout << str << " ";
+    std::cout << std::endl;
+
     std::set<std::string> keywords{
         "--help", "-h", "--half", "--float", "--double", "--int8", "--bfloat16"};
     d.parse(keyword_set{keywords});
@@ -1381,7 +1386,7 @@ template <template <class...> class Driver>
 void test_drive(int argc, const char* argv[])
 {
     std::vector<std::string> as(argv + 1, argv + argc);
-    as.emplace_back("--float");
+    // as.emplace_back("--float");
     for(auto&& arg : as)
     {
         if(arg == "--half")
diff --git a/test/gtest/CMakeLists.txt b/test/gtest/CMakeLists.txt
index eb3a716232..d6e60681e6 100644
--- a/test/gtest/CMakeLists.txt
+++ b/test/gtest/CMakeLists.txt
@@ -7,37 +7,35 @@ set(SOURCES
     )
 
 if(MIOPEN_BACKEND_OPENCL)
-  set(SKIP_TESTS dumpTensorTest)
+  set(SKIP_TESTS dumpTensorTest.cpp)
 endif()
 
-function(add_gtest TEST_NAME)
-  if( NOT (TEST_NAME IN_LIST SKIP_TESTS))
-    message("Adding Test: " ${TEST_NAME})
-    add_executable(test_${TEST_NAME} ${TEST_NAME}.cpp  ${SOURCES})
-    if(WIN32)
-      target_compile_definitions(test_${TEST_NAME} PRIVATE NOMINMAX)
-    endif()
-    add_dependencies(tests test_${TEST_NAME})
-    add_dependencies(check test_${TEST_NAME})
-    target_compile_options(test_${TEST_NAME} PRIVATE -Wno-global-constructors -Wno-undef)
-    target_include_directories(test_${TEST_NAME} PRIVATE ../ ../../src/kernels)
-    if(MIOPEN_ENABLE_AI_KERNEL_TUNING)
-      target_link_libraries(test_${TEST_NAME} frugally-deep::fdeep Eigen3::Eigen)
-    endif()
-    target_link_libraries(test_${TEST_NAME} GTest::gtest GTest::gtest_main MIOpen ${Boost_LIBRARIES} hip::host $<BUILD_INTERFACE:roc::rocblas>)
-    if(NOT MIOPEN_EMBED_DB STREQUAL "")
-        target_link_libraries(test_${TEST_NAME} $<BUILD_INTERFACE:miopen_data>)
-    endif()
-    if(NOT WIN32) # TODO: cannot run on Windows due to missing DLL dependencies
-      # Enable CMake to discover the test binary
-      # Extend GTest DISCOVERY_TIMEOUT to 5 mins
-      gtest_discover_tests(test_${TEST_NAME} DISCOVERY_TIMEOUT 300 PROPERTIES ENVIRONMENT "MIOPEN_USER_DB_PATH=${CMAKE_CURRENT_BINARY_DIR};MIOPEN_TEST_FLOAT_ARG=${MIOPEN_TEST_FLOAT_ARG};MIOPEN_TEST_ALL=${MIOPEN_TEST_ALL};MIOPEN_TEST_MLIR=${MIOPEN_TEST_MLIR};MIOPEN_TEST_COMPOSABLEKERNEL=${MIOPEN_TEST_COMPOSABLEKERNEL}")
-    endif()
-
-    if(WIN32)
-      # Refer to https://en.cppreference.com/w/cpp/language/types for details.
-      target_compile_options(test_${TEST_NAME} PRIVATE $<BUILD_INTERFACE:$<$<CXX_COMPILER_ID:Clang>:-U__LP64__>>)
-    endif()
+function(add_gtest TEST_NAME TEST_CPP)
+  message("Adding Test: " ${TEST_NAME} " : " ${TEST_CPP})
+  add_executable(${TEST_NAME} ${TEST_CPP}  ${SOURCES})
+  if(WIN32)
+    target_compile_definitions(${TEST_NAME} PRIVATE NOMINMAX)
+  endif()
+  add_dependencies(tests ${TEST_NAME})
+  add_dependencies(check ${TEST_NAME})
+  target_compile_options(${TEST_NAME} PRIVATE -Wno-global-constructors -Wno-undef)
+  target_include_directories(${TEST_NAME} PRIVATE ../ ../../src/kernels)
+  if(MIOPEN_ENABLE_AI_KERNEL_TUNING)
+    target_link_libraries(${TEST_NAME} frugally-deep::fdeep Eigen3::Eigen)
+  endif()
+  target_link_libraries(${TEST_NAME} GTest::gtest GTest::gtest_main MIOpen ${Boost_LIBRARIES} hip::host $<BUILD_INTERFACE:roc::rocblas>)
+  if(NOT MIOPEN_EMBED_DB STREQUAL "")
+      target_link_libraries(${TEST_NAME} $<BUILD_INTERFACE:miopen_data>)
+  endif()
+  if(NOT WIN32) # TODO: cannot run on Windows due to missing DLL dependencies
+    # Enable CMake to discover the test binary
+    # Extend GTest DISCOVERY_TIMEOUT to 5 mins
+    gtest_discover_tests(${TEST_NAME} DISCOVERY_TIMEOUT 300 PROPERTIES ENVIRONMENT "MIOPEN_USER_DB_PATH=${CMAKE_CURRENT_BINARY_DIR};MIOPEN_TEST_FLOAT_ARG=${MIOPEN_TEST_FLOAT_ARG};MIOPEN_TEST_ALL=${MIOPEN_TEST_ALL};MIOPEN_TEST_MLIR=${MIOPEN_TEST_MLIR};MIOPEN_TEST_COMPOSABLEKERNEL=${MIOPEN_TEST_COMPOSABLEKERNEL};CODECOV_TEST=${CODECOV_TEST};MIOPEN_TEST_DBSYNC=${MIOPEN_TEST_DBSYNC}")
+  endif()
+
+  if(WIN32)
+    # Refer to https://en.cppreference.com/w/cpp/language/types for details.
+    target_compile_options(${TEST_NAME} PRIVATE $<BUILD_INTERFACE:$<$<CXX_COMPILER_ID:Clang>:-U__LP64__>>)
   endif()
 endfunction()
 
@@ -47,7 +45,29 @@ foreach(SOURCE ${SOURCES})
     list(REMOVE_ITEM TESTS ${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE})
 endforeach()
 
-foreach(TEST ${TESTS})
-    get_filename_component(BASE_NAME ${TEST} NAME_WE)
-    add_gtest(${BASE_NAME})
+foreach(SOURCE ${SKIP_TESTS})
+    list(REMOVE_ITEM TESTS ${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE})
 endforeach()
+
+if( MIOPEN_TEST_DISCRETE )
+  foreach(TEST ${TESTS})
+    get_filename_component(BASE_NAME ${TEST} NAME_WE)
+    add_gtest(test_${BASE_NAME} ${BASE_NAME}.cpp)
+  endforeach()
+
+else()
+  foreach(TEST ${TESTS})
+    get_filename_component(BASE_NAME ${TEST} NAME)
+    list(APPEND TESTS_CPP ${BASE_NAME})
+  endforeach()
+
+  add_gtest(miopen_gtest "${TESTS_CPP}")
+
+  if( NOT ENABLE_ASAN_PACKAGING )
+    install(TARGETS miopen_gtest
+        PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
+        DESTINATION ${CMAKE_INSTALL_BINDIR})
+  endif()
+endif()
+
+
diff --git a/test/gtest/ai_heuristics.hpp b/test/gtest/ai_heuristics.hpp
index 235c3e7f02..3898ad9bf6 100644
--- a/test/gtest/ai_heuristics.hpp
+++ b/test/gtest/ai_heuristics.hpp
@@ -31,7 +31,7 @@
 
 struct AIModelTestCase
 {
-    struct ConvTestCase conv;
+    struct ConvTestCaseBase conv;
     miopen::conv::Direction direction;
     miopenDataType_t data_type;
     miopenTensorLayout_t layout;
diff --git a/test/gtest/bad_fusion_plan.cpp b/test/gtest/bad_fusion_plan.cpp
index 80cd6bdd10..26958c3269 100644
--- a/test/gtest/bad_fusion_plan.cpp
+++ b/test/gtest/bad_fusion_plan.cpp
@@ -29,9 +29,12 @@
 
 #include "tensor_holder.hpp"
 #include "get_handle.hpp"
+#include "conv_test_base.hpp"
 
 #if MIOPEN_BACKEND_HIP
 
+namespace bad_fusion_plan {
+
 void setEnvironmentVariable(const std::string& name, const std::string& value)
 {
     int ret = 0;
@@ -45,16 +48,7 @@ void setEnvironmentVariable(const std::string& name, const std::string& value)
     EXPECT_EQ(ret, 0);
 }
 
-template <typename T>
-miopenDataType_t GetDataType();
-
-template <>
-miopenDataType_t GetDataType<half_float::half>()
-{
-    return miopenHalf;
-}
-
-struct ConvTestCase
+struct ConvTestCaseFusion
 {
     size_t N;
     size_t C;
@@ -69,7 +63,7 @@ struct ConvTestCase
     size_t stride_y;
     size_t dilation_x;
     size_t dilation_y;
-    friend std::ostream& operator<<(std::ostream& os, const ConvTestCase& tc)
+    friend std::ostream& operator<<(std::ostream& os, const ConvTestCaseFusion& tc)
     {
         return os << "(N: " << tc.N << " C:" << tc.C << " H:" << tc.H << " W:" << tc.W
                   << " k: " << tc.k << " y:" << tc.y << " x:" << tc.x << " pad_y:" << tc.pad_y
@@ -88,7 +82,7 @@ struct ConvTestCase
     }
 };
 
-const static ConvTestCase conv_config = {64, 64, 56, 56, 64, 3, 3, 1, 1, 1, 1, 1, 1};
+const static ConvTestCaseFusion conv_config = {64, 64, 56, 56, 64, 3, 3, 1, 1, 1, 1, 1, 1};
 
 template <typename Solver, typename T>
 class TestFusionPlan
@@ -172,6 +166,9 @@ class TestFusionPlan
     bool skip_test;
 };
 
+} // namespace bad_fusion_plan
+using namespace bad_fusion_plan;
+
 TEST(TestFusionPlan, GoodFusionPlan)
 {
     TestFusionPlan<miopen::solver::fusion::ConvCKIgemmFwdBiasActivFused, half_float::half> obj(
diff --git a/test/gtest/bn_bwd.cpp b/test/gtest/bn_bwd.cpp
index 722b42e872..e36dfe4374 100644
--- a/test/gtest/bn_bwd.cpp
+++ b/test/gtest/bn_bwd.cpp
@@ -54,20 +54,20 @@ TEST_P(BNBwdTestDouble, DISABLED_BnBwdCKDouble) {}
 
 INSTANTIATE_TEST_SUITE_P(BNBwdTestTestHalfNHWCSuite,
                          BNBwdTestTestHalf,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNBwdTestFloatNHWCSuite,
                          BNBwdTestFloat,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNBwdTestBFloat16NHWCSuite,
                          BNBwdTestBFloat16,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNBwdTestDoubleNHWCSuite,
                          BNBwdTestDouble,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
diff --git a/test/gtest/bn_fwd_train.cpp b/test/gtest/bn_fwd_train.cpp
index 4a4dd4c728..f7f3352a45 100644
--- a/test/gtest/bn_fwd_train.cpp
+++ b/test/gtest/bn_fwd_train.cpp
@@ -54,20 +54,20 @@ TEST_P(BNFwdTrainTestBFloat16, DISABLED_BnFwdTrainCKBFloat16) {}
 
 INSTANTIATE_TEST_SUITE_P(BNFwdTrainTestHalfNHWCSuite,
                          BNFwdTrainTestHalf,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNFwdTrainTestFloatNHWCSuite,
                          BNFwdTrainTestFloat,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNFwdTrainTestFloatNHWCSuite,
                          BNFwdTrainTestDouble,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNFwdTrainTestFloatNHWCSuite,
                          BNFwdTrainTestBFloat16,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
diff --git a/test/gtest/bn_infer.cpp b/test/gtest/bn_infer.cpp
index 0dceaa1ba5..ef742d6afb 100644
--- a/test/gtest/bn_infer.cpp
+++ b/test/gtest/bn_infer.cpp
@@ -54,20 +54,20 @@ TEST_P(BNInferTestBFloat16, DISABLED_BnInferCKBFloat16) {}
 
 INSTANTIATE_TEST_SUITE_P(BNInferTestHalfNHWCSuite,
                          BNInferTestHalf,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNInferTestFloatNHWCSuite,
                          BNInferTestFloat,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNInferTestFloatNHWCSuite,
                          BNInferTestDouble,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
 
 INSTANTIATE_TEST_SUITE_P(BNInferTestFloatNHWCSuite,
                          BNInferTestBFloat16,
-                         testing::Combine(testing::ValuesIn(Network1()),
+                         testing::Combine(testing::ValuesIn(Network1<BNTestCase>()),
                                           testing::Values(miopenTensorNHWC)));
diff --git a/test/gtest/bn_test_data.hpp b/test/gtest/bn_test_data.hpp
index 06a16be427..5304055fcb 100644
--- a/test/gtest/bn_test_data.hpp
+++ b/test/gtest/bn_test_data.hpp
@@ -55,7 +55,11 @@ struct BNTestCase
     std::vector<size_t> GetInput() const { return {N, C, H, W}; }
 };
 
-std::vector<BNTestCase> Network1()
+template <typename T>
+std::vector<T> Network1();
+
+template <>
+inline std::vector<BNTestCase> Network1()
 {
     // pyt_mlperf_resnet50v1.5
     return {
diff --git a/test/gtest/cba.hpp b/test/gtest/cba.hpp
index 70091e107c..4c0b554c7f 100644
--- a/test/gtest/cba.hpp
+++ b/test/gtest/cba.hpp
@@ -43,7 +43,7 @@
 template <typename T = float>
 struct ConvBiasActivInferTest
     : public ::testing::TestWithParam<
-          std::tuple<miopenActivationMode_t, ConvTestCase, miopenTensorLayout_t>>,
+          std::tuple<miopenActivationMode_t, ConvTestCaseBase, miopenTensorLayout_t>>,
       ConvFwdSolverTestBase<T>
 {
 protected:
@@ -90,7 +90,7 @@ struct ConvBiasActivInferTest
                             cfsb::ref_out.data);
         cfsb::ThresholdChecks();
     }
-    ConvTestCase conv_config;
+    ConvTestCaseBase conv_config;
     miopen::ActivationDescriptor activ_desc;
     tensor<T> bias;
     miopen::Allocator::ManageDataPtr bias_dev;
diff --git a/test/gtest/cba_find2.hpp b/test/gtest/cba_find2.hpp
index 7e2b443d6e..263eebb0e9 100644
--- a/test/gtest/cba_find2.hpp
+++ b/test/gtest/cba_find2.hpp
@@ -45,11 +45,11 @@
 template <typename T = float>
 struct ConvBiasActivInferFind2Test
     : public ::testing::TestWithParam<
-          std::tuple<miopenActivationMode_t, ConvTestCase, miopenTensorLayout_t>>,
+          std::tuple<miopenActivationMode_t, ConvTestCaseBase, miopenTensorLayout_t>>,
       ConvFwdSolverTestBase<T>
 {
 protected:
-    ConvTestCase conv_config;
+    ConvTestCaseBase conv_config;
     miopen::ActivationDescriptor activ_desc;
     tensor<T> bias;
     miopen::Allocator::ManageDataPtr bias_dev;
diff --git a/test/gtest/cba_find2_infer.cpp b/test/gtest/cba_find2_infer.cpp
index 67da2c2053..0472688a50 100644
--- a/test/gtest/cba_find2_infer.cpp
+++ b/test/gtest/cba_find2_infer.cpp
@@ -38,6 +38,8 @@
 #include "get_handle.hpp"
 #include "cba_find2.hpp"
 
+namespace cba_find2_infer {
+
 struct ConvBiasActivFind2InferTestFloat : ConvBiasActivInferFind2Test<float>
 {
 };
@@ -78,7 +80,7 @@ void RunSolver(miopen::FusedProblem& problem,
 template <typename Solver>
 void RunTunableSolver(miopen::FusedProblem& problem,
                       const miopen::AnyInvokeParams& invoke_ctx,
-                      const ConvTestCase& conv_config,
+                      const ConvTestCaseBase& conv_config,
                       bool& test_skipped)
 {
     auto& handle = get_handle();
@@ -101,6 +103,9 @@ void RunTunableSolver(miopen::FusedProblem& problem,
     handle.Finish();
 }
 
+} // namespace cba_find2_infer
+using namespace cba_find2_infer;
+
 TEST_P(ConvBiasActivFind2InferTestFloat, ConvBiasActivAsm1x1UFind2Float)
 {
     RunTunableSolver<miopen::solver::fusion::ConvBiasActivAsm1x1U>(
@@ -153,22 +158,23 @@ TEST_P(ConvBiasActivFind2InferTestFloatFusionFind, ConvBiasActivFind2Float_testF
     }
 }
 
-INSTANTIATE_TEST_SUITE_P(CBAFind2InferSolverTest,
-                         ConvBiasActivFind2InferTestFloatFusionFind,
-                         testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetworkForFusionCompileStepTest()),
-                                          testing::Values(miopenTensorNCHW)));
+INSTANTIATE_TEST_SUITE_P(
+    CBAFind2InferSolverTest,
+    ConvBiasActivFind2InferTestFloatFusionFind,
+    testing::Combine(testing::Values(miopenActivationRELU),
+                     testing::ValuesIn(GetNetworkForFusionCompileStepTest<ConvTestCaseBase>()),
+                     testing::Values(miopenTensorNCHW)));
 
 #endif
 
 INSTANTIATE_TEST_SUITE_P(CBAFind2InferSolverTest,
                          ConvBiasActivFind2InferTestFloat,
                          testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetwork1()),
+                                          testing::ValuesIn(GetNetwork1<ConvTestCaseBase>()),
                                           testing::Values(miopenTensorNCHW)));
 
 INSTANTIATE_TEST_SUITE_P(CBAFind2InferSolverTest,
                          ConvBiasActivFind2InferTestHalf,
                          testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetwork1()),
+                                          testing::ValuesIn(GetNetwork1<ConvTestCaseBase>()),
                                           testing::Values(miopenTensorNHWC)));
diff --git a/test/gtest/cba_infer.cpp b/test/gtest/cba_infer.cpp
index 8690824ff4..e02dd31ec8 100644
--- a/test/gtest/cba_infer.cpp
+++ b/test/gtest/cba_infer.cpp
@@ -36,6 +36,8 @@
 #include "get_handle.hpp"
 #include "cba.hpp"
 
+namespace cba_infer {
+
 struct ConvBiasActivInferTestFloat : ConvBiasActivInferTest<float>
 {
 };
@@ -87,7 +89,7 @@ void RunSolver(miopen::FusionPlanDescriptor& fusePlanDesc,
 template <typename Solver>
 void RunTunableSolver(miopen::FusionPlanDescriptor& fusePlanDesc,
                       const std::unique_ptr<miopen::fusion::FusionInvokeParams>& plan_params,
-                      const ConvTestCase& conv_config,
+                      const ConvTestCaseBase& conv_config,
                       bool& test_skipped)
 {
     auto& handle = get_handle();
@@ -108,6 +110,8 @@ void RunTunableSolver(miopen::FusionPlanDescriptor& fusePlanDesc,
     (invoker)(handle, *(plan_params.get()));
     handle.Finish();
 }
+} // namespace cba_infer
+using namespace cba_infer;
 
 TEST_P(ConvBiasActivInferTestFloat, ConvBiasActivAsm1x1UFloat)
 {
@@ -158,22 +162,23 @@ TEST_P(ConvBiasActivInferTestFloatFusionCompileStep, ConvBiasActivAsm1x1UFloat_t
         fusePlanDesc, plan_params, conv_config, test_skipped);
 }
 
-INSTANTIATE_TEST_SUITE_P(CBAInferSolverTest,
-                         ConvBiasActivInferTestFloatFusionCompileStep,
-                         testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetworkForFusionCompileStepTest()),
-                                          testing::Values(miopenTensorNCHW)));
+INSTANTIATE_TEST_SUITE_P(
+    CBAInferSolverTest,
+    ConvBiasActivInferTestFloatFusionCompileStep,
+    testing::Combine(testing::Values(miopenActivationRELU),
+                     testing::ValuesIn(GetNetworkForFusionCompileStepTest<ConvTestCaseBase>()),
+                     testing::Values(miopenTensorNCHW)));
 
 #endif
 
 INSTANTIATE_TEST_SUITE_P(CBAInferSolverTest,
                          ConvBiasActivInferTestFloat,
                          testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetwork1()),
+                                          testing::ValuesIn(GetNetwork1<ConvTestCaseBase>()),
                                           testing::Values(miopenTensorNCHW)));
 
 INSTANTIATE_TEST_SUITE_P(CBAInferSolverTest,
                          ConvBiasActivInferTestHalf,
                          testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetwork1()),
+                                          testing::ValuesIn(GetNetwork1<ConvTestCaseBase>()),
                                           testing::Values(miopenTensorNHWC)));
diff --git a/test/gtest/conv3d_codecov.cpp b/test/gtest/conv3d_codecov.cpp
new file mode 100644
index 0000000000..fe7b2f6987
--- /dev/null
+++ b/test/gtest/conv3d_codecov.cpp
@@ -0,0 +1,163 @@
+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2023 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *******************************************************************************/
+#include <gtest/gtest.h>
+#include <miopen/env.hpp>
+#include "get_handle.hpp"
+#include "test_env.hpp"
+
+#include "conv3d.hpp"
+
+MIOPEN_DECLARE_ENV_VAR_BOOL(CODECOV_TEST)
+MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLAGS_ARGS)
+
+namespace conv3d_codecov {
+
+static bool SkipTest(void) { return !miopen::IsEnabled(ENV(CODECOV_TEST)); }
+
+void GetArgs(const std::string& param, std::vector<std::string>& tokens)
+{
+    std::stringstream ss(param);
+    std::istream_iterator<std::string> begin(ss);
+    std::istream_iterator<std::string> end;
+    while(begin != end)
+        tokens.push_back(*begin++);
+}
+
+void Run3dDriver(miopenDataType_t prec)
+{
+
+    std::vector<std::string> params;
+    switch(prec)
+    {
+    case miopenHalf: params = Conv3dHalf::GetParam(); break;
+    case miopenBFloat16: params = Conv3dBFloat16::GetParam(); break;
+    case miopenFloat: params = Conv3dFloat::GetParam(); break;
+    case miopenInt8: params = Conv3dInt8::GetParam(); break;
+    case miopenFloat8:
+    case miopenBFloat8:
+    case miopenInt32:
+    case miopenDouble:
+        FAIL() << "miopenInt32, miopenDouble, miopenFloat8, miopenBFloat8 "
+                  "data type not supported by "
+                  "conv3d_codecov test";
+
+    default: params = Conv3dFloat::GetParam();
+    }
+
+    for(const auto& test_value : params)
+    {
+        std::vector<std::string> tokens;
+        GetArgs(test_value, tokens);
+        std::vector<const char*> ptrs;
+
+        std::transform(tokens.begin(), tokens.end(), std::back_inserter(ptrs), [](const auto& str) {
+            return str.data();
+        });
+
+        testing::internal::CaptureStderr();
+        test_drive<conv3d_driver>(ptrs.size(), ptrs.data());
+        auto capture = testing::internal::GetCapturedStderr();
+        std::cout << capture;
+    }
+};
+
+bool IsTestSupportedForDevice(const miopen::Handle& handle) { return true; }
+
+std::vector<std::string> GetTestCases(const std::string& precision)
+{
+    const auto& flag_arg = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLAGS_ARGS));
+
+    const std::vector<std::string> test_cases = {
+        // clang-format off
+    {"test_conv3d " + precision + " --input 2 4 4 4 4 --weights 2 4 1 1 1 --pads_strides_dilations 0 0 0 1 1 1 1 1 1 "+flag_arg}
+        // clang-format on
+    };
+
+    return test_cases;
+}
+
+} // namespace conv3d_codecov
+using namespace conv3d_codecov;
+
+TEST_P(Conv3dFloat, FloatTest_conv3d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--float"))
+    {
+        Run3dDriver(miopenFloat);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+TEST_P(Conv3dHalf, HalfTest_conv3d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--half"))
+    {
+        Run3dDriver(miopenHalf);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+TEST_P(Conv3dBFloat16, BFloat16Test_conv3d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--bfloat16"))
+    {
+        Run3dDriver(miopenBFloat16);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+TEST_P(Conv3dInt8, Int8Test_conv3d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--int8"))
+    {
+        Run3dDriver(miopenInt8);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+INSTANTIATE_TEST_SUITE_P(Conv3D, Conv3dFloat, testing::Values(GetTestCases("--float")));
+
+INSTANTIATE_TEST_SUITE_P(Conv3D, Conv3dHalf, testing::Values(GetTestCases("--half")));
+
+INSTANTIATE_TEST_SUITE_P(Conv3D, Conv3dBFloat16, testing::Values(GetTestCases("--bfloat16")));
+
+INSTANTIATE_TEST_SUITE_P(Conv3D, Conv3dInt8, testing::Values(GetTestCases("--int8")));
diff --git a/test/gtest/conv3d_test_case.hpp b/test/gtest/conv3d_test_case.hpp
index 242615077f..2edb1741e9 100644
--- a/test/gtest/conv3d_test_case.hpp
+++ b/test/gtest/conv3d_test_case.hpp
@@ -32,27 +32,7 @@
 
 #include "../driver/tensor_driver.hpp"
 #include "conv_common.hpp"
-
-template <typename T>
-miopenDataType_t GetDataType();
-
-template <>
-miopenDataType_t GetDataType<float>()
-{
-    return miopenFloat;
-}
-
-template <>
-miopenDataType_t GetDataType<half_float::half>()
-{
-    return miopenHalf;
-}
-
-template <>
-miopenDataType_t GetDataType<int8_t>()
-{
-    return miopenInt8;
-}
+#include "conv_test_base.hpp"
 
 struct Conv3DTestCase
 {
diff --git a/test/gtest/conv_2d.hpp b/test/gtest/conv_2d.hpp
deleted file mode 100644
index df73453ef2..0000000000
--- a/test/gtest/conv_2d.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/*******************************************************************************
- *
- * MIT License
- *
- * Copyright (c) 2023 Advanced Micro Devices, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- *******************************************************************************/
-#include "conv_common.hpp"
-
-template <class T>
-struct conv2d_driver : conv_driver<T>
-{
-    conv2d_driver() : conv_driver<T>()
-    {
-        this->add(this->input_dims, "input");
-        this->add(this->weight_tensor_dims, "weights");
-        this->add(this->batch_size,
-                  "batch_size",
-                  this->generate_data_limited(this->get_batch_sizes(), 1));
-        this->add(this->input_channels,
-                  "input_channels",
-                  this->generate_data_limited(this->get_input_channels(), 1, {32}));
-        this->add(this->output_channels,
-                  "output_channels",
-                  this->generate_data_limited(this->get_output_channels(), 1, {64}));
-        this->add(this->spatial_dim_elements,
-                  "spatial_dim_elements",
-                  this->generate_data_limited(this->get_2d_spatial_dims(), 1, {28, 28}));
-        this->add(this->filter_dims,
-                  "filter_dims",
-                  this->generate_data_limited(this->get_2d_filter_dims(), 2, {3, 3}));
-        this->add(this->pads_strides_dilations,
-                  "pads_strides_dilations",
-                  this->generate_data_limited(this->get_2d_pads_strides_dilations(), 2));
-        this->add(this->trans_output_pads,
-                  "trans_output_pads",
-                  this->generate_data(this->get_2d_trans_output_pads()));
-        this->add(this->in_layout, "in_layout", this->generate_data({"NCHW"}));
-        this->add(this->fil_layout, "fil_layout", this->generate_data({"NCHW"}));
-        this->add(this->out_layout, "out_layout", this->generate_data({"NCHW"}));
-        this->add(this->deterministic, "deterministic", this->generate_data({false}));
-        this->add(this->tensor_vect, "tensor_vect", this->generate_data({0}));
-        this->add(this->vector_length, "vector_length", this->generate_data({1}));
-        // Only valid for int8 input and weights
-        this->add(this->output_type, "output_type", this->generate_data({"int32"}));
-        this->add(this->int8_vectorize, "int8_vectorize", this->generate_data({false}));
-    }
-};
diff --git a/test/gtest/conv_embed_db.cpp b/test/gtest/conv_embed_db.cpp
index d20a4d2956..e752cea630 100644
--- a/test/gtest/conv_embed_db.cpp
+++ b/test/gtest/conv_embed_db.cpp
@@ -29,17 +29,12 @@
 #include <gtest/gtest.h>
 #include <miopen/miopen.h>
 #include <miopen/env.hpp>
-#include "../conv2d.hpp"
 #include "get_handle.hpp"
+#include "test_env.hpp"
 
-MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLOAT_ARG)
+#include "../conv2d.hpp"
 
-static bool IsTestRunWith(const char* float_arg)
-{
-    assert(float_arg != nullptr);
-    const auto& s_envVar = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLOAT_ARG));
-    return (s_envVar.compare(float_arg) == 0);
-}
+namespace conv_embed_db {
 
 void GetArgs(const std::string& param, std::vector<std::string>& tokens)
 {
@@ -50,16 +45,16 @@ void GetArgs(const std::string& param, std::vector<std::string>& tokens)
         tokens.push_back(*begin++);
 }
 
-class ConfigWithHalf : public testing::TestWithParam<std::vector<std::string>>
+class ConvEmbedConfigHalf : public testing::TestWithParam<std::vector<std::string>>
 {
 };
-class ConfigWithInt8 : public testing::TestWithParam<std::vector<std::string>>
+class ConvEmbedConfigInt8 : public testing::TestWithParam<std::vector<std::string>>
 {
 };
-class ConfigWithBFloat16 : public testing::TestWithParam<std::vector<std::string>>
+class ConvEmbedConfigBFloat16 : public testing::TestWithParam<std::vector<std::string>>
 {
 };
-class ConfigWithFloat : public testing::TestWithParam<std::vector<std::string>>
+class ConvEmbedConfigFloat : public testing::TestWithParam<std::vector<std::string>>
 {
 };
 
@@ -69,10 +64,10 @@ void Run2dDriver(miopenDataType_t prec)
     std::vector<std::string> params;
     switch(prec)
     {
-    case miopenFloat: params = ConfigWithFloat::GetParam(); break;
-    case miopenHalf: params = ConfigWithHalf::GetParam(); break;
-    case miopenInt8: params = ConfigWithInt8::GetParam(); break;
-    case miopenBFloat16: params = ConfigWithBFloat16::GetParam(); break;
+    case miopenFloat: params = ConvEmbedConfigFloat::GetParam(); break;
+    case miopenHalf: params = ConvEmbedConfigHalf::GetParam(); break;
+    case miopenInt8: params = ConvEmbedConfigInt8::GetParam(); break;
+    case miopenBFloat16: params = ConvEmbedConfigBFloat16::GetParam(); break;
     case miopenInt32:
     case miopenFloat8:
     case miopenBFloat8:
@@ -80,7 +75,7 @@ void Run2dDriver(miopenDataType_t prec)
         FAIL() << "miopenInt32, miopenFloat8, miopenBFloat8, miopenDouble data type "
                   "not supported by conv_embed_db test";
 
-    default: params = ConfigWithFloat::GetParam();
+    default: params = ConvEmbedConfigFloat::GetParam();
     }
 
     for(const auto& test_value : params)
@@ -109,7 +104,47 @@ bool IsTestSupportedForDevice(const miopen::Handle& handle)
         return false;
 }
 
-TEST_P(ConfigWithFloat, FloatTest)
+std::vector<std::string> GetTestCases(const std::string& precision)
+{
+    std::string flags = " --disable-validation --verbose ";
+
+    // If precision env var is not set
+    if(!(IsTestRunWith("--float") || IsTestRunWith("--half") || IsTestRunWith("--int8") ||
+         IsTestRunWith("--bfloat16")))
+        flags.insert(0, precision);
+
+    const std::vector<std::string> test_cases = {
+        // clang-format off
+    {flags + "--input 128 128 28 28 --weights 128 128 3 3 --pads_strides_dilations 1 1 1 1 1 1"},
+    {flags + "--input 128 256 56 56 --weights 512 256 1 1 --pads_strides_dilations 0 0 2 2 1 1"},
+    {flags + "--input 128 3 230 230   --weights 64 3 7 7 --pads_strides_dilations 0 0 2 2 1 1"},
+    {flags + "--input 128 64 56 56 --weights 64 64 3 3 --pads_strides_dilations 1 1 1 1 1 1"},
+    {flags + "--input 128 256 14 14 --weights 256 256 3 3 --pads_strides_dilations 1 1 1 1 1 1"},
+    {flags + "--input 128 512 7 7   --weights 512 512 3 3 --pads_strides_dilations 1 1 1 1 1 1"},
+    {flags + "--input 128 1024 14 14 --weights 512 1024 1 1 --pads_strides_dilations 0 0 2 2 1 1"},
+    {flags + "--input 128 1024 14 14 --weights 2048 1024 1 1 --pads_strides_dilations 0 0 2 2 1 1"},
+    {flags + "--input 128 256 14 14 --weights 1024 256 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
+    {flags + "--input 128 512 28 28 --weights 256 512 1 1 --pads_strides_dilations 0 0 2 2 1 1"},
+    {flags + "--input 128 1024 14 14 --weights 256 1024 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
+    {flags + "--input 128 64 56 56 --weights 256 64 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
+    {flags + "--input 128 64 56 56 --weights 64 64 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
+    {flags + "--input 128 128 28 28 --weights 512 128 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
+    {flags + "--input 128 256 56 56 --weights 128 256 1 1 --pads_strides_dilations 0 0 2 2 1 1"},
+    {flags + "--input 128 256 56 56 --weights 64 256 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
+    {flags + "--input 128 512 28 28 --weights 1024 512 1 1 --pads_strides_dilations 0 0 2 2 1 1"},
+    {flags + "--input 128 512 28 28 --weights 128 512 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
+    {flags + "--input 128 512 7 7   --weights 2048 512 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
+    {flags + "--input 128 2048 7 7 --weights 512 2048 1 1 --pads_strides_dilations 0 0 1 1 1 1"}
+        // clang-format on
+    };
+
+    return test_cases;
+}
+
+} // namespace conv_embed_db
+using namespace conv_embed_db;
+
+TEST_P(ConvEmbedConfigFloat, FloatTest_conv_embed_db)
 {
 #if MIOPEN_EMBED_DB
 
@@ -128,7 +163,7 @@ TEST_P(ConfigWithFloat, FloatTest)
 #endif
 };
 
-TEST_P(ConfigWithHalf, HalfTest)
+TEST_P(ConvEmbedConfigHalf, HalfTest_conv_embed_db)
 {
 #if MIOPEN_EMBED_DB
 
@@ -147,7 +182,7 @@ TEST_P(ConfigWithHalf, HalfTest)
 #endif
 };
 
-TEST_P(ConfigWithInt8, Int8Test)
+TEST_P(ConvEmbedConfigInt8, Int8Test_conv_embed_db)
 {
 #if MIOPEN_EMBED_DB
 
@@ -166,7 +201,7 @@ TEST_P(ConfigWithInt8, Int8Test)
 #endif
 };
 
-TEST_P(ConfigWithBFloat16, BFloat16Test)
+TEST_P(ConvEmbedConfigBFloat16, BFloat16Test_conv_embed_db)
 {
 #if MIOPEN_EMBED_DB
 
@@ -185,46 +220,11 @@ TEST_P(ConfigWithBFloat16, BFloat16Test)
 #endif
 };
 
-std::vector<std::string> GetTestCases(const std::string& precision)
-{
-    std::string flags = " --disable-validation --verbose ";
-
-    // If precision env var is not set
-    if(!(IsTestRunWith("--float") || IsTestRunWith("--half") || IsTestRunWith("--int8") ||
-         IsTestRunWith("--bfloat16")))
-        flags.insert(0, precision);
-
-    const std::vector<std::string> test_cases = {
-        // clang-format off
-    {flags + "--input 128 128 28 28 --weights 128 128 3 3 --pads_strides_dilations 1 1 1 1 1 1"},
-    {flags + "--input 128 256 56 56 --weights 512 256 1 1 --pads_strides_dilations 0 0 2 2 1 1"},
-    {flags + "--input 128 3 230 230   --weights 64 3 7 7 --pads_strides_dilations 0 0 2 2 1 1"},
-    {flags + "--input 128 64 56 56 --weights 64 64 3 3 --pads_strides_dilations 1 1 1 1 1 1"},
-    {flags + "--input 128 256 14 14 --weights 256 256 3 3 --pads_strides_dilations 1 1 1 1 1 1"},
-    {flags + "--input 128 512 7 7   --weights 512 512 3 3 --pads_strides_dilations 1 1 1 1 1 1"},
-    {flags + "--input 128 1024 14 14 --weights 512 1024 1 1 --pads_strides_dilations 0 0 2 2 1 1"},
-    {flags + "--input 128 1024 14 14 --weights 2048 1024 1 1 --pads_strides_dilations 0 0 2 2 1 1"},
-    {flags + "--input 128 256 14 14 --weights 1024 256 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
-    {flags + "--input 128 512 28 28 --weights 256 512 1 1 --pads_strides_dilations 0 0 2 2 1 1"},
-    {flags + "--input 128 1024 14 14 --weights 256 1024 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
-    {flags + "--input 128 64 56 56 --weights 256 64 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
-    {flags + "--input 128 64 56 56 --weights 64 64 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
-    {flags + "--input 128 128 28 28 --weights 512 128 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
-    {flags + "--input 128 256 56 56 --weights 128 256 1 1 --pads_strides_dilations 0 0 2 2 1 1"},
-    {flags + "--input 128 256 56 56 --weights 64 256 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
-    {flags + "--input 128 512 28 28 --weights 1024 512 1 1 --pads_strides_dilations 0 0 2 2 1 1"},
-    {flags + "--input 128 512 28 28 --weights 128 512 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
-    {flags + "--input 128 512 7 7   --weights 2048 512 1 1 --pads_strides_dilations 0 0 1 1 1 1"},
-    {flags + "--input 128 2048 7 7 --weights 512 2048 1 1 --pads_strides_dilations 0 0 1 1 1 1"}
-        // clang-format on
-    };
-
-    return test_cases;
-}
-
-INSTANTIATE_TEST_SUITE_P(ConvEmbedDB, ConfigWithFloat, testing::Values(GetTestCases("--float")));
-INSTANTIATE_TEST_SUITE_P(ConvEmbedDB, ConfigWithHalf, testing::Values(GetTestCases("--half")));
-INSTANTIATE_TEST_SUITE_P(ConvEmbedDB, ConfigWithInt8, testing::Values(GetTestCases("--int8")));
 INSTANTIATE_TEST_SUITE_P(ConvEmbedDB,
-                         ConfigWithBFloat16,
+                         ConvEmbedConfigFloat,
+                         testing::Values(GetTestCases("--float")));
+INSTANTIATE_TEST_SUITE_P(ConvEmbedDB, ConvEmbedConfigHalf, testing::Values(GetTestCases("--half")));
+INSTANTIATE_TEST_SUITE_P(ConvEmbedDB, ConvEmbedConfigInt8, testing::Values(GetTestCases("--int8")));
+INSTANTIATE_TEST_SUITE_P(ConvEmbedDB,
+                         ConvEmbedConfigBFloat16,
                          testing::Values(GetTestCases("--bfloat16")));
diff --git a/test/gtest/conv_f8_bwd.cpp b/test/gtest/conv_f8_bwd.cpp
index 156260f875..e18779b718 100644
--- a/test/gtest/conv_f8_bwd.cpp
+++ b/test/gtest/conv_f8_bwd.cpp
@@ -29,8 +29,10 @@
 #include <serialize.hpp>
 #include "tensor_util.hpp"
 #include "get_handle.hpp"
-#include "conv3d_test_case.hpp"
 #include "f8_cast_util.hpp"
+#include "conv3d_test_case.hpp"
+
+namespace conv_f8_bwd {
 
 std::vector<Conv3DTestCase> ConvTestConfigs()
 { // g    n   c   d    h   w   k   z  y  x pad_x pad_y pad_z stri_x stri_y stri_z dia_x dia_y dia_z
@@ -65,7 +67,7 @@ struct ConvBwdSolverTest
         conv_desc = conv_config.GetConv();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         output = tensor<T>{tensor_layout, output_desc.GetLengths()};
         output.generate(gen_value);
 
@@ -174,6 +176,9 @@ void SolverBwd(const miopen::TensorDescriptor& inputDesc,
     handle.Finish();
 }
 
+} // namespace conv_f8_bwd
+using namespace conv_f8_bwd;
+
 TEST_P(ConvBwdSolverTestF8, CKConvF8Bwd)
 {
     SolverBwd<miopen::solver::conv::ConvHipImplicitGemmF16F8F16BwdXdlops>(input.desc,
diff --git a/test/gtest/conv_f8_fwd.cpp b/test/gtest/conv_f8_fwd.cpp
index 433f9f7fa7..766b8b3d51 100644
--- a/test/gtest/conv_f8_fwd.cpp
+++ b/test/gtest/conv_f8_fwd.cpp
@@ -23,7 +23,6 @@
  * SOFTWARE.
  *
  *******************************************************************************/
-#include "conv3d_test_case.hpp"
 #include <gtest/gtest.h>
 #include <miopen/miopen.h>
 #include <miopen/solver_id.hpp>
@@ -31,6 +30,9 @@
 #include "tensor_util.hpp"
 #include "get_handle.hpp"
 #include "f8_cast_util.hpp"
+#include "conv3d_test_case.hpp"
+
+namespace conv_f8_fwd {
 
 std::vector<Conv3DTestCase> ConvTestConfigs()
 { // g    n   c   d    h   w   k   z  y  x pad_x pad_y pad_z stri_x stri_y stri_z dia_x dia_y dia_z
@@ -65,7 +67,7 @@ struct ConvFwdSolverTest
         weights.desc.SetCastType(miopenFloat8);
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         output = tensor<T>{tensor_layout, output_desc.GetLengths()};
         std::fill(output.begin(), output.end(), std::numeric_limits<double>::quiet_NaN());
         auto&& handle = get_handle();
@@ -81,7 +83,7 @@ struct ConvFwdSolverTest
         auto&& handle = get_handle();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         ref_out        = tensor<T>{tensor_layout, output_desc.GetLengths()};
         using FI       = Fp8Cast<T, T>;
         using FW       = Fp8Cast<T, T>;
@@ -173,6 +175,9 @@ void SolverFwd(const miopen::TensorDescriptor& inputDesc,
     handle.Finish();
 }
 
+} // namespace conv_f8_fwd
+using namespace conv_f8_fwd;
+
 TEST_P(ConvFwdSolverTestF8, CKConvF8Fwd)
 {
     SolverFwd<miopen::solver::conv::ConvHipImplicitGemmF16F8F16FwdXdlops>(input.desc,
diff --git a/test/gtest/conv_f8_wrw.cpp b/test/gtest/conv_f8_wrw.cpp
index 925590833f..07851d4878 100644
--- a/test/gtest/conv_f8_wrw.cpp
+++ b/test/gtest/conv_f8_wrw.cpp
@@ -24,7 +24,6 @@
  *
  *******************************************************************************/
 
-#include "conv3d_test_case.hpp"
 #include <gtest/gtest.h>
 #include <miopen/miopen.h>
 #include <miopen/solver_id.hpp>
@@ -32,6 +31,9 @@
 #include "tensor_util.hpp"
 #include "get_handle.hpp"
 #include "f8_cast_util.hpp"
+#include "conv3d_test_case.hpp"
+
+namespace conv_f8_wrw {
 
 std::vector<Conv3DTestCase> ConvTestConfigs()
 { // g   n   c   d    h   w   k   z  y  x pad_x pad_y pad_z stri_x stri_y stri_z dia_x dia_y dia_z
@@ -68,7 +70,7 @@ struct ConvWrwSolverTest
         conv_desc = conv_config.GetConv();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         output = tensor<T>{tensor_layout, output_desc.GetLengths()};
         output.generate(gen_value);
         auto&& handle = get_handle();
@@ -177,6 +179,8 @@ void SolverWrw(const miopen::TensorDescriptor& inputDesc,
     (invoker)(handle, invoke_params);
     handle.Finish();
 }
+} // namespace conv_f8_wrw
+using namespace conv_f8_wrw;
 
 TEST_P(ConvWrwSolverTestF8, CKConvF8Wrw)
 {
diff --git a/test/gtest/conv_hip_igemm_xdlops.cpp b/test/gtest/conv_hip_igemm_xdlops.cpp
index 26c51ba7e1..fa2d25aad7 100644
--- a/test/gtest/conv_hip_igemm_xdlops.cpp
+++ b/test/gtest/conv_hip_igemm_xdlops.cpp
@@ -29,19 +29,15 @@
 #include <gtest/gtest.h>
 #include <miopen/miopen.h>
 #include <miopen/env.hpp>
-#include "../conv2d.hpp"
 #include "get_handle.hpp"
+#include "test_env.hpp"
+
+#include "../conv2d.hpp"
 
-MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLOAT_ARG)
 MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_COMPOSABLEKERNEL)
 MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_ALL)
 
-static bool IsTestRunWith(const char* float_arg)
-{
-    assert(float_arg != nullptr);
-    const auto& s_envVar = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLOAT_ARG));
-    return (!s_envVar.empty() && std::strcmp(s_envVar.c_str(), float_arg) == 0);
-}
+namespace conv_hip_igemm_xdlops {
 
 void GetArgs(const std::string& param, std::vector<std::string>& tokens)
 {
@@ -52,7 +48,7 @@ void GetArgs(const std::string& param, std::vector<std::string>& tokens)
         tokens.push_back(*begin++);
 }
 
-class ConfigWithInt8 : public testing::TestWithParam<std::vector<std::string>>
+class ConvHipIgemmXdlopsConfigInt8 : public testing::TestWithParam<std::vector<std::string>>
 {
 };
 
@@ -61,7 +57,7 @@ void Run2dDriver(miopenDataType_t prec)
     std::vector<std::string> params;
     switch(prec)
     {
-    case miopenInt8: params = ConfigWithInt8::GetParam(); break;
+    case miopenInt8: params = ConvHipIgemmXdlopsConfigInt8::GetParam(); break;
     case miopenFloat8:
     case miopenBFloat8:
     case miopenHalf:
@@ -74,7 +70,7 @@ void Run2dDriver(miopenDataType_t prec)
                   "type not supported by "
                   "test_conv_hip_igemm_xdlops test";
 
-    default: params = ConfigWithInt8::GetParam();
+    default: params = ConvHipIgemmXdlopsConfigInt8::GetParam();
     }
 
     for(const auto& test_value : params)
@@ -103,26 +99,6 @@ bool IsTestSupportedForDevice(const miopen::Handle& handle)
         return false;
 }
 
-TEST_P(ConfigWithInt8, Int8Test)
-{
-#if MIOPEN_BACKEND_OPENCL
-
-    GTEST_SKIP() << "MIOPEN_BACKEND_HIP needed for this test";
-
-#else // MIOPEN_BACKEND_HIP, OCL_DISABLED
-    const auto& handle = get_handle();
-    if(IsTestSupportedForDevice(handle) && miopen::IsEnabled(ENV(MIOPEN_TEST_COMPOSABLEKERNEL)) &&
-       miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) && IsTestRunWith("--int8"))
-    {
-        Run2dDriver(miopenInt8);
-    }
-    else
-    {
-        GTEST_SKIP();
-    }
-#endif
-};
-
 std::vector<std::string> GetTestCases(const std::string& precision)
 {
     std::string fwd         = " --disable-backward-data --disable-backward-weights --verbose";
@@ -164,6 +140,29 @@ std::vector<std::string> GetTestCases(const std::string& precision)
     return test_cases;
 }
 
+} // namespace conv_hip_igemm_xdlops
+using namespace conv_hip_igemm_xdlops;
+
+TEST_P(ConvHipIgemmXdlopsConfigInt8, Int8Test)
+{
+#if MIOPEN_BACKEND_OPENCL
+
+    GTEST_SKIP() << "MIOPEN_BACKEND_HIP needed for this test";
+
+#else // MIOPEN_BACKEND_HIP, OCL_DISABLED
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && miopen::IsEnabled(ENV(MIOPEN_TEST_COMPOSABLEKERNEL)) &&
+       miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) && IsTestRunWith("--int8"))
+    {
+        Run2dDriver(miopenInt8);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+#endif
+};
+
 INSTANTIATE_TEST_SUITE_P(ConvHipIgemmXdlops,
-                         ConfigWithInt8,
+                         ConvHipIgemmXdlopsConfigInt8,
                          testing::Values(GetTestCases("--int8")));
diff --git a/test/gtest/conv_igemm_dynamic.cpp b/test/gtest/conv_igemm_dynamic.cpp
index 4decf80c2b..676ce1c352 100644
--- a/test/gtest/conv_igemm_dynamic.cpp
+++ b/test/gtest/conv_igemm_dynamic.cpp
@@ -28,13 +28,17 @@
 #include <miopen/miopen.h>
 #include <gtest/gtest.h>
 #include <miopen/miopen.h>
-#include "../conv2d.hpp"
 #include "get_handle.hpp"
+#include "test_env.hpp"
+
+#include "../conv2d.hpp"
 
 using TestCase = std::tuple<std::vector<std::string>, std::string>;
 
 MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_GPU_XNACK_ENABLED)
 
+namespace conv_igemm_dynamic {
+
 static bool SkipTest(void) { return miopen::IsEnabled(ENV(MIOPEN_TEST_GPU_XNACK_ENABLED)); }
 
 void GetArgs(const TestCase& param, std::vector<std::string>& tokens)
@@ -54,7 +58,7 @@ void GetArgs(const TestCase& param, std::vector<std::string>& tokens)
         tokens.push_back(*begin++);
 }
 
-class Conv2dFloat : public testing::TestWithParam<std::vector<TestCase>>
+class Conv2dFloatDynamic : public testing::TestWithParam<std::vector<TestCase>>
 {
 };
 
@@ -64,7 +68,7 @@ void Run2dDriver(miopenDataType_t prec)
     std::vector<TestCase> params;
     switch(prec)
     {
-    case miopenFloat: params = Conv2dFloat::GetParam(); break;
+    case miopenFloat: params = Conv2dFloatDynamic::GetParam(); break;
     case miopenHalf:
     case miopenInt8:
     case miopenBFloat16:
@@ -76,7 +80,7 @@ void Run2dDriver(miopenDataType_t prec)
                   "miopenDouble, miopenFloat8, miopenBFloat8 "
                   "data type not supported by conv_igemm_dynamic test";
 
-    default: params = Conv2dFloat::GetParam();
+    default: params = Conv2dFloatDynamic::GetParam();
     }
 
     for(const auto& test_value : params)
@@ -106,19 +110,6 @@ bool IsTestSupportedForDevice(const miopen::Handle& handle)
         return false;
 }
 
-TEST_P(Conv2dFloat, FloatTest)
-{
-    const auto& handle = get_handle();
-    if(IsTestSupportedForDevice(handle) && !SkipTest())
-    {
-        Run2dDriver(miopenFloat);
-    }
-    else
-    {
-        GTEST_SKIP();
-    }
-};
-
 std::vector<TestCase> GetTestCases(const std::string& precision)
 {
 
@@ -185,4 +176,22 @@ std::vector<TestCase> GetTestCases(const std::string& precision)
     return test_cases;
 }
 
-INSTANTIATE_TEST_SUITE_P(ConvIgemmDynamic, Conv2dFloat, testing::Values(GetTestCases("--float")));
+} // namespace conv_igemm_dynamic
+using namespace conv_igemm_dynamic;
+
+TEST_P(Conv2dFloatDynamic, FloatTest_conv_igemm_dynamic)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--float"))
+    {
+        Run2dDriver(miopenFloat);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+INSTANTIATE_TEST_SUITE_P(ConvIgemmDynamic,
+                         Conv2dFloatDynamic,
+                         testing::Values(GetTestCases("--float")));
diff --git a/test/gtest/conv_igemm_mlir.cpp b/test/gtest/conv_igemm_mlir.cpp
index 23ea66efc1..3b846d6e6c 100644
--- a/test/gtest/conv_igemm_mlir.cpp
+++ b/test/gtest/conv_igemm_mlir.cpp
@@ -29,24 +29,17 @@
 #include <gtest/gtest.h>
 #include <miopen/miopen.h>
 #include <miopen/env.hpp>
-#include "../conv2d.hpp"
 #include "get_handle.hpp"
+#include "test_env.hpp"
+
+#include "../conv2d.hpp"
 
-MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLOAT_ARG)
 MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_MLIR)
 MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_ALL)
 
-using TestCase = std::tuple<std::vector<std::string>, std::string>;
+namespace conv_igemm_mlir {
 
-std::string GetFloatArg()
-{
-    const auto& tmp = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLOAT_ARG));
-    if(tmp.empty())
-    {
-        return "";
-    }
-    return tmp;
-};
+using TestCase = std::tuple<std::vector<std::string>, std::string>;
 
 void GetArgs(const TestCase& param, std::vector<std::string>& tokens)
 {
@@ -65,13 +58,13 @@ void GetArgs(const TestCase& param, std::vector<std::string>& tokens)
         tokens.push_back(*begin++);
 }
 
-class ConfigWithFloat : public testing::TestWithParam<std::vector<TestCase>>
+class ConvIgemmMlirConfigFloat : public testing::TestWithParam<std::vector<TestCase>>
 {
 };
-class ConfigWithHalf : public testing::TestWithParam<std::vector<TestCase>>
+class ConvIgemmMlirConfigHalf : public testing::TestWithParam<std::vector<TestCase>>
 {
 };
-class ConfigWithInt8 : public testing::TestWithParam<std::vector<TestCase>>
+class ConvIgemmMlirConfigInt8 : public testing::TestWithParam<std::vector<TestCase>>
 {
 };
 
@@ -81,9 +74,9 @@ void Run2dDriver(miopenDataType_t prec)
     std::vector<TestCase> params;
     switch(prec)
     {
-    case miopenHalf: params = ConfigWithHalf::GetParam(); break;
-    case miopenInt8: params = ConfigWithInt8::GetParam(); break;
-    case miopenFloat: params = ConfigWithFloat::GetParam(); break;
+    case miopenHalf: params = ConvIgemmMlirConfigHalf::GetParam(); break;
+    case miopenInt8: params = ConvIgemmMlirConfigInt8::GetParam(); break;
+    case miopenFloat: params = ConvIgemmMlirConfigFloat::GetParam(); break;
     case miopenBFloat16:
     case miopenInt32:
     case miopenFloat8:
@@ -93,7 +86,7 @@ void Run2dDriver(miopenDataType_t prec)
                      "miopenBFloat16, miopenInt32, miopenFloat8, miopenBFloat8, "
                      "miopenDouble data type not supported by conv_igemm_mlir test");
 
-    default: params = ConfigWithFloat::GetParam();
+    default: params = ConvIgemmMlirConfigFloat::GetParam();
     }
 
     for(const auto& test_value : params)
@@ -113,72 +106,6 @@ void Run2dDriver(miopenDataType_t prec)
     }
 };
 
-TEST_P(ConfigWithFloat, FloatTest)
-{
-#if MIOPEN_USE_MLIR
-
-    const auto& handle = get_handle();
-    if((miopen::StartsWith(handle.GetDeviceName(), "gfx103") ||
-        miopen::StartsWith(handle.GetDeviceName(), "gfx906")) &&
-       miopen::IsEnabled(ENV(MIOPEN_TEST_MLIR)) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) &&
-       GetFloatArg() == "--float")
-    {
-        Run2dDriver(miopenFloat);
-    }
-    else
-    {
-        GTEST_SKIP();
-    }
-
-#else
-    GTEST_SKIP();
-#endif
-};
-
-TEST_P(ConfigWithHalf, HalfTest)
-{
-#if MIOPEN_USE_MLIR
-
-    const auto& handle = get_handle();
-    if((miopen::StartsWith(handle.GetDeviceName(), "gfx103") ||
-        miopen::StartsWith(handle.GetDeviceName(), "gfx906")) &&
-       miopen::IsEnabled(ENV(MIOPEN_TEST_MLIR)) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) &&
-       GetFloatArg() == "--half")
-    {
-        Run2dDriver(miopenHalf);
-    }
-    else
-    {
-        GTEST_SKIP();
-    }
-
-#else
-    GTEST_SKIP();
-#endif
-};
-
-TEST_P(ConfigWithInt8, Int8Test)
-{
-#if MIOPEN_USE_MLIR
-
-    const auto& handle = get_handle();
-    if((miopen::StartsWith(handle.GetDeviceName(), "gfx103") ||
-        miopen::StartsWith(handle.GetDeviceName(), "gfx906")) &&
-       miopen::IsEnabled(ENV(MIOPEN_TEST_MLIR)) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) &&
-       GetFloatArg() == "--int8")
-    {
-        Run2dDriver(miopenInt8);
-    }
-    else
-    {
-        GTEST_SKIP();
-    }
-
-#else
-    GTEST_SKIP();
-#endif
-};
-
 std::vector<TestCase> GetTestCases(const std::string& precision)
 {
     std::vector<std::string> igemm_fwd = {"MIOPEN_FIND_MODE=normal",
@@ -242,9 +169,85 @@ std::vector<TestCase> GetTestCases(const std::string& precision)
 
     return test_cases;
 }
+
+} // namespace conv_igemm_mlir
+using namespace conv_igemm_mlir;
+
+TEST_P(ConvIgemmMlirConfigFloat, FloatTest_conv_igemm_mlir)
+{
+#if MIOPEN_USE_MLIR
+
+    const auto& handle = get_handle();
+    if((miopen::StartsWith(handle.GetDeviceName(), "gfx103") ||
+        miopen::StartsWith(handle.GetDeviceName(), "gfx906")) &&
+       miopen::IsEnabled(ENV(MIOPEN_TEST_MLIR)) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) &&
+       IsTestRunWith("--float"))
+    {
+        Run2dDriver(miopenFloat);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+
+#else
+    GTEST_SKIP();
+#endif
+};
+
+TEST_P(ConvIgemmMlirConfigHalf, HalfTest_conv_igemm_mlir)
+{
+#if MIOPEN_USE_MLIR
+
+    const auto& handle = get_handle();
+    if((miopen::StartsWith(handle.GetDeviceName(), "gfx103") ||
+        miopen::StartsWith(handle.GetDeviceName(), "gfx906")) &&
+       miopen::IsEnabled(ENV(MIOPEN_TEST_MLIR)) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) &&
+       IsTestRunWith("--half"))
+    {
+        Run2dDriver(miopenHalf);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+
+#else
+    GTEST_SKIP();
+#endif
+};
+
+TEST_P(ConvIgemmMlirConfigInt8, Int8Test_conv_igemm_mlir)
+{
+#if MIOPEN_USE_MLIR
+
+    const auto& handle = get_handle();
+    if((miopen::StartsWith(handle.GetDeviceName(), "gfx103") ||
+        miopen::StartsWith(handle.GetDeviceName(), "gfx906")) &&
+       miopen::IsEnabled(ENV(MIOPEN_TEST_MLIR)) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) &&
+       IsTestRunWith("--int8"))
+    {
+        Run2dDriver(miopenInt8);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+
+#else
+    GTEST_SKIP();
+#endif
+};
+
 // Float for FWD, BWD, WRW
-INSTANTIATE_TEST_SUITE_P(ConvIgemmMlir, ConfigWithFloat, testing::Values(GetTestCases("--float")));
+INSTANTIATE_TEST_SUITE_P(ConvIgemmMlir,
+                         ConvIgemmMlirConfigFloat,
+                         testing::Values(GetTestCases("--float")));
 // Half for FWD, BWD, WRW
-INSTANTIATE_TEST_SUITE_P(ConvIgemmMlir, ConfigWithHalf, testing::Values(GetTestCases("--half")));
+INSTANTIATE_TEST_SUITE_P(ConvIgemmMlir,
+                         ConvIgemmMlirConfigHalf,
+                         testing::Values(GetTestCases("--half")));
 // Int8 for FWD
-INSTANTIATE_TEST_SUITE_P(ConvIgemmMlir, ConfigWithInt8, testing::Values(GetTestCases("--int8")));
+INSTANTIATE_TEST_SUITE_P(ConvIgemmMlir,
+                         ConvIgemmMlirConfigInt8,
+                         testing::Values(GetTestCases("--int8")));
diff --git a/test/gtest/conv_igemm_mlir_xdlops.cpp b/test/gtest/conv_igemm_mlir_xdlops.cpp
index bcc9495204..ff43a91896 100644
--- a/test/gtest/conv_igemm_mlir_xdlops.cpp
+++ b/test/gtest/conv_igemm_mlir_xdlops.cpp
@@ -4,24 +4,17 @@
 #include <gtest/gtest.h>
 #include <miopen/miopen.h>
 #include <miopen/env.hpp>
-#include "conv_2d.hpp"
 #include "get_handle.hpp"
+#include "test_env.hpp"
+
+#include "conv2d.hpp"
 
-MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLOAT_ARG)
 MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_MLIR)
 MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_ALL)
 
-using TestCase = std::tuple<std::vector<std::string>, std::string>;
+namespace conv_igemm_mlir_xdlops {
 
-std::string GetFloatArg()
-{
-    const auto& tmp = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLOAT_ARG));
-    if(tmp.empty())
-    {
-        return "";
-    }
-    return tmp;
-};
+using TestCase = std::tuple<std::vector<std::string>, std::string>;
 
 void GetArgs(const TestCase& param, std::vector<std::string>& tokens)
 {
@@ -40,10 +33,10 @@ void GetArgs(const TestCase& param, std::vector<std::string>& tokens)
         tokens.push_back(*begin++);
 }
 
-class ConfigWithHalf : public testing::TestWithParam<std::vector<TestCase>>
+class ConvIgemmMlirXdlopsConfigHalf : public testing::TestWithParam<std::vector<TestCase>>
 {
 };
-class ConfigWithInt8 : public testing::TestWithParam<std::vector<TestCase>>
+class ConvIgemmMlirXdlopsConfigInt8 : public testing::TestWithParam<std::vector<TestCase>>
 {
 };
 
@@ -53,8 +46,8 @@ void Run2dDriver(miopenDataType_t prec)
     std::vector<TestCase> params;
     switch(prec)
     {
-    case miopenHalf: params = ConfigWithHalf::GetParam(); break;
-    case miopenInt8: params = ConfigWithInt8::GetParam(); break;
+    case miopenHalf: params = ConvIgemmMlirXdlopsConfigHalf::GetParam(); break;
+    case miopenInt8: params = ConvIgemmMlirXdlopsConfigInt8::GetParam(); break;
     case miopenBFloat16:
     case miopenFloat:
     case miopenInt32:
@@ -66,7 +59,7 @@ void Run2dDriver(miopenDataType_t prec)
                      "type not supported by "
                      "conv_igemm_mlir_xdlops test");
 
-    default: params = ConfigWithHalf::GetParam();
+    default: params = ConvIgemmMlirXdlopsConfigHalf::GetParam();
     }
 
     for(const auto& test_value : params)
@@ -86,50 +79,6 @@ void Run2dDriver(miopenDataType_t prec)
     }
 };
 
-TEST_P(ConfigWithHalf, HalfTest)
-{
-#if MIOPEN_USE_MLIR
-
-    const auto& handle = get_handle();
-    if((miopen::StartsWith(handle.GetDeviceName(), "gfx908") ||
-        miopen::StartsWith(handle.GetDeviceName(), "gfx90a")) &&
-       miopen::IsEnabled(ENV(MIOPEN_TEST_MLIR)) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) &&
-       GetFloatArg() == "--half")
-    {
-        Run2dDriver(miopenHalf);
-    }
-    else
-    {
-        GTEST_SKIP();
-    }
-
-#else
-    GTEST_SKIP();
-#endif
-};
-
-TEST_P(ConfigWithInt8, Int8Test)
-{
-#if MIOPEN_USE_MLIR
-
-    const auto& handle = get_handle();
-    if((miopen::StartsWith(handle.GetDeviceName(), "gfx908") ||
-        miopen::StartsWith(handle.GetDeviceName(), "gfx90a")) &&
-       miopen::IsEnabled(ENV(MIOPEN_TEST_MLIR)) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) &&
-       GetFloatArg() == "--int8")
-    {
-        Run2dDriver(miopenInt8);
-    }
-    else
-    {
-        GTEST_SKIP();
-    }
-
-#else
-    GTEST_SKIP();
-#endif
-};
-
 std::vector<TestCase> GetTestCases(const std::string& precision)
 {
     std::vector<std::string> fwd = {"MIOPEN_FIND_MODE=normal",
@@ -194,11 +143,59 @@ std::vector<TestCase> GetTestCases(const std::string& precision)
 
     return test_cases;
 }
+
+} // namespace conv_igemm_mlir_xdlops
+using namespace conv_igemm_mlir_xdlops;
+
+TEST_P(ConvIgemmMlirXdlopsConfigHalf, HalfTest_conv_igemm_mlir_xdlops)
+{
+#if MIOPEN_USE_MLIR
+
+    const auto& handle = get_handle();
+    if((miopen::StartsWith(handle.GetDeviceName(), "gfx908") ||
+        miopen::StartsWith(handle.GetDeviceName(), "gfx90a")) &&
+       miopen::IsEnabled(ENV(MIOPEN_TEST_MLIR)) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) &&
+       IsTestRunWith("--half"))
+    {
+        Run2dDriver(miopenHalf);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+
+#else
+    GTEST_SKIP();
+#endif
+};
+
+TEST_P(ConvIgemmMlirXdlopsConfigInt8, Int8Test_conv_igemm_mlir_xdlops)
+{
+#if MIOPEN_USE_MLIR
+
+    const auto& handle = get_handle();
+    if((miopen::StartsWith(handle.GetDeviceName(), "gfx908") ||
+        miopen::StartsWith(handle.GetDeviceName(), "gfx90a")) &&
+       miopen::IsEnabled(ENV(MIOPEN_TEST_MLIR)) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) &&
+       IsTestRunWith("--int8"))
+    {
+        Run2dDriver(miopenInt8);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+
+#else
+    GTEST_SKIP();
+#endif
+};
+
 // Half for FWD, BWD, WRW
 INSTANTIATE_TEST_SUITE_P(ConvIgemmMlirXdlops,
-                         ConfigWithHalf,
+                         ConvIgemmMlirXdlopsConfigHalf,
                          testing::Values(GetTestCases("--half")));
 // Int8 for FWD
 INSTANTIATE_TEST_SUITE_P(ConvIgemmMlirXdlops,
-                         ConfigWithInt8,
+                         ConvIgemmMlirXdlopsConfigInt8,
                          testing::Values(GetTestCases("--int8")));
diff --git a/test/gtest/conv_tensor_gen.hpp b/test/gtest/conv_tensor_gen.hpp
index f578e91973..572480123d 100644
--- a/test/gtest/conv_tensor_gen.hpp
+++ b/test/gtest/conv_tensor_gen.hpp
@@ -29,6 +29,8 @@
 
 #include <random>
 
+#include <hip_float8.hpp>
+
 // Copied from conv_driver.hpp
 
 template <typename T>
@@ -45,19 +47,19 @@ inline T RAN_GEN(T A, T B)
     return r;
 }
 template <typename T>
-T RanGenData()
+inline T RanGenData()
 {
     return RAN_GEN<T>(static_cast<T>(0.0f), static_cast<T>(1.0f));
 }
 
 template <>
-float8 RanGenData()
+inline float8 RanGenData()
 {
     return RAN_GEN<float8>(static_cast<float8>(-1.0f), static_cast<float8>(1.0f));
 }
 
 template <>
-bfloat8 RanGenData()
+inline bfloat8 RanGenData()
 {
     const auto tmp = RAN_GEN<float>(static_cast<float>(-1.0f), static_cast<float>(1.0f));
     return static_cast<bfloat8>(tmp);
@@ -82,14 +84,14 @@ T RanGenWeights()
 // Shift FP16 distribution towards positive numbers,
 // otherwise Winograd FP16 validation fails.
 template <>
-half_float::half RanGenWeights()
+inline half_float::half RanGenWeights()
 {
     return RAN_GEN<half_float::half>(static_cast<half_float::half>(-1.0 / 3.0),
                                      static_cast<half_float::half>(0.5));
 }
 
 template <>
-float8 RanGenWeights()
+inline float8 RanGenWeights()
 {
     const auto tmp =
         RAN_GEN<float>(0.0, 1.0) > 0.5 ? static_cast<float>(0.0) : static_cast<float>(1.0);
@@ -102,7 +104,7 @@ float8 RanGenWeights()
 }
 
 template <>
-bfloat8 RanGenWeights()
+inline bfloat8 RanGenWeights()
 {
     const auto tmp =
         RAN_GEN<float>(0.0, 1.0) > 0.5 ? static_cast<float>(0.0) : static_cast<float>(1.0);
diff --git a/test/gtest/conv_test_base.hpp b/test/gtest/conv_test_base.hpp
index d41af1d898..e68e346c19 100644
--- a/test/gtest/conv_test_base.hpp
+++ b/test/gtest/conv_test_base.hpp
@@ -28,37 +28,11 @@
 #include <miopen/miopen.h>
 #include <iostream>
 
+#include "tensor_holder.hpp"
 #include "conv_common.hpp"
 #include "conv_tensor_gen.hpp"
 
-template <typename T>
-miopenDataType_t GetDataType();
-
-template <>
-miopenDataType_t GetDataType<float>()
-{
-    return miopenFloat;
-}
-
-template <>
-miopenDataType_t GetDataType<half_float::half>()
-{
-    return miopenHalf;
-}
-
-template <>
-miopenDataType_t GetDataType<miopen_f8::hip_f8<miopen_f8::hip_f8_type::fp8>>()
-{
-    return miopenFloat8;
-}
-
-template <>
-miopenDataType_t GetDataType<miopen_f8::hip_f8<miopen_f8::hip_f8_type::bf8>>()
-{
-    return miopenBFloat8;
-}
-
-struct ConvTestCase
+struct ConvTestCaseBase
 {
     size_t N;
     size_t C;
@@ -74,7 +48,8 @@ struct ConvTestCase
     size_t dilation_x;
     size_t dilation_y;
     miopenConvolutionMode_t conv_mode;
-    friend std::ostream& operator<<(std::ostream& os, const ConvTestCase& tc)
+
+    friend std::ostream& operator<<(std::ostream& os, const ConvTestCaseBase& tc)
     {
         return os << "(N: " << tc.N << " C:" << tc.C << " H:" << tc.H << " W:" << tc.W
                   << " k: " << tc.k << " y:" << tc.y << " x:" << tc.x << " pad_y:" << tc.pad_y
@@ -93,13 +68,21 @@ struct ConvTestCase
     }
 };
 
-std::vector<ConvTestCase> GetNetworkForFusionCompileStepTest()
+template <typename T>
+std::vector<T> GetNetworkForFusionCompileStepTest();
+
+template <>
+inline std::vector<ConvTestCaseBase> GetNetworkForFusionCompileStepTest()
 {
     return {{1, 64, 56, 56, 64, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
             {1, 64, 56, 56, 64, 3, 3, 1, 1, 1, 1, 1, 1, miopenConvolution}};
 }
 
-std::vector<ConvTestCase> GetNetwork1()
+template <typename T>
+std::vector<T> GetNetwork1();
+
+template <>
+inline std::vector<ConvTestCaseBase> GetNetwork1()
 {
     // pyt_mlperf_resnet50v1.5
     return {{64, 1024, 14, 14, 2048, 1, 1, 0, 0, 2, 2, 1, 1, miopenConvolution},
@@ -127,7 +110,11 @@ std::vector<ConvTestCase> GetNetwork1()
             {64, 64, 56, 56, 64, 3, 3, 1, 1, 1, 1, 1, 1, miopenConvolution}};
 }
 
-std::vector<ConvTestCase> ConvTestConfigs()
+template <typename T>
+std::vector<T> ConvTestConfigs();
+
+template <>
+inline std::vector<ConvTestCaseBase> ConvTestConfigs()
 { // n  c   h   w   k   y  x pad_x pad_y stri_x stri_y dia_x dia_y
     return {{16, 128, 16, 16, 128, 3, 3, 1, 1, 1, 1, 1, 1, miopenConvolution},
             {64, 128, 28, 28, 128, 3, 3, 1, 1, 1, 1, 1, 1, miopenConvolution},
@@ -140,7 +127,7 @@ template <typename T, typename Tref = float, bool use_cpu_ref = false>
 struct ConvFwdSolverTestBase
 {
 protected:
-    void SetUpImpl(ConvTestCase conv_config, miopenTensorLayout_t tensor_layout)
+    void SetUpImpl(ConvTestCaseBase conv_config, miopenTensorLayout_t tensor_layout)
     {
         input   = tensor<T>{tensor_layout, conv_config.GetInput()};
         weights = tensor<T>{tensor_layout, conv_config.GetWeights()};
@@ -150,7 +137,7 @@ struct ConvFwdSolverTestBase
         conv_desc = conv_config.GetConv();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
 
         output = tensor<T>{tensor_layout, output_desc.GetLengths()};
         std::fill(output.begin(), output.end(), std::numeric_limits<T>::quiet_NaN());
@@ -164,7 +151,7 @@ struct ConvFwdSolverTestBase
     void TearDownConv()
     {
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         ref_out = tensor<T>{output.desc.GetLayout_t(), output_desc.GetLengths()};
         if(use_cpu_ref)
         {
diff --git a/test/gtest/conv_trans.cpp b/test/gtest/conv_trans.cpp
index 1c887fe24c..9a715e8c6d 100644
--- a/test/gtest/conv_trans.cpp
+++ b/test/gtest/conv_trans.cpp
@@ -32,6 +32,8 @@
 
 MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_ALL)
 
+namespace conv_trans {
+
 void GetArgs(const std::string& param, std::vector<std::string>& tokens)
 {
     std::stringstream ss(param);
@@ -94,19 +96,6 @@ bool IsTestSupportedForDevice(const miopen::Handle& handle)
         return false;
 }
 
-TEST_P(ConfigWithFloat, FloatTest)
-{
-    const auto& handle = get_handle();
-    if(IsTestSupportedForDevice(handle) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)))
-    {
-        Run2dDriver(miopenFloat);
-    }
-    else
-    {
-        GTEST_SKIP();
-    }
-};
-
 std::vector<std::string> GetTestCases(void)
 {
     std::string flags = " --verbose ";
@@ -150,4 +139,20 @@ std::vector<std::string> GetTestCases(void)
     return test_cases;
 }
 
+} // namespace conv_trans
+using namespace conv_trans;
+
+TEST_P(ConfigWithFloat, FloatTest_conv_trans)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)))
+    {
+        Run2dDriver(miopenFloat);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
 INSTANTIATE_TEST_SUITE_P(ConvTrans, ConfigWithFloat, testing::Values(GetTestCases()));
diff --git a/test/gtest/db_sync.cpp b/test/gtest/db_sync.cpp
index 3d06147c69..d89497ef2a 100644
--- a/test/gtest/db_sync.cpp
+++ b/test/gtest/db_sync.cpp
@@ -50,6 +50,8 @@
 #define SKIP_KDB_PDB_TESTING 0       // Allows testing FDB on gfx1030.
 #define SKIP_CONVOCLDIRECTFWDFUSED 0 // Allows testing FDB on gfx1030 (legacy fdb).
 
+MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_DBSYNC)
+
 struct KDBKey
 {
     std::string program_file;
@@ -438,14 +440,17 @@ void SetupPaths(boost::filesystem::path& fdb_file_path,
 
 TEST(DBSync, KDBTargetID)
 {
-    boost::filesystem::path fdb_file_path, pdb_file_path, kdb_file_path;
+    if(miopen::IsEnabled(ENV(MIOPEN_TEST_DBSYNC)))
+    {
+        boost::filesystem::path fdb_file_path, pdb_file_path, kdb_file_path;
 #if WORKAROUND_ISSUE_2493
-    SetEnvironmentVariable("MIOPEN_DEBUG_WORKAROUND_ISSUE_2493", "0");
+        SetEnvironmentVariable("MIOPEN_DEBUG_WORKAROUND_ISSUE_2493", "0");
 #endif
-    SetupPaths(fdb_file_path, pdb_file_path, kdb_file_path, get_handle());
-    std::ignore = fdb_file_path;
-    std::ignore = pdb_file_path;
-    EXPECT_FALSE(!SKIP_KDB_PDB_TESTING && miopen::CheckKDBForTargetID(kdb_file_path));
+        SetupPaths(fdb_file_path, pdb_file_path, kdb_file_path, get_handle());
+        std::ignore = fdb_file_path;
+        std::ignore = pdb_file_path;
+        EXPECT_FALSE(!SKIP_KDB_PDB_TESTING && miopen::CheckKDBForTargetID(kdb_file_path));
+    }
 }
 
 bool LogBuildMessage()
@@ -820,10 +825,13 @@ struct DBSync : testing::TestWithParam<std::pair<std::string, size_t>>
 
 TEST_P(DBSync, StaticFDBSync)
 {
-    std::string arch;
-    size_t num_cu;
-    std::tie(arch, num_cu) = GetParam();
-    StaticFDBSync(arch, num_cu);
+    if(miopen::IsEnabled(ENV(MIOPEN_TEST_DBSYNC)))
+    {
+        std::string arch;
+        size_t num_cu;
+        std::tie(arch, num_cu) = GetParam();
+        StaticFDBSync(arch, num_cu);
+    }
 }
 
 INSTANTIATE_TEST_SUITE_P(DBSyncSuite,
diff --git a/test/gtest/fused_conv_bias_res_add_activ.cpp b/test/gtest/fused_conv_bias_res_add_activ.cpp
index a3d066d82d..4fe66b95b7 100644
--- a/test/gtest/fused_conv_bias_res_add_activ.cpp
+++ b/test/gtest/fused_conv_bias_res_add_activ.cpp
@@ -70,7 +70,7 @@ struct ConvFwdBiasResAddFixture
         conv_desc = conv_config.GetConv();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>());
         output = tensor<T>{tensor_layout, output_desc.GetLengths()};
         std::fill(output.begin(), output.end(), std::numeric_limits<double>::quiet_NaN());
 
@@ -100,7 +100,7 @@ struct ConvFwdBiasResAddFixture
         auto&& handle = get_handle();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>());
 
         ref_out = tensor<T>{tensor_layout, output_desc.GetLengths()};
         ref_out = ref_conv_fwd(input, weights, output, conv_desc);
diff --git a/test/gtest/fusion_test.cpp b/test/gtest/fusion_test.cpp
index e442b4d741..6046fa7e75 100644
--- a/test/gtest/fusion_test.cpp
+++ b/test/gtest/fusion_test.cpp
@@ -99,7 +99,7 @@ TEST_P(FusionSetArgTestFloat, TestSetArgApiCall)
 INSTANTIATE_TEST_SUITE_P(CBAInferSolverTest,
                          FusionSetArgTestFloat,
                          testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(GetNetwork1()),
+                                          testing::ValuesIn(GetNetwork1<ConvTestCaseBase>()),
                                           testing::Values(miopenTensorNCHW)));
 
 #endif
diff --git a/test/gtest/group_conv3d_bwd.cpp b/test/gtest/group_conv3d_bwd.cpp
index 10a63bb2a3..a2a4ed7f3c 100644
--- a/test/gtest/group_conv3d_bwd.cpp
+++ b/test/gtest/group_conv3d_bwd.cpp
@@ -32,6 +32,22 @@
 #include "get_handle.hpp"
 #include "group_conv3d_bwd.hpp"
 
+namespace group_conv3d_bwd {
+
+std::vector<Conv3DTestCase> ConvTestConfigs()
+{ // g    n   c   d    h   w   k   z  y  x pad_x pad_y pad_z stri_x stri_y stri_z dia_x dia_y dia_z
+    return {{1, 1, 4, 14, 28, 28, 4, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {1, 1, 1, 1, 4, 4, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {1, 1, 1, 8, 8, 8, 1, 2, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {1, 1, 1, 8, 8, 8, 1, 2, 2, 2, 0, 0, 0, 2, 2, 2, 1, 1, 1, miopenConvolution},
+            {1, 64, 32, 28, 28, 28, 16, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {16, 128, 16, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {16, 128, 16, 28, 28, 28, 16, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {4, 128, 8, 28, 28, 28, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {4, 128, 4, 28, 28, 28, 8, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {2, 128, 2, 28, 28, 28, 2, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution}};
+}
+
 struct ConvBwdSolverTest3D : ConvBwdSolverTest<float>
 {
 };
@@ -79,6 +95,9 @@ void SolverBwd(const miopen::TensorDescriptor& inputDesc,
     handle.Finish();
 }
 
+} // namespace group_conv3d_bwd
+using namespace group_conv3d_bwd;
+
 TEST_P(ConvBwdSolverTest3D, CKGroupConvBwd3D)
 {
     SolverBwd<miopen::solver::conv::ConvHipImplicitGemm3DGroupBwdXdlops>(input.desc,
diff --git a/test/gtest/group_conv3d_bwd.hpp b/test/gtest/group_conv3d_bwd.hpp
index 9de7b4d18d..41241b605a 100644
--- a/test/gtest/group_conv3d_bwd.hpp
+++ b/test/gtest/group_conv3d_bwd.hpp
@@ -27,20 +27,6 @@
 
 #include "conv3d_test_case.hpp"
 
-std::vector<Conv3DTestCase> ConvTestConfigs()
-{ // g    n   c   d    h   w   k   z  y  x pad_x pad_y pad_z stri_x stri_y stri_z dia_x dia_y dia_z
-    return {{1, 1, 4, 14, 28, 28, 4, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {1, 1, 1, 1, 4, 4, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {1, 1, 1, 8, 8, 8, 1, 2, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {1, 1, 1, 8, 8, 8, 1, 2, 2, 2, 0, 0, 0, 2, 2, 2, 1, 1, 1, miopenConvolution},
-            {1, 64, 32, 28, 28, 28, 16, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {16, 128, 16, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {16, 128, 16, 28, 28, 28, 16, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {4, 128, 8, 28, 28, 28, 4, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {4, 128, 4, 28, 28, 28, 8, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {2, 128, 2, 28, 28, 28, 2, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution}};
-}
-
 inline int SetTensorLayout(miopen::TensorDescriptor& desc)
 {
     // get layout string names
@@ -76,7 +62,7 @@ struct ConvBwdSolverTest
         conv_desc = conv_config.GetConv();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         output = tensor<T>{tensor_layout, output_desc.GetLengths()};
         SetTensorLayout(output.desc);
         output.generate(gen_value);
diff --git a/test/gtest/group_conv3d_fwd.cpp b/test/gtest/group_conv3d_fwd.cpp
index 5e17aa7c0d..879ed24b18 100644
--- a/test/gtest/group_conv3d_fwd.cpp
+++ b/test/gtest/group_conv3d_fwd.cpp
@@ -32,7 +32,26 @@
 #include "get_handle.hpp"
 #include "group_conv3d_fwd.hpp"
 
-struct ConvFwdSolverTest3D : ConvFwdSolverTest<half_float::half>
+namespace group_conv3d_fwd {
+
+std::vector<Conv3DTestCase> ConvTestConfigs()
+{ // g    n   c   d    h   w   k   z  y  x pad_x pad_y pad_z stri_x stri_y stri_z dia_x dia_y dia_z
+    return {{1, 128, 64, 14, 28, 28, 64, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {1, 64, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {2, 128, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {32, 128, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {2, 128, 32, 28, 28, 28, 32, 3, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {8, 64, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {16, 64, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {2, 128, 32, 28, 28, 28, 32, 3, 3, 3, 0, 0, 0, 2, 2, 2, 1, 1, 1, miopenConvolution},
+            {8, 64, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 2, 2, 2, 1, 1, 1, miopenConvolution},
+            {16, 64, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 2, 2, 2, 1, 1, 1, miopenConvolution},
+            {3, 48, 48, 28, 28, 28, 48, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {3, 48, 39, 28, 28, 28, 39, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {5, 120, 60, 28, 28, 28, 60, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution}};
+}
+
+struct ConvGroupFwdSolverTest3D : ConvFwdSolverTest<half_float::half>
 {
 };
 
@@ -78,7 +97,10 @@ void SolverFwd(const miopen::TensorDescriptor& inputDesc,
     handle.Finish();
 }
 
-TEST_P(ConvFwdSolverTest3D, CKGroupConvFwd3D)
+} // namespace group_conv3d_fwd
+using namespace group_conv3d_fwd;
+
+TEST_P(ConvGroupFwdSolverTest3D, CKGroupConvFwd3D)
 {
     SolverFwd<miopen::solver::conv::ConvHipImplicitGemm3DGroupFwdXdlops>(input.desc,
                                                                          in_dev.get(),
@@ -92,7 +114,7 @@ TEST_P(ConvFwdSolverTest3D, CKGroupConvFwd3D)
 }
 
 INSTANTIATE_TEST_SUITE_P(ConvFwdTest,
-                         ConvFwdSolverTest3D,
+                         ConvGroupFwdSolverTest3D,
                          testing::Combine(testing::Values(miopenConvolutionFwdAlgoImplicitGEMM),
                                           testing::ValuesIn(ConvTestConfigs()),
                                           testing::Values(miopenTensorNDHWC)));
diff --git a/test/gtest/group_conv3d_fwd.hpp b/test/gtest/group_conv3d_fwd.hpp
index c5fc432e8b..49a2261537 100644
--- a/test/gtest/group_conv3d_fwd.hpp
+++ b/test/gtest/group_conv3d_fwd.hpp
@@ -27,23 +27,6 @@
 
 #include "conv3d_test_case.hpp"
 
-std::vector<Conv3DTestCase> ConvTestConfigs()
-{ // g    n   c   d    h   w   k   z  y  x pad_x pad_y pad_z stri_x stri_y stri_z dia_x dia_y dia_z
-    return {{1, 128, 64, 14, 28, 28, 64, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {1, 64, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {2, 128, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {32, 128, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {2, 128, 32, 28, 28, 28, 32, 3, 3, 3, 0, 0, 0, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {8, 64, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {16, 64, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {2, 128, 32, 28, 28, 28, 32, 3, 3, 3, 0, 0, 0, 2, 2, 2, 1, 1, 1, miopenConvolution},
-            {8, 64, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 2, 2, 2, 1, 1, 1, miopenConvolution},
-            {16, 64, 32, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 2, 2, 2, 1, 1, 1, miopenConvolution},
-            {3, 48, 48, 28, 28, 28, 48, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {3, 48, 39, 28, 28, 28, 39, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {5, 120, 60, 28, 28, 28, 60, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution}};
-}
-
 inline int SetTensorLayout(miopen::TensorDescriptor& desc)
 {
     // get layout string names
@@ -79,7 +62,7 @@ struct ConvFwdSolverTest
         conv_desc = conv_config.GetConv();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         output = tensor<T>{tensor_layout, output_desc.GetLengths()};
         SetTensorLayout(output.desc);
         std::fill(output.begin(), output.end(), std::numeric_limits<double>::quiet_NaN());
@@ -96,7 +79,7 @@ struct ConvFwdSolverTest
         auto&& handle = get_handle();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         ref_out     = tensor<T>{tensor_layout, output_desc.GetLengths()};
         ref_out     = ref_conv_fwd(input, weights, output, conv_desc);
         output.data = handle.Read<T>(out_dev, output.data.size());
diff --git a/test/gtest/group_conv3d_wrw.cpp b/test/gtest/group_conv3d_wrw.cpp
index 7d3e31da5e..fe629a5315 100644
--- a/test/gtest/group_conv3d_wrw.cpp
+++ b/test/gtest/group_conv3d_wrw.cpp
@@ -32,6 +32,24 @@
 #include "get_handle.hpp"
 #include "group_conv3d_wrw.hpp"
 
+namespace group_conv3d_wrw {
+
+std::vector<Conv3DTestCase> ConvTestConfigs()
+{ // g   n   c   d    h   w   k   z  y  x pad_x pad_y pad_z stri_x stri_y stri_z dia_x dia_y dia_z
+    return {{1, 1, 4, 14, 28, 28, 4, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {1, 1, 1, 1, 4, 4, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {1, 1, 1, 8, 8, 8, 1, 2, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {1, 1, 1, 8, 8, 8, 1, 2, 2, 2, 0, 0, 0, 2, 2, 2, 1, 1, 1, miopenConvolution},
+            {1, 64, 5, 28, 28, 28, 9, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {2, 128, 4, 28, 28, 28, 10, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {16, 128, 32, 28, 28, 28, 32, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {8, 64, 32, 28, 28, 28, 16, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {16, 64, 16, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {3, 48, 48, 28, 28, 28, 48, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {3, 48, 39, 28, 28, 28, 12, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
+            {5, 120, 10, 28, 28, 28, 30, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution}};
+}
+
 struct ConvWrwSolverTest3D : ConvWrwSolverTest<float>
 {
 };
@@ -79,6 +97,9 @@ void SolverWrw(const miopen::TensorDescriptor& inputDesc,
     handle.Finish();
 }
 
+} // namespace group_conv3d_wrw
+using namespace group_conv3d_wrw;
+
 TEST_P(ConvWrwSolverTest3D, CKGroupConvWrw3D)
 {
     SolverWrw<miopen::solver::conv::ConvHipImplicitGemm3DGroupWrwXdlops>(input.desc,
diff --git a/test/gtest/group_conv3d_wrw.hpp b/test/gtest/group_conv3d_wrw.hpp
index 41d390d1f6..492d332892 100644
--- a/test/gtest/group_conv3d_wrw.hpp
+++ b/test/gtest/group_conv3d_wrw.hpp
@@ -27,22 +27,6 @@
 
 #include "conv3d_test_case.hpp"
 
-std::vector<Conv3DTestCase> ConvTestConfigs()
-{ // g   n   c   d    h   w   k   z  y  x pad_x pad_y pad_z stri_x stri_y stri_z dia_x dia_y dia_z
-    return {{1, 1, 4, 14, 28, 28, 4, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {1, 1, 1, 1, 4, 4, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {1, 1, 1, 8, 8, 8, 1, 2, 2, 2, 0, 0, 0, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {1, 1, 1, 8, 8, 8, 1, 2, 2, 2, 0, 0, 0, 2, 2, 2, 1, 1, 1, miopenConvolution},
-            {1, 64, 5, 28, 28, 28, 9, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {2, 128, 4, 28, 28, 28, 10, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {16, 128, 32, 28, 28, 28, 32, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {8, 64, 32, 28, 28, 28, 16, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {16, 64, 16, 28, 28, 28, 32, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {3, 48, 48, 28, 28, 28, 48, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {3, 48, 39, 28, 28, 28, 12, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
-            {5, 120, 10, 28, 28, 28, 30, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution}};
-}
-
 inline int SetTensorLayout(miopen::TensorDescriptor& desc)
 {
     // get layout string names
@@ -78,7 +62,7 @@ struct ConvWrwSolverTest
         conv_desc = conv_config.GetConv();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         output = tensor<T>{tensor_layout, output_desc.GetLengths()};
         output.generate(gen_value);
         auto&& handle = get_handle();
diff --git a/test/gtest/group_conv_fwd.cpp b/test/gtest/group_conv_fwd.cpp
index 4efea68c1d..7523ca964f 100644
--- a/test/gtest/group_conv_fwd.cpp
+++ b/test/gtest/group_conv_fwd.cpp
@@ -32,7 +32,7 @@
 #include "get_handle.hpp"
 #include "group_solver.hpp"
 
-struct ConvFwdSolverTestFloat : ConvFwdSolverTest<float>
+struct ConvGroupFwdSolverTestFloat : ConvGroupFwdSolverTest<float>
 {
 };
 
@@ -44,7 +44,7 @@ void SolverFwd(const miopen::TensorDescriptor& inputDesc,
                const miopen::TensorDescriptor& outputDesc,
                Data_t output,
                const miopen::ConvolutionDescriptor& convDesc,
-               const ConvTestCase& conv_config,
+               const ConvTestCaseGroup& conv_config,
                bool& test_skipped)
 {
     auto&& handle = get_handle();
@@ -78,7 +78,7 @@ void SolverFwd(const miopen::TensorDescriptor& inputDesc,
     handle.Finish();
 }
 
-TEST_P(ConvFwdSolverTestFloat, CKGroupConvFwd)
+TEST_P(ConvGroupFwdSolverTestFloat, CKGroupConvFwd)
 {
     SolverFwd<miopen::solver::conv::ConvHipImplicitGemmGroupFwdXdlops>(input.desc,
                                                                        in_dev.get(),
@@ -92,7 +92,7 @@ TEST_P(ConvFwdSolverTestFloat, CKGroupConvFwd)
 }
 
 INSTANTIATE_TEST_SUITE_P(ConvFwdTest,
-                         ConvFwdSolverTestFloat,
+                         ConvGroupFwdSolverTestFloat,
                          testing::Combine(testing::Values(miopenConvolutionFwdAlgoImplicitGEMM),
-                                          testing::ValuesIn(ConvTestConfigs()),
+                                          testing::ValuesIn(ConvTestConfigs<ConvTestCaseGroup>()),
                                           testing::Values(miopenTensorNHWC)));
diff --git a/test/gtest/group_solver.hpp b/test/gtest/group_solver.hpp
index 10faed9880..3d50fd05c5 100644
--- a/test/gtest/group_solver.hpp
+++ b/test/gtest/group_solver.hpp
@@ -32,29 +32,9 @@
 
 #include "../driver/tensor_driver.hpp"
 #include "conv_common.hpp"
+#include "conv_test_base.hpp"
 
-template <typename T>
-miopenDataType_t GetDataType();
-
-template <>
-miopenDataType_t GetDataType<float>()
-{
-    return miopenFloat;
-}
-
-template <>
-miopenDataType_t GetDataType<half_float::half>()
-{
-    return miopenHalf;
-}
-
-template <>
-miopenDataType_t GetDataType<int8_t>()
-{
-    return miopenInt8;
-}
-
-struct ConvTestCase
+struct ConvTestCaseGroup
 {
     size_t G;
     size_t N;
@@ -71,7 +51,7 @@ struct ConvTestCase
     size_t dilation_x;
     size_t dilation_y;
     miopenConvolutionMode_t conv_mode;
-    friend std::ostream& operator<<(std::ostream& os, const ConvTestCase& tc)
+    friend std::ostream& operator<<(std::ostream& os, const ConvTestCaseGroup& tc)
     {
         return os << " G:" << tc.G << " N:" << tc.N << " C:" << tc.C << " H:" << tc.H
                   << " W:" << tc.W << " k:" << tc.k << " y:" << tc.y << " x:" << tc.x
@@ -101,7 +81,8 @@ struct ConvTestCase
     }
 };
 
-std::vector<ConvTestCase> ConvTestConfigs()
+template <>
+inline std::vector<ConvTestCaseGroup> ConvTestConfigs()
 { // g  n  c   h   w   k   y  x pad_x pad_y stri_x stri_y dia_x dia_y
     return {{1, 256, 192, 28, 28, 192, 3, 3, 1, 1, 1, 1, 1, 1, miopenConvolution},
             {1, 256, 12, 28, 28, 12, 3, 3, 1, 1, 1, 1, 1, 1, miopenConvolution},
@@ -111,7 +92,7 @@ std::vector<ConvTestCase> ConvTestConfigs()
             {32, 256, 1024, 28, 28, 2048, 3, 3, 1, 1, 1, 1, 1, 1, miopenConvolution}};
 }
 
-inline int SetTensorLayout(miopen::TensorDescriptor& desc)
+static int SetTensorLayout(miopen::TensorDescriptor& desc)
 {
     // get layout string names
     std::string layout_str = desc.GetLayout_str();
@@ -124,9 +105,9 @@ inline int SetTensorLayout(miopen::TensorDescriptor& desc)
 }
 
 template <typename T = float>
-struct ConvFwdSolverTest
+struct ConvGroupFwdSolverTest
     : public ::testing::TestWithParam<
-          std::tuple<miopenConvFwdAlgorithm_t, ConvTestCase, miopenTensorLayout_t>>
+          std::tuple<miopenConvFwdAlgorithm_t, ConvTestCaseGroup, miopenTensorLayout_t>>
 {
 protected:
     void SetUp() override
@@ -147,7 +128,7 @@ struct ConvFwdSolverTest
         conv_desc = conv_config.GetConv();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         output = tensor<T>{tensor_layout, output_desc.GetLengths()};
         SetTensorLayout(output.desc);
         std::fill(output.begin(), output.end(), std::numeric_limits<double>::quiet_NaN());
@@ -165,7 +146,7 @@ struct ConvFwdSolverTest
         auto&& handle = get_handle();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         ref_out     = tensor<T>{tensor_layout, output_desc.GetLengths()};
         ref_out     = ref_conv_fwd(input, weights, output, conv_desc);
         output.data = handle.Read<T>(out_dev, output.data.size());
@@ -183,7 +164,7 @@ struct ConvFwdSolverTest
         EXPECT_TRUE(error < threshold)
             << "Error beyond tolerance Error:" << error << ",  Threshold: " << threshold;
     }
-    ConvTestCase conv_config;
+    ConvTestCaseGroup conv_config;
     miopen::ConvolutionDescriptor conv_desc;
     tensor<T> input;
     tensor<T> weights;
diff --git a/test/gtest/immed_conv2d_codecov.cpp b/test/gtest/immed_conv2d_codecov.cpp
new file mode 100644
index 0000000000..5d4153bc53
--- /dev/null
+++ b/test/gtest/immed_conv2d_codecov.cpp
@@ -0,0 +1,212 @@
+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2023 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *******************************************************************************/
+#include "conv_common.hpp"
+#include "get_handle.hpp"
+#include <miopen/env.hpp>
+#include <gtest/gtest.h>
+#include "test_env.hpp"
+
+MIOPEN_DECLARE_ENV_VAR_BOOL(CODECOV_TEST)
+MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLAGS_ARGS)
+
+namespace immed_conv2d_codecov {
+
+template <class T>
+struct conv2d_driver : conv_driver<T, ConvApi::Immediate>
+{
+    conv2d_driver() : conv_driver<T, ConvApi::Immediate>()
+    {
+        this->add(this->input_dims, "input");
+        this->add(this->weight_tensor_dims, "weights");
+        this->add(this->batch_size,
+                  "batch_size",
+                  this->generate_data_limited(this->get_batch_sizes(), 1, {16}));
+        this->add(this->input_channels,
+                  "input_channels",
+                  this->generate_data_limited(this->get_input_channels(), 1, {32}));
+        this->add(this->output_channels,
+                  "output_channels",
+                  this->generate_data_limited(this->get_output_channels(), 1, {32}));
+        this->add(this->spatial_dim_elements,
+                  "spatial_dim_elements",
+                  this->generate_data_limited(this->get_2d_spatial_dims(), 1, {56, 56}));
+        this->add(this->filter_dims,
+                  "filter_dims",
+                  this->generate_data_limited(this->get_2d_filter_dims(), 2, {3, 3}));
+        this->add(this->pads_strides_dilations,
+                  "pads_strides_dilations",
+                  this->generate_data_limited(this->get_2d_pads_strides_dilations(), 2));
+        this->add(this->trans_output_pads,
+                  "trans_output_pads",
+                  this->generate_data_limited(this->get_2d_trans_output_pads(), 1));
+        this->add(this->in_layout, "in_layout", this->generate_data({"NCHW"}));
+        this->add(this->fil_layout, "fil_layout", this->generate_data({"NCHW"}));
+        this->add(this->out_layout, "out_layout", this->generate_data({"NCHW"}));
+    }
+};
+
+static bool SkipTest(void) { return !miopen::IsEnabled(ENV(CODECOV_TEST)); }
+
+void GetArgs(const std::string& param, std::vector<std::string>& tokens)
+{
+    std::stringstream ss(param);
+    std::istream_iterator<std::string> begin(ss);
+    std::istream_iterator<std::string> end;
+    while(begin != end)
+        tokens.push_back(*begin++);
+}
+
+class Conv2dFloat : public testing::TestWithParam<std::vector<std::string>>
+{
+};
+
+class Conv2dHalf : public testing::TestWithParam<std::vector<std::string>>
+{
+};
+
+class Conv2dBFloat16 : public testing::TestWithParam<std::vector<std::string>>
+{
+};
+
+class Conv2dInt8 : public testing::TestWithParam<std::vector<std::string>>
+{
+};
+
+void Run2dDriver(miopenDataType_t prec)
+{
+
+    std::vector<std::string> params;
+    switch(prec)
+    {
+    case miopenHalf: params = Conv2dHalf::GetParam(); break;
+    case miopenBFloat16: params = Conv2dBFloat16::GetParam(); break;
+    case miopenFloat: params = Conv2dFloat::GetParam(); break;
+    case miopenInt8: params = Conv2dInt8::GetParam(); break;
+    case miopenFloat8:
+    case miopenBFloat8:
+    case miopenInt32:
+    case miopenDouble:
+        FAIL() << "miopenInt32, miopenDouble, miopenFloat8, miopenBFloat8 "
+                  "data type not supported by "
+                  "immed_conv2d_codecov test";
+
+    default: params = Conv2dFloat::GetParam();
+    }
+
+    for(const auto& test_value : params)
+    {
+        std::vector<std::string> tokens;
+        GetArgs(test_value, tokens);
+        std::vector<const char*> ptrs;
+
+        std::transform(tokens.begin(), tokens.end(), std::back_inserter(ptrs), [](const auto& str) {
+            return str.data();
+        });
+
+        testing::internal::CaptureStderr();
+        test_drive<conv2d_driver>(ptrs.size(), ptrs.data());
+        auto capture = testing::internal::GetCapturedStderr();
+        std::cout << capture;
+    }
+};
+
+bool IsTestSupportedForDevice(const miopen::Handle& handle) { return true; }
+
+std::vector<std::string> GetTestCases(const std::string& precision)
+{
+    const auto& flag_arg = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLAGS_ARGS));
+
+    const std::vector<std::string> test_cases = {
+        // clang-format off
+    {"test_immed_conv2d " + precision + " --input  2 2 14 14 --weights 8 2 3 3 --pads_strides_dilations 0 0 1 1 1 1 "+flag_arg}
+        // clang-format on
+    };
+
+    return test_cases;
+}
+
+} // namespace immed_conv2d_codecov
+using namespace immed_conv2d_codecov;
+
+TEST_P(Conv2dFloat, FloatTest_immed_conv2d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--float"))
+    {
+        Run2dDriver(miopenFloat);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+TEST_P(Conv2dHalf, HalfTest_immed_conv2d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--half"))
+    {
+        Run2dDriver(miopenHalf);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+TEST_P(Conv2dBFloat16, BFloat16Test_immed_conv2d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--bfloat16"))
+    {
+        Run2dDriver(miopenBFloat16);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+TEST_P(Conv2dInt8, Int8Test_immed_conv2d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--int8"))
+    {
+        Run2dDriver(miopenInt8);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+INSTANTIATE_TEST_SUITE_P(ImmedConv2D, Conv2dFloat, testing::Values(GetTestCases("--float")));
+
+INSTANTIATE_TEST_SUITE_P(ImmedConv2D, Conv2dHalf, testing::Values(GetTestCases("--half")));
+
+INSTANTIATE_TEST_SUITE_P(ImmedConv2D, Conv2dBFloat16, testing::Values(GetTestCases("--bfloat16")));
+
+INSTANTIATE_TEST_SUITE_P(ImmedConv2D, Conv2dInt8, testing::Values(GetTestCases("--int8")));
diff --git a/test/gtest/immed_conv3d_codecov.cpp b/test/gtest/immed_conv3d_codecov.cpp
new file mode 100644
index 0000000000..e1223906c9
--- /dev/null
+++ b/test/gtest/immed_conv3d_codecov.cpp
@@ -0,0 +1,197 @@
+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2023 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *******************************************************************************/
+#include <gtest/gtest.h>
+#include <miopen/env.hpp>
+#include "get_handle.hpp"
+#include "test_env.hpp"
+
+#include "conv3d.hpp"
+
+MIOPEN_DECLARE_ENV_VAR_BOOL(CODECOV_TEST)
+MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLAGS_ARGS)
+
+namespace immed_conv3d_codecov {
+
+template <class T>
+struct conv3d_driver : conv_driver<T, ConvApi::Immediate>
+{
+    conv3d_driver() : conv_driver<T, ConvApi::Immediate>()
+    {
+        this->add(this->input_dims, "input");
+        this->add(this->weight_tensor_dims, "weights");
+        this->add(this->batch_size,
+                  "batch_size",
+                  this->generate_data_limited(this->get_batch_sizes(), 1, {8}));
+        this->add(this->input_channels,
+                  "input_channels",
+                  this->generate_data_limited(this->get_input_channels(), 1, {2}));
+        this->add(this->output_channels,
+                  "output_channels",
+                  this->generate_data_limited(this->get_output_channels(), 1, {16}));
+        this->add(this->spatial_dim_elements,
+                  "spatial_dim_elements",
+                  this->generate_data_limited(this->get_3d_spatial_dims(), 1, {16, 16, 16}));
+        this->add(this->filter_dims,
+                  "filter_dims",
+                  this->generate_data_limited(this->get_3d_filter_dims(), 2, {5, 5, 5}));
+        this->add(this->pads_strides_dilations,
+                  "pads_strides_dilations",
+                  this->generate_data_limited(this->get_3d_pads_strides_dilations(), 2));
+        this->add(this->trans_output_pads,
+                  "trans_output_pads",
+                  this->generate_data_limited(this->get_3d_trans_output_pads(), 1));
+        this->add(this->in_layout, "in_layout", this->generate_data({"NCDHW"}));
+        this->add(this->fil_layout, "fil_layout", this->generate_data({"NCDHW"}));
+        this->add(this->out_layout, "out_layout", this->generate_data({"NCDHW"}));
+    }
+};
+
+static bool SkipTest(void) { return !miopen::IsEnabled(ENV(CODECOV_TEST)); }
+
+void GetArgs(const std::string& param, std::vector<std::string>& tokens)
+{
+    std::stringstream ss(param);
+    std::istream_iterator<std::string> begin(ss);
+    std::istream_iterator<std::string> end;
+    while(begin != end)
+        tokens.push_back(*begin++);
+}
+
+void Run3dDriver(miopenDataType_t prec)
+{
+
+    std::vector<std::string> params;
+    switch(prec)
+    {
+    case miopenHalf: params = Conv3dHalf::GetParam(); break;
+    case miopenBFloat16: params = Conv3dBFloat16::GetParam(); break;
+    case miopenFloat: params = Conv3dFloat::GetParam(); break;
+    case miopenInt8: params = Conv3dInt8::GetParam(); break;
+    case miopenFloat8:
+    case miopenBFloat8:
+    case miopenInt32:
+    case miopenDouble:
+        FAIL() << "miopenInt32, miopenDouble, miopenFloat8, miopenBFloat8 "
+                  "data type not supported by "
+                  "immed_conv3d_codecov test";
+
+    default: params = Conv3dFloat::GetParam();
+    }
+
+    for(const auto& test_value : params)
+    {
+        std::vector<std::string> tokens;
+        GetArgs(test_value, tokens);
+        std::vector<const char*> ptrs;
+
+        std::transform(tokens.begin(), tokens.end(), std::back_inserter(ptrs), [](const auto& str) {
+            return str.data();
+        });
+
+        testing::internal::CaptureStderr();
+        test_drive<conv3d_driver>(ptrs.size(), ptrs.data());
+        auto capture = testing::internal::GetCapturedStderr();
+        std::cout << capture;
+    }
+};
+
+bool IsTestSupportedForDevice(const miopen::Handle& handle) { return true; }
+
+std::vector<std::string> GetTestCases(const std::string& precision)
+{
+    const auto& flag_arg = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLAGS_ARGS));
+
+    const std::vector<std::string> test_cases = {
+        // clang-format off
+    {"test_immed_conv3d " + precision + " --input 1 4 4 4 4 --weights 2 4 3 3 3 --pads_strides_dilations 0 0 0 1 1 1 1 1 1 "+flag_arg}
+        // clang-format on
+    };
+
+    return test_cases;
+}
+
+} // namespace immed_conv3d_codecov
+using namespace immed_conv3d_codecov;
+
+TEST_P(Conv3dFloat, FloatTest_immed_conv3d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--float"))
+    {
+        Run3dDriver(miopenFloat);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+TEST_P(Conv3dHalf, HalfTest_immed_conv3d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--half"))
+    {
+        Run3dDriver(miopenHalf);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+TEST_P(Conv3dBFloat16, BFloat16Test_immed_conv3d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--bfloat16"))
+    {
+        Run3dDriver(miopenBFloat16);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+TEST_P(Conv3dInt8, Int8Test_immed_conv3d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--int8"))
+    {
+        Run3dDriver(miopenInt8);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+INSTANTIATE_TEST_SUITE_P(ImmedConv3D, Conv3dFloat, testing::Values(GetTestCases("--float")));
+
+INSTANTIATE_TEST_SUITE_P(ImmedConv3D, Conv3dHalf, testing::Values(GetTestCases("--half")));
+
+INSTANTIATE_TEST_SUITE_P(ImmedConv3D, Conv3dBFloat16, testing::Values(GetTestCases("--bfloat16")));
+
+INSTANTIATE_TEST_SUITE_P(ImmedConv3D, Conv3dInt8, testing::Values(GetTestCases("--int8")));
diff --git a/test/gtest/layernorm.cpp b/test/gtest/layernorm.cpp
index 8827aec465..257802fc53 100644
--- a/test/gtest/layernorm.cpp
+++ b/test/gtest/layernorm.cpp
@@ -29,6 +29,8 @@
 MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLOAT_ARG)
 MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_ALL)
 
+namespace layernorm {
+
 std::string GetFloatArg()
 {
     const auto& tmp = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLOAT_ARG));
@@ -43,6 +45,9 @@ struct LayerNormTestFloat : LayerNormTest<float>
 {
 };
 
+} // namespace layernorm
+using namespace layernorm;
+
 TEST_P(LayerNormTestFloat, LayerNormTestFw)
 {
     const auto& handle = get_handle();
diff --git a/test/gtest/layernorm.hpp b/test/gtest/layernorm.hpp
index 63158ef134..f93071c915 100644
--- a/test/gtest/layernorm.hpp
+++ b/test/gtest/layernorm.hpp
@@ -151,7 +151,7 @@ std::vector<LayerNormTestCase> LayerNormTestConfigs()
     // clang-format on
 }
 
-inline int32_t SetTensorLayout(miopen::TensorDescriptor& desc)
+static int32_t SetTensorLayout(miopen::TensorDescriptor& desc)
 {
     std::vector<std::size_t> lens = desc.GetLengths();
     std::vector<int32_t> int32_t_lens(lens.begin(), lens.end());
@@ -168,6 +168,7 @@ struct LayerNormTest : public ::testing::TestWithParam<LayerNormTestCase>
     {
         auto&& handle    = get_handle();
         layernorm_config = GetParam();
+
         std::mt19937 gen(0);
         std::uniform_real_distribution<> d{-3, 3};
         auto gen_value = [&](auto...) { return d(gen); };
diff --git a/test/gtest/na.hpp b/test/gtest/na.hpp
index 387f88e12c..663b84962e 100644
--- a/test/gtest/na.hpp
+++ b/test/gtest/na.hpp
@@ -54,7 +54,7 @@ struct BNTestCase
     std::vector<size_t> GetInput() { return {N, C, H, W}; }
 };
 
-std::vector<BNTestCase> Network1()
+std::vector<BNTestCase> Networkna1()
 {
     // pyt_mlperf_resnet50v1.5
     return {
diff --git a/test/gtest/na_infer.cpp b/test/gtest/na_infer.cpp
index f0d3407b2b..d14b0cf8d0 100644
--- a/test/gtest/na_infer.cpp
+++ b/test/gtest/na_infer.cpp
@@ -71,7 +71,7 @@ TEST_P(BNActivInferFloat, BnFwdInferActivationFused)
 INSTANTIATE_TEST_SUITE_P(BNActivInferFloatSuite,
                          BNActivInferFloat,
                          testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(Network1())));
+                                          testing::ValuesIn(Networkna1())));
 TEST_P(BNActivInferHalf, DISABLED_BnFwdInferActivationFused)
 {
     const auto plan_params = miopen::fusion::FusionInvokeParams(
@@ -83,4 +83,4 @@ TEST_P(BNActivInferHalf, DISABLED_BnFwdInferActivationFused)
 INSTANTIATE_TEST_SUITE_P(BNActivInferHalfSuite,
                          BNActivInferHalf,
                          testing::Combine(testing::Values(miopenActivationRELU),
-                                          testing::ValuesIn(Network1())));
+                                          testing::ValuesIn(Networkna1())));
diff --git a/test/gtest/nonpack_conv3d_fwd.cpp b/test/gtest/nonpack_conv3d_fwd.cpp
index 0d08e5215a..64a6ef5eb8 100644
--- a/test/gtest/nonpack_conv3d_fwd.cpp
+++ b/test/gtest/nonpack_conv3d_fwd.cpp
@@ -32,7 +32,7 @@
 #include "get_handle.hpp"
 #include "nonpack_conv3d_fwd.hpp"
 
-struct ConvFwdSolverTest3D : ConvFwdSolverTest<half_float::half>
+struct ConvNonpackFwdSolverTest3DHalf : ConvNonpackFwdSolverTest3D<half_float::half>
 {
 };
 
@@ -78,7 +78,7 @@ void SolverFwd(const miopen::TensorDescriptor& inputDesc,
     handle.Finish();
 }
 
-TEST_P(ConvFwdSolverTest3D, CKNonPackConvFwd3D)
+TEST_P(ConvNonpackFwdSolverTest3DHalf, CKNonPackConvFwd3D)
 {
     SolverFwd<miopen::solver::conv::ConvHipImplicitGemm3DGroupFwdXdlops>(input.desc,
                                                                          in_dev.get(),
@@ -92,7 +92,7 @@ TEST_P(ConvFwdSolverTest3D, CKNonPackConvFwd3D)
 }
 
 INSTANTIATE_TEST_SUITE_P(ConvFwdTest,
-                         ConvFwdSolverTest3D,
+                         ConvNonpackFwdSolverTest3DHalf,
                          testing::Combine(testing::Values(miopenConvolutionFwdAlgoImplicitGEMM),
-                                          testing::ValuesIn(ConvTestConfigs()),
+                                          testing::ValuesIn(ConvTestConfigs<NonPackTestCase>()),
                                           testing::Values(miopenTensorNDHWC)));
diff --git a/test/gtest/nonpack_conv3d_fwd.hpp b/test/gtest/nonpack_conv3d_fwd.hpp
index 5e521d7455..9cba761211 100644
--- a/test/gtest/nonpack_conv3d_fwd.hpp
+++ b/test/gtest/nonpack_conv3d_fwd.hpp
@@ -49,6 +49,7 @@ struct NonPackTestCase : Conv3DTestCase
     std::vector<size_t> GetOutputStrides() { return {o0, o1, o2, o3, o4}; }
 };
 
+template <>
 std::vector<NonPackTestCase> ConvTestConfigs()
 { // g    n   c   d    h   w   k   z  y  x pad_x pad_y pad_z stri_x stri_y stri_z dia_x dia_y dia_z
     return {{{1, 4, 16, 4, 9, 16, 16, 3, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, miopenConvolution},
@@ -86,7 +87,7 @@ std::vector<NonPackTestCase> ConvTestConfigs()
 }
 
 template <typename T = float>
-struct ConvFwdSolverTest
+struct ConvNonpackFwdSolverTest3D
     : public ::testing::TestWithParam<
           std::tuple<miopenConvFwdAlgorithm_t, NonPackTestCase, miopenTensorLayout_t>>
 {
@@ -107,7 +108,7 @@ struct ConvFwdSolverTest
         conv_desc = conv_config.GetConv();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         output = tensor<T>{tensor_layout, output_desc.GetLengths()};
         std::fill(output.begin(), output.end(), std::numeric_limits<double>::quiet_NaN());
         auto&& handle = get_handle();
@@ -123,7 +124,7 @@ struct ConvFwdSolverTest
         auto&& handle = get_handle();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         ref_out     = tensor<T>{tensor_layout, output_desc.GetLengths()};
         ref_out     = ref_conv_fwd(input, weights, output, conv_desc);
         output.data = handle.Read<T>(out_dev, output.data.size());
diff --git a/test/gtest/pooling2d_asymmetric.cpp b/test/gtest/pooling2d_asymmetric.cpp
new file mode 100644
index 0000000000..13cd49051a
--- /dev/null
+++ b/test/gtest/pooling2d_asymmetric.cpp
@@ -0,0 +1,137 @@
+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2019 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *******************************************************************************/
+
+#include <gtest/gtest.h>
+#include <miopen/env.hpp>
+#include "get_handle.hpp"
+#include "test_env.hpp"
+
+#include "pooling2d.hpp"
+
+MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_ALL)
+MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLAGS_ARGS)
+
+namespace pooling2d_asymmetric {
+
+static bool SkipTest(void) { return miopen::IsDisabled(ENV(MIOPEN_TEST_ALL)); }
+
+void GetArgs(const std::string& param, std::vector<std::string>& tokens)
+{
+    std::stringstream ss(param);
+    std::istream_iterator<std::string> begin(ss);
+    std::istream_iterator<std::string> end;
+    while(begin != end)
+        tokens.push_back(*begin++);
+}
+
+void Run2dDriver(miopenDataType_t prec)
+{
+
+    std::vector<std::string> params;
+    switch(prec)
+    {
+    case miopenFloat: params = Pooling2dFloat::GetParam(); break;
+    case miopenHalf: params = Pooling2dHalf::GetParam(); break;
+    case miopenBFloat16:
+    case miopenInt8:
+    case miopenFloat8:
+    case miopenBFloat8:
+    case miopenInt32:
+    case miopenDouble:
+        FAIL()
+            << "miopenBFloat16, miopenInt8, miopenInt32, miopenDouble, miopenFloat8, miopenBFloat8 "
+               "data type not supported by "
+               "immed_conv2d_codecov test";
+
+    default: params = Pooling2dFloat::GetParam();
+    }
+
+    for(const auto& test_value : params)
+    {
+        std::vector<std::string> tokens;
+        GetArgs(test_value, tokens);
+        std::vector<const char*> ptrs;
+
+        std::transform(tokens.begin(), tokens.end(), std::back_inserter(ptrs), [](const auto& str) {
+            return str.data();
+        });
+
+        testing::internal::CaptureStderr();
+        test_drive<pooling2d_driver>(ptrs.size(), ptrs.data());
+        auto capture = testing::internal::GetCapturedStderr();
+        std::cout << capture;
+    }
+};
+
+bool IsTestSupportedForDevice(const miopen::Handle& handle) { return true; }
+
+std::vector<std::string> GetTestCases(const std::string& precision)
+{
+    const auto& flag_arg = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLAGS_ARGS));
+
+    const std::vector<std::string> test_cases = {
+        // clang-format off
+    {"test_pooling2d " + precision + " --all --dataset 1 --limit 0 "+flag_arg}
+        // clang-format on
+    };
+
+    return test_cases;
+}
+
+} // namespace pooling2d_asymmetric
+using namespace pooling2d_asymmetric;
+
+/*
+TEST_P(Pooling2dFloat, FloatTest_pooling2d_asymmetric)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--float"))
+    {
+        Run2dDriver(miopenFloat);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+*/
+
+TEST_P(Pooling2dHalf, HalfTest_pooling2d_asymmetric)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--half"))
+    {
+        Run2dDriver(miopenHalf);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+// INSTANTIATE_TEST_SUITE_P(Pooling2D, Pooling2dFloat, testing::Values(GetTestCases("--float")));
+
+INSTANTIATE_TEST_SUITE_P(Pooling2D, Pooling2dHalf, testing::Values(GetTestCases("--half")));
diff --git a/test/gtest/pooling2d_codecov.cpp b/test/gtest/pooling2d_codecov.cpp
new file mode 100644
index 0000000000..f17b0ee25e
--- /dev/null
+++ b/test/gtest/pooling2d_codecov.cpp
@@ -0,0 +1,135 @@
+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2019 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *******************************************************************************/
+
+#include <gtest/gtest.h>
+#include <miopen/env.hpp>
+#include "get_handle.hpp"
+#include "test_env.hpp"
+
+#include "pooling2d.hpp"
+
+MIOPEN_DECLARE_ENV_VAR_BOOL(CODECOV_TEST)
+MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLAGS_ARGS)
+
+namespace pooling2d_codecov {
+
+static bool SkipTest(void) { return !miopen::IsEnabled(ENV(CODECOV_TEST)); }
+
+void GetArgs(const std::string& param, std::vector<std::string>& tokens)
+{
+    std::stringstream ss(param);
+    std::istream_iterator<std::string> begin(ss);
+    std::istream_iterator<std::string> end;
+    while(begin != end)
+        tokens.push_back(*begin++);
+}
+
+void Run2dDriver(miopenDataType_t prec)
+{
+
+    std::vector<std::string> params;
+    switch(prec)
+    {
+    case miopenHalf: params = Pooling2dHalf::GetParam(); break;
+    case miopenFloat: params = Pooling2dFloat::GetParam(); break;
+    case miopenBFloat16:
+    case miopenInt8:
+    case miopenFloat8:
+    case miopenBFloat8:
+    case miopenInt32:
+    case miopenDouble:
+        FAIL()
+            << "miopenBFloat16, miopenInt8, miopenInt32, miopenDouble, miopenFloat8, miopenBFloat8 "
+               "data type not supported by "
+               "immed_conv2d_codecov test";
+
+    default: params = Pooling2dFloat::GetParam();
+    }
+
+    for(const auto& test_value : params)
+    {
+        std::vector<std::string> tokens;
+        GetArgs(test_value, tokens);
+        std::vector<const char*> ptrs;
+
+        std::transform(tokens.begin(), tokens.end(), std::back_inserter(ptrs), [](const auto& str) {
+            return str.data();
+        });
+
+        testing::internal::CaptureStderr();
+        test_drive<pooling2d_driver>(ptrs.size(), ptrs.data());
+        auto capture = testing::internal::GetCapturedStderr();
+        std::cout << capture;
+    }
+};
+
+bool IsTestSupportedForDevice(const miopen::Handle& handle) { return true; }
+
+std::vector<std::string> GetTestCases(const std::string& precision)
+{
+    const auto& flag_arg = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLAGS_ARGS));
+
+    const std::vector<std::string> test_cases = {
+        // clang-format off
+    {"test_pooling2d " + precision + "--input 1, 192, 28, 28 --lens 2 2 --strides 2 2 --pads 0 0 "+flag_arg}
+        // clang-format on
+    };
+
+    return test_cases;
+}
+
+} // namespace pooling2d_codecov
+using namespace pooling2d_codecov;
+
+TEST_P(Pooling2dFloat, FloatTest_pooling2d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--float"))
+    {
+        Run2dDriver(miopenFloat);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+TEST_P(Pooling2dHalf, HalfTest_pooling2d_codecov)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--half"))
+    {
+        Run2dDriver(miopenHalf);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+INSTANTIATE_TEST_SUITE_P(Pooling2D, Pooling2dFloat, testing::Values(GetTestCases("--float")));
+
+INSTANTIATE_TEST_SUITE_P(Pooling2D, Pooling2dHalf, testing::Values(GetTestCases("--half")));
diff --git a/test/gtest/pooling2d_wide.cpp b/test/gtest/pooling2d_wide.cpp
new file mode 100644
index 0000000000..f6c7da0148
--- /dev/null
+++ b/test/gtest/pooling2d_wide.cpp
@@ -0,0 +1,137 @@
+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2019 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *******************************************************************************/
+
+#include <gtest/gtest.h>
+#include <miopen/env.hpp>
+#include "get_handle.hpp"
+#include "test_env.hpp"
+
+#include "pooling2d.hpp"
+
+MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_ALL)
+MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLAGS_ARGS)
+
+namespace pooling2d_wide {
+
+static bool SkipTest(void) { return miopen::IsDisabled(ENV(MIOPEN_TEST_ALL)); }
+
+void GetArgs(const std::string& param, std::vector<std::string>& tokens)
+{
+    std::stringstream ss(param);
+    std::istream_iterator<std::string> begin(ss);
+    std::istream_iterator<std::string> end;
+    while(begin != end)
+        tokens.push_back(*begin++);
+}
+
+void Run2dDriver(miopenDataType_t prec)
+{
+
+    std::vector<std::string> params;
+    switch(prec)
+    {
+    case miopenFloat: params = Pooling2dFloat::GetParam(); break;
+    case miopenHalf: params = Pooling2dHalf::GetParam(); break;
+    case miopenBFloat16:
+    case miopenInt8:
+    case miopenFloat8:
+    case miopenBFloat8:
+    case miopenInt32:
+    case miopenDouble:
+        FAIL()
+            << "miopenBFloat16, miopenInt8, miopenInt32, miopenDouble, miopenFloat8, miopenBFloat8 "
+               "data type not supported by "
+               "immed_conv2d_codecov test";
+
+    default: params = Pooling2dFloat::GetParam();
+    }
+
+    for(const auto& test_value : params)
+    {
+        std::vector<std::string> tokens;
+        GetArgs(test_value, tokens);
+        std::vector<const char*> ptrs;
+
+        std::transform(tokens.begin(), tokens.end(), std::back_inserter(ptrs), [](const auto& str) {
+            return str.data();
+        });
+
+        testing::internal::CaptureStderr();
+        test_drive<pooling2d_driver>(ptrs.size(), ptrs.data());
+        auto capture = testing::internal::GetCapturedStderr();
+        std::cout << capture;
+    }
+};
+
+bool IsTestSupportedForDevice(const miopen::Handle& handle) { return true; }
+
+std::vector<std::string> GetTestCases(const std::string precision)
+{
+    const auto& flag_arg = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLAGS_ARGS));
+
+    const std::vector<std::string> test_cases = {
+        // clang-format off
+    {"test_pooling2d " + precision + " --all --dataset 2 --limit 0 "+flag_arg}
+        // clang-format on
+    };
+
+    return test_cases;
+}
+
+} // namespace pooling2d_wide
+using namespace pooling2d_wide;
+
+/*
+TEST_P(Pooling2dFloat, FloatTest_pooling2d_wide)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--float"))
+    {
+        Run2dDriver(miopenFloat);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+*/
+
+TEST_P(Pooling2dHalf, HalfTest_pooling2d_wide)
+{
+    const auto& handle = get_handle();
+    if(IsTestSupportedForDevice(handle) && !SkipTest() && IsTestRunWith("--half"))
+    {
+        Run2dDriver(miopenHalf);
+    }
+    else
+    {
+        GTEST_SKIP();
+    }
+};
+
+// INSTANTIATE_TEST_SUITE_P(Pooling2D, Pooling2dFloat, testing::Values(GetTestCases("--float")));
+
+INSTANTIATE_TEST_SUITE_P(Pooling2D, Pooling2dHalf, testing::Values(GetTestCases("--half")));
diff --git a/test/gtest/solver_bwd.hpp b/test/gtest/solver_bwd.hpp
index 6511800ce6..93ac36fcf5 100644
--- a/test/gtest/solver_bwd.hpp
+++ b/test/gtest/solver_bwd.hpp
@@ -44,7 +44,7 @@
 
 template <typename T = float, typename Tref = float, bool use_cpu_ref = false>
 struct ConvBwdSolverTest
-    : public ::testing::TestWithParam<std::tuple<miopenConvFwdAlgorithm_t, ConvTestCase>>
+    : public ::testing::TestWithParam<std::tuple<miopenConvFwdAlgorithm_t, ConvTestCaseBase>>
 {
 
     template <typename Solver>
@@ -103,7 +103,7 @@ struct ConvBwdSolverTest
         conv_desc = conv_config.GetConv();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
 
         output = tensor<T>{output_desc.GetLengths()};
         output.generate(GenData<T>{});
@@ -123,7 +123,7 @@ struct ConvBwdSolverTest
         auto&& handle = get_handle();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         ref_in = tensor<Tref>{output_desc.GetLengths()};
         if(use_cpu_ref)
         {
@@ -165,7 +165,7 @@ struct ConvBwdSolverTest
         EXPECT_TRUE(error < threshold)
             << "Error beyond tolerance Error:" << error << ",  Threshold: " << threshold;
     }
-    ConvTestCase conv_config;
+    ConvTestCaseBase conv_config;
     miopen::ConvolutionDescriptor conv_desc;
     tensor<T> input;
     tensor<T> weights;
diff --git a/test/gtest/solver_bwd_f8.cpp b/test/gtest/solver_bwd_f8.cpp
index 6f2cda02bf..cb601e4b55 100644
--- a/test/gtest/solver_bwd_f8.cpp
+++ b/test/gtest/solver_bwd_f8.cpp
@@ -60,10 +60,10 @@ TEST_P(ConvBwdFp8Naive, DISABLED_Bwd)
 INSTANTIATE_TEST_SUITE_P(ConvBwdTest,
                          ConvBwdFp8,
                          testing::Combine(testing::Values(miopenConvolutionAlgoGEMM),
-                                          testing::ValuesIn(GetNetwork1())));
+                                          testing::ValuesIn(GetNetwork1<ConvTestCaseBase>())));
 // Since NaiveConv is verified against the CPU, we are conservative in the number and type
 // of test cases we instantiate
 INSTANTIATE_TEST_SUITE_P(ConvBwdTest,
                          ConvBwdFp8Naive,
                          testing::Combine(testing::Values(miopenConvolutionAlgoGEMM),
-                                          testing::ValuesIn(ConvTestConfigs())));
+                                          testing::ValuesIn(ConvTestConfigs<ConvTestCaseBase>())));
diff --git a/test/gtest/solver_convasm3x3u.cpp b/test/gtest/solver_convasm3x3u.cpp
index 3ed1e466dc..e6422e7892 100644
--- a/test/gtest/solver_convasm3x3u.cpp
+++ b/test/gtest/solver_convasm3x3u.cpp
@@ -38,5 +38,5 @@ TEST_P(ConvFwdSolverTestFloat, ConvASM3x3UFwd)
 INSTANTIATE_TEST_SUITE_P(ConvFwdTest,
                          ConvFwdSolverTestFloat,
                          testing::Combine(testing::Values(miopenConvolutionFwdAlgoDirect),
-                                          testing::ValuesIn(ConvTestConfigs()),
+                                          testing::ValuesIn(ConvTestConfigs<ConvTestCaseBase>()),
                                           testing::Values(miopenTensorNCHW)));
diff --git a/test/gtest/solver_f8.cpp b/test/gtest/solver_f8.cpp
new file mode 100644
index 0000000000..0caa2f70a7
--- /dev/null
+++ b/test/gtest/solver_f8.cpp
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2022 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *******************************************************************************/
+#include "solver_f8.hpp"
+
+template <>
+std::vector<ConvTestCaseF8> ConvTestConfigs()
+{           // n  c   h   w   k   y  x pad_x pad_y stri_x stri_y dia_x dia_y
+    return {// New tests begin
+            {1, 32, 4, 4, 16, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {2, 32, 4, 4, 16, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {4, 32, 4, 4, 16, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {8, 32, 4, 4, 16, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {16, 32, 4, 4, 16, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {16, 128, 16, 16, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 128, 28, 28, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 128, 64, 64, 64, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 128, 128, 64, 64, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 128, 128, 128, 64, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 128, 128, 128, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 256, 128, 128, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 256, 256, 128, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 256, 256, 256, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 256, 256, 256, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {128, 256, 256, 256, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {128, 256, 512, 256, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {128, 256, 512, 512, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {128, 256, 1024, 512, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {128, 256, 1024, 1024, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {128, 512, 1024, 1024, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {128, 512, 1024, 1024, 512, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {128, 1024, 1024, 1024, 512, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {128, 1024, 1024, 1024, 1024, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {256, 1024, 1024, 1024, 1024, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {1024, 1024, 1024, 1024, 1024, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {1024, 2048, 2048, 2048, 2048, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            // New tests end
+            {16, 128, 16, 16, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 128, 28, 28, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 256, 14, 14, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 512, 7, 7, 512, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
+            {64, 1024, 14, 14, 1024, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution}};
+}
diff --git a/test/gtest/solver_f8.hpp b/test/gtest/solver_f8.hpp
index bf77347ef8..bf6fccc163 100644
--- a/test/gtest/solver_f8.hpp
+++ b/test/gtest/solver_f8.hpp
@@ -26,39 +26,26 @@
 #pragma once
 
 #include <gtest/gtest.h>
+#include <random>
 #include "cpu_conv.hpp"
 #include "get_handle.hpp"
 #include "tensor_util.hpp"
 #include <fusionHost.hpp>
 #include <miopen/conv/data_invoke_params.hpp>
 #include "conv_common.hpp"
-#include <miopen/hip_float8.hpp>
+#include "hip_float8.hpp"
 #include "verify.hpp"
-using float8  = miopen_f8::hip_f8<miopen_f8::hip_f8_type::fp8>;
-using bfloat8 = miopen_f8::hip_f8<miopen_f8::hip_f8_type::bf8>;
 
-template <typename T>
-miopenDataType_t GetDataType();
+#include "conv_test_base.hpp"
+#include "f8_cast_util.hpp"
 
-template <>
-miopenDataType_t GetDataType<float8>()
+float scalar_gen_random_float(float low, float high)
 {
-    return miopenFloat8;
+    float r = static_cast<float>(rand()) / static_cast<float>(RAND_MAX) * (high + low) - low;
+    return r;
 }
 
-template <>
-miopenDataType_t GetDataType<bfloat8>()
-{
-    return miopenBFloat8;
-}
-
-template <>
-miopenDataType_t GetDataType<float>()
-{
-    return miopenFloat;
-}
-
-struct ConvTestCase
+struct ConvTestCaseF8
 {
     size_t N;
     size_t C;
@@ -74,7 +61,7 @@ struct ConvTestCase
     size_t dialtion_x;
     size_t dilation_y;
     miopenConvolutionMode_t conv_mode;
-    friend std::ostream& operator<<(std::ostream& os, const ConvTestCase& tc)
+    friend std::ostream& operator<<(std::ostream& os, const ConvTestCaseF8& tc)
     {
         return os << "N: " << tc.N << " C:" << tc.C << " H:" << tc.H << " W:" << tc.W
                   << " k: " << tc.k << " y:" << tc.y << " x:" << tc.x << " pad_y:" << tc.pad_y
@@ -91,68 +78,9 @@ struct ConvTestCase
     }
 };
 
-std::vector<ConvTestCase> ConvTestConfigs()
-{           // n  c   h   w   k   y  x pad_x pad_y stri_x stri_y dia_x dia_y
-    return {// New tests begin
-            {1, 32, 4, 4, 16, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {2, 32, 4, 4, 16, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {4, 32, 4, 4, 16, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {8, 32, 4, 4, 16, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {16, 32, 4, 4, 16, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {16, 128, 16, 16, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 128, 28, 28, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 128, 64, 64, 64, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 128, 128, 64, 64, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 128, 128, 128, 64, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 128, 128, 128, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 256, 128, 128, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 256, 256, 128, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 256, 256, 256, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 256, 256, 256, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {128, 256, 256, 256, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {128, 256, 512, 256, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {128, 256, 512, 512, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {128, 256, 1024, 512, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {128, 256, 1024, 1024, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {128, 512, 1024, 1024, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {128, 512, 1024, 1024, 512, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {128, 1024, 1024, 1024, 512, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {128, 1024, 1024, 1024, 1024, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {256, 1024, 1024, 1024, 1024, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {1024, 1024, 1024, 1024, 1024, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {1024, 2048, 2048, 2048, 2048, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            // New tests end
-            {16, 128, 16, 16, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 128, 28, 28, 128, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 256, 14, 14, 256, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 512, 7, 7, 512, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution},
-            {64, 1024, 14, 14, 1024, 1, 1, 0, 0, 1, 1, 1, 1, miopenConvolution}};
-}
-
-template <typename U, typename V>
-struct Fp8Cast
-{
-    uint64_t seed = 1234;
-    bool is_stoch = true;
-    V operator()(U x)
-    {
-        if(is_stoch)
-        {
-            auto tmp =
-                float8(static_cast<float>(x), miopen_f8::hip_f8_rounding_mode::stochastic, seed);
-            return static_cast<V>(tmp);
-        }
-        else
-        {
-            auto tmp = float8(static_cast<float>(x));
-            return static_cast<V>(tmp);
-        }
-    }
-};
-
 template <typename T, typename Tout = T, typename Tacc = float>
-struct ConvFwdSolverTest
-    : public ::testing::TestWithParam<std::tuple<miopenConvFwdAlgorithm_t, ConvTestCase>>
+struct ConvFwdSolverTestF8
+    : public ::testing::TestWithParam<std::tuple<miopenConvFwdAlgorithm_t, ConvTestCaseF8>>
 {
 protected:
     void SetUp() override
@@ -163,7 +91,7 @@ struct ConvFwdSolverTest
         weights = tensor<T>{conv_config.k, conv_config.C, conv_config.y, conv_config.x};
 
         auto gen_fp8_value = [=](auto...) {
-            const auto tmp = float8(scalar_gen_random_float{-0.5, 0.5}());
+            const auto tmp = float8(scalar_gen_random_float(-0.5, 0.5));
             return tmp;
         };
 
@@ -173,7 +101,7 @@ struct ConvFwdSolverTest
         conv_desc = conv_config.GetConv();
 
         miopen::TensorDescriptor output_desc = conv_desc.GetForwardOutputTensor(
-            input.desc, weights.desc, GetDataType<Tout>()); // Tgpu Datatype?
+            input.desc, weights.desc, miopen_type<Tout>{}); // Tgpu Datatype?
 
         output = tensor<Tout>{output_desc.GetLengths()}; // half_float::half instead?
 
@@ -192,7 +120,7 @@ struct ConvFwdSolverTest
         auto&& handle = get_handle();
 
         miopen::TensorDescriptor output_desc = conv_desc.GetForwardOutputTensor(
-            input.desc, weights.desc, GetDataType<Tout>()); // miopenFloat or GetDataType<Tgpu>() ?
+            input.desc, weights.desc, miopen_type<Tout>{}); // miopenFloat or miopen_type<Tgpu>{} ?
         ref_out = tensor<Tout>{output_desc.GetLengths()};
 
         using FI       = Fp8Cast<T, T>;
@@ -249,7 +177,7 @@ struct ConvFwdSolverTest
         EXPECT_TRUE(error < threshold)
             << "Error beyond tolerance Error:" << error << ",  Threshold: " << threshold;
     }
-    ConvTestCase conv_config;
+    ConvTestCaseF8 conv_config;
     miopen::ConvolutionDescriptor conv_desc;
     tensor<T> input;
     tensor<T> weights;
diff --git a/test/gtest/solver_fwd.hpp b/test/gtest/solver_fwd.hpp
index 20b16fcc32..397140e7f4 100644
--- a/test/gtest/solver_fwd.hpp
+++ b/test/gtest/solver_fwd.hpp
@@ -43,7 +43,7 @@
 template <typename T = float, typename Tref = float, bool use_cpu_ref = false>
 struct ConvFwdSolverTest
     : public ::testing::TestWithParam<
-          std::tuple<miopenConvFwdAlgorithm_t, ConvTestCase, miopenTensorLayout_t>>,
+          std::tuple<miopenConvFwdAlgorithm_t, ConvTestCaseBase, miopenTensorLayout_t>>,
       ConvFwdSolverTestBase<T, Tref, use_cpu_ref>
 {
     template <typename Solver>
@@ -112,7 +112,7 @@ struct ConvFwdSolverTest
         this->ThresholdChecks();
     }
 
-    ConvTestCase conv_config;
+    ConvTestCaseBase conv_config;
     Workspace wspace{};
     miopenConvFwdAlgorithm_t algo = miopenConvolutionFwdAlgoDirect;
     bool test_skipped             = false;
diff --git a/test/gtest/solver_fwd_f8.cpp b/test/gtest/solver_fwd_f8.cpp
index a48513480c..eecada9c96 100644
--- a/test/gtest/solver_fwd_f8.cpp
+++ b/test/gtest/solver_fwd_f8.cpp
@@ -60,12 +60,12 @@ TEST_P(ConvFwdFp8Naive, DISABLED_Fwd)
 INSTANTIATE_TEST_SUITE_P(ConvFwdTest,
                          ConvFwdFp8,
                          testing::Combine(testing::Values(miopenConvolutionAlgoGEMM),
-                                          testing::ValuesIn(ConvTestConfigs()),
+                                          testing::ValuesIn(ConvTestConfigs<ConvTestCaseBase>()),
                                           testing::Values(miopenTensorNCHW)));
 // Since NaiveConv is verified against the CPU, we are conservative in the number and type
 // of test cases we instantiate
 INSTANTIATE_TEST_SUITE_P(ConvFwdTest,
                          ConvFwdFp8Naive,
                          testing::Combine(testing::Values(miopenConvolutionAlgoGEMM),
-                                          testing::ValuesIn(ConvTestConfigs()),
+                                          testing::ValuesIn(ConvTestConfigs<ConvTestCaseBase>()),
                                           testing::Values(miopenTensorNCHW)));
diff --git a/test/gtest/solver_wrw.hpp b/test/gtest/solver_wrw.hpp
index dcf8311d83..e1c204f60e 100644
--- a/test/gtest/solver_wrw.hpp
+++ b/test/gtest/solver_wrw.hpp
@@ -44,7 +44,7 @@
 
 template <typename T = float, typename Tref = float, bool use_cpu_ref = false>
 struct ConvWrwSolverTest
-    : public ::testing::TestWithParam<std::tuple<miopenConvFwdAlgorithm_t, ConvTestCase>>
+    : public ::testing::TestWithParam<std::tuple<miopenConvFwdAlgorithm_t, ConvTestCaseBase>>
 {
 
     template <typename Solver>
@@ -103,7 +103,7 @@ struct ConvWrwSolverTest
         conv_desc = conv_config.GetConv();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
 
         output = tensor<T>{output_desc.GetLengths()};
         output.generate(GenData<T>{});
@@ -123,7 +123,7 @@ struct ConvWrwSolverTest
         auto&& handle = get_handle();
 
         miopen::TensorDescriptor output_desc =
-            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, GetDataType<T>());
+            conv_desc.GetForwardOutputTensor(input.desc, weights.desc, miopen_type<T>{});
         ref_weights = tensor<Tref>{output_desc.GetLengths()};
         if(use_cpu_ref)
         {
@@ -167,7 +167,7 @@ struct ConvWrwSolverTest
         EXPECT_TRUE(error < threshold)
             << "Error beyond tolerance Error:" << error << ",  Threshold: " << threshold;
     }
-    ConvTestCase conv_config;
+    ConvTestCaseBase conv_config;
     miopen::ConvolutionDescriptor conv_desc;
     tensor<T> input;
     tensor<T> weights;
diff --git a/test/gtest/solver_wrw_f8.cpp b/test/gtest/solver_wrw_f8.cpp
index a970effd02..95f85e79da 100644
--- a/test/gtest/solver_wrw_f8.cpp
+++ b/test/gtest/solver_wrw_f8.cpp
@@ -40,4 +40,4 @@ TEST_P(ConvWrwFp8Naive, DISABLED_Wrw)
 INSTANTIATE_TEST_SUITE_P(ConvWrwTest,
                          ConvWrwFp8Naive,
                          testing::Combine(testing::Values(miopenConvolutionAlgoGEMM),
-                                          testing::ValuesIn(ConvTestConfigs())));
+                                          testing::ValuesIn(ConvTestConfigs<ConvTestCaseBase>())));
diff --git a/test/gtest/sum.cpp b/test/gtest/sum.cpp
index 0965649c23..b18fc0a89e 100644
--- a/test/gtest/sum.cpp
+++ b/test/gtest/sum.cpp
@@ -29,6 +29,8 @@
 MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLOAT_ARG)
 MIOPEN_DECLARE_ENV_VAR_BOOL(MIOPEN_TEST_ALL)
 
+namespace sum {
+
 std::string GetFloatArg()
 {
     const auto& tmp = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLOAT_ARG));
@@ -43,6 +45,9 @@ struct SumTestFloat : SumTest<float>
 {
 };
 
+} // namespace sum
+using namespace sum;
+
 TEST_P(SumTestFloat, SumTestFw)
 {
     if(miopen::IsEnabled(ENV(MIOPEN_TEST_ALL)) && (GetFloatArg() == "--float"))
diff --git a/test/gtest/sum.hpp b/test/gtest/sum.hpp
index f38da15f96..80105780ec 100644
--- a/test/gtest/sum.hpp
+++ b/test/gtest/sum.hpp
@@ -99,7 +99,7 @@ std::vector<SumTestCase> SumTestConfigs()
     // clang-format on
 }
 
-inline int32_t SetTensorLayout(miopen::TensorDescriptor& desc)
+static int32_t SetTensorLayout(miopen::TensorDescriptor& desc)
 {
     std::vector<std::size_t> lens = desc.GetLengths();
     std::vector<int32_t> int32_t_lens(lens.begin(), lens.end());
diff --git a/test/gtest/test_operations.hpp b/test/gtest/test_operations.hpp
index da41212302..298ac55e3e 100644
--- a/test/gtest/test_operations.hpp
+++ b/test/gtest/test_operations.hpp
@@ -134,7 +134,7 @@ void AddActiv(miopen::FusionPlanDescriptor& fusePlanDesc,
               miopenStatusSuccess);
 }
 
-bool Skip(miopen::Handle& handle)
+inline bool Skip(miopen::Handle& handle)
 {
     const std::string arch = handle.GetDeviceName();
     bool skip_test         = (arch != "gfx908" && arch != "gfx90a");
diff --git a/test/immed_conv2d.cpp b/test/immed_conv2d.cpp
deleted file mode 100644
index 6649c69d65..0000000000
--- a/test/immed_conv2d.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*******************************************************************************
- *
- * MIT License
- *
- * Copyright (c) 2019 Advanced Micro Devices, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- *******************************************************************************/
-#include "conv_common.hpp"
-
-template <class T>
-struct conv2d_driver : conv_driver<T, ConvApi::Immediate>
-{
-    conv2d_driver() : conv_driver<T, ConvApi::Immediate>()
-    {
-        this->add(this->input_dims, "input");
-        this->add(this->weight_tensor_dims, "weights");
-        this->add(this->batch_size,
-                  "batch_size",
-                  this->generate_data_limited(this->get_batch_sizes(), 1, {16}));
-        this->add(this->input_channels,
-                  "input_channels",
-                  this->generate_data_limited(this->get_input_channels(), 1, {32}));
-        this->add(this->output_channels,
-                  "output_channels",
-                  this->generate_data_limited(this->get_output_channels(), 1, {32}));
-        this->add(this->spatial_dim_elements,
-                  "spatial_dim_elements",
-                  this->generate_data_limited(this->get_2d_spatial_dims(), 1, {56, 56}));
-        this->add(this->filter_dims,
-                  "filter_dims",
-                  this->generate_data_limited(this->get_2d_filter_dims(), 2, {3, 3}));
-        this->add(this->pads_strides_dilations,
-                  "pads_strides_dilations",
-                  this->generate_data_limited(this->get_2d_pads_strides_dilations(), 2));
-        this->add(this->trans_output_pads,
-                  "trans_output_pads",
-                  this->generate_data_limited(this->get_2d_trans_output_pads(), 1));
-        this->add(this->in_layout, "in_layout", this->generate_data({"NCHW"}));
-        this->add(this->fil_layout, "fil_layout", this->generate_data({"NCHW"}));
-        this->add(this->out_layout, "out_layout", this->generate_data({"NCHW"}));
-    }
-};
-
-int main(int argc, const char* argv[]) { test_drive<conv2d_driver>(argc, argv); }
diff --git a/test/pooling2d.cpp b/test/pooling2d.hpp
similarity index 95%
rename from test/pooling2d.cpp
rename to test/pooling2d.hpp
index c0df88c481..e6e107678a 100644
--- a/test/pooling2d.cpp
+++ b/test/pooling2d.hpp
@@ -24,6 +24,7 @@
  *
  *******************************************************************************/
 
+#include <gtest/gtest.h>
 #include "pooling_common.hpp"
 
 #define WORKAROUND_ISSUE_1670 1
@@ -106,4 +107,10 @@ struct pooling2d_driver : pooling_driver<T>
     }
 };
 
-int main(int argc, const char* argv[]) { test_drive<pooling2d_driver>(argc, argv); }
+class Pooling2dFloat : public testing::TestWithParam<std::vector<std::string>>
+{
+};
+
+class Pooling2dHalf : public testing::TestWithParam<std::vector<std::string>>
+{
+};
diff --git a/test/test_env.hpp b/test/test_env.hpp
new file mode 100644
index 0000000000..f0c3ec9b4a
--- /dev/null
+++ b/test/test_env.hpp
@@ -0,0 +1,38 @@
+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2023 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ *******************************************************************************/
+
+#pragma once
+
+#include <miopen/env.hpp>
+
+MIOPEN_DECLARE_ENV_VAR_STR(MIOPEN_TEST_FLOAT_ARG)
+
+inline bool IsTestRunWith(const char* float_arg)
+{
+    assert(float_arg != nullptr);
+    const auto& s_envVar = miopen::GetStringEnv(ENV(MIOPEN_TEST_FLOAT_ARG));
+    return (s_envVar.compare(float_arg) == 0);
+}