fix the argument order, add atol,rtols etc.

src/driver/verify.cpp

@@ -22,6 +22,7 @@
  * THE SOFTWARE.
  */
 #include "verify.hpp"
+#include "migraphx/verify.hpp"
 #include "perf.hpp"
 
 #include <migraphx/register_target.hpp>
@@ -84,7 +85,7 @@ void verify_program(const std::string& name,
     std::size_t output_num = x.size();
     for(std::size_t i = 0; i < output_num; ++i)
     {
-        verify_args_with_threshold(name, x[i], y[i], threshold);
+        verify_args_with_threshold(name, x[i], y[i], verify::threshold{threshold});
     }
 }
 

src/include/migraphx/verify.hpp

@@ -189,7 +189,7 @@ double rms_range(const R1& r1, const R2& r2)
 }
 
 template <class R>
-double get_threshold(const R&, std::size_t tolerance = 80)
+double get_rms_tol(const R&, std::size_t tolerance = 80)
 {
     double threshold = std::numeric_limits<range_value<R>>::epsilon() * tolerance;
     return threshold;
@@ -214,13 +214,39 @@ struct expected
 template <class T>
 expected(const T&) -> expected<T>;
 
+struct threshold
+{
+    double rms_tol = 0.001;
+    double atol    = 0.001;
+    double rtol    = 0.001;
+};
+
+template <class R1, class R2>
+bool allclose(const R1& r1, const R2& r2, threshold thres)
+{
+    std::size_t n = range_distance(r1);
+    if(n == range_distance(r2))
+    {
+        auto idx = mismatch_idx(r1, r2, [&](auto x, auto y) {
+            return abs_diff(double(x), double(y)) > thres.atol + thres.rtol * std::abs(double(y));
+        });
+        if(idx < range_distance(r1))
+        {
+            return false;
+        }
+        return true;
+    }
+    else
+        return false;
+}
+
 template <class R1, class R2>
 bool verify_range(const R1& r1,
                   const R2& r2,
                   std::size_t tolerance = 80,
                   double* out_error     = nullptr)
 {
-    double threshold = get_threshold(r1, tolerance);
+    double threshold = get_rms_tol(r1, tolerance);
     auto error       = rms_range(r1, r2);
     if(out_error != nullptr)
         *out_error = error;
@@ -230,13 +256,14 @@ bool verify_range(const R1& r1,
 template <class R1, class R2>
 bool verify_range_with_threshold(const R1& r1,
                                  const expected<R2>& r2,
-                                 double threshold,
+                                 threshold tols    = threshold{},
                                  double* out_error = nullptr)
 {
-    auto error = rms_range(r1, r2.data());
+    auto rms_error = rms_range(r1, r2.data());
+    // auto ewise_verify = allclose(r1, r2.data(), tols);
     if(out_error != nullptr)
-        *out_error = error;
-    return error <= threshold;
+        *out_error = rms_error;
+    return rms_error <= tols.rms_tol;
 }
 
 // expected argument should be passed as second, but if it is passed as the first by mistake then
@@ -244,10 +271,10 @@ bool verify_range_with_threshold(const R1& r1,
 template <class R1, class R2>
 bool verify_range_with_threshold(const expected<R1>& r1,
                                  const R2& r2,
-                                 double threshold,
+                                 threshold tols    = threshold{},
                                  double* out_error = nullptr)
 {
-    return verify_range(r2, r1, threshold, out_error);
+    return verify_range(r2, r1, tols, out_error);
 }
 
 } // namespace verify

src/include/migraphx/verify_args.hpp

@@ -34,11 +34,11 @@ inline namespace MIGRAPHX_INLINE_NS {
 MIGRAPHX_EXPORT bool verify_args_with_threshold(const std::string& name,
                                                 const argument& ref_arg,
                                                 const argument& target_arg,
-                                                double threshold);
+                                                verify::threshold);
 
 MIGRAPHX_EXPORT bool verify_args(const std::string& name,
-                                 const argument& ref_arg,
                                  const argument& target_arg,
+                                 const argument& ref_arg,
                                  std::size_t tolerance = 80);
 
 } // namespace MIGRAPHX_INLINE_NS

src/verify_args.cpp

@@ -30,13 +30,12 @@ inline namespace MIGRAPHX_INLINE_NS {
 bool verify_args_with_threshold(const std::string& name,
                                 const argument& target_arg,
                                 const argument& ref_arg,
-                                double threshold)
+                                verify::threshold tols)
 {
     bool passed = true;
     visit_all(ref_arg, target_arg)([&](auto ref, auto target) {
         double error;
-        passed =
-            verify::verify_range_with_threshold(target, verify::expected{ref}, threshold, &error);
+        passed = verify::verify_range_with_threshold(target, verify::expected{ref}, tols, &error);
         if(not passed)
         {
             // TODO: Check for nans
@@ -95,13 +94,14 @@ bool verify_args_with_threshold(const std::string& name,
 }
 
 bool verify_args(const std::string& name,
-                 const argument& ref_arg,
                  const argument& target_arg,
+                 const argument& ref_arg,
                  std::size_t tolerance)
 {
-    double threshold = 0.001;
-    target_arg.visit([&](auto ta) { threshold = verify::get_threshold(ta, tolerance); });
-    return verify_args_with_threshold(name, target_arg, ref_arg, threshold);
+    double rms_tol = 0.001;
+    target_arg.visit([&](auto ta) { rms_tol = verify::get_rms_tol(ta, tolerance); });
+    verify::threshold tols{rms_tol};
+    return verify_args_with_threshold(name, target_arg, ref_arg, tols);
 }
 
 } // namespace MIGRAPHX_INLINE_NS

test/gpu/codegen_literal.cpp

@@ -80,7 +80,7 @@ TEST_CASE(mul_literal_round_test)
     migraphx::target gpu_t = migraphx::make_target("gpu");
     run_prog(p, gpu_t, m, gpu_result);
 
-    EXPECT(migraphx::verify::verify_range(ref_result, gpu_result));
+    EXPECT(migraphx::verify::verify_range(gpu_result, ref_result));
 }
 
 int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/gpu/manage_host_buffer.cpp

@@ -53,7 +53,6 @@ TEST_CASE(host_same_buffer_copy)
     migraphx::parameter_map pp;
     std::vector<float> a_vec(ss.elements(), -1);
     std::vector<float> b_vec(ss.elements(), 2);
-    std::vector<float> c_vec(ss.elements(), 0);
     pp["a"] = migraphx::argument(ss, a_vec.data());
     pp["b"] = migraphx::argument(ss, b_vec.data());
     std::vector<float> gpu_result;
@@ -64,7 +63,8 @@ TEST_CASE(host_same_buffer_copy)
     auto result = p.eval(pp).back();
     std::vector<float> results_vector(ss.elements(), -1);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(c_vec, results_vector));
+    std::vector<float> gold_vec(ss.elements(), 0);
+    EXPECT(migraphx::verify::verify_range(results_vector, gold_vec));
 }
 
 TEST_CASE(arguments_lifetime)

test/gpu/mlir.cpp

@@ -133,7 +133,7 @@ bool verify_mlir(const migraphx::module& mmlir)
     auto inputs = generate_params(ref);
 
     auto mlir = create_program_from_mlir(mmlir);
-    return migraphx::verify_args("mlir", run_ref(ref, inputs), run_gpu(mlir, inputs));
+    return migraphx::verify_args("mlir", run_gpu(mlir, inputs), run_ref(ref, inputs));
 }
 
 TEST_CASE(conv)

test/gpu/quantization.cpp

@@ -40,7 +40,6 @@
 TEST_CASE(gpu_target_copy)
 {
     migraphx::target gpu_t = migraphx::make_target("gpu");
-    migraphx::target ref_t = migraphx::make_target("ref");
     migraphx::shape s{migraphx::shape::int8_type, {2, 3, 4, 5}};
 
     auto ref_arg_orig  = migraphx::generate_argument(s, 0x123456L);
@@ -118,9 +117,12 @@ TEST_CASE(int8_quantization)
         // the regular pipeline uses the rewrite_quantization in the much
         // earlier stage.
         if(migraphx::gpu::mlir_enabled())
-            EXPECT(migraphx::verify::verify_range_with_threshold(gpu_result, migraphx::verify::expected{ref_result}, 0.01));
+            EXPECT(migraphx::verify::verify_range_with_threshold(
+                gpu_result,
+                migraphx::verify::expected{ref_result},
+                migraphx::verify::threshold{0.01}));
         else
-            EXPECT(migraphx::verify::verify_range(ref_result, gpu_result));
+            EXPECT(migraphx::verify::verify_range(gpu_result, ref_result));
     }
 }
 

test/onnx/verify_onnx.cpp

@@ -76,15 +76,15 @@ TEST_CASE(batch_norm_flat_test)
     migraphx::shape x_shape{migraphx::shape::float_type, {10}};
     migraphx::shape c_shape(migraphx::shape::float_type, {1});
     std::vector<float> x_data        = {1.6524342,
-                                 -0.51048076,
-                                 0.32543048,
-                                 2.4410043,
-                                 2.0833702,
-                                 0.44981122,
-                                 1.0044622,
-                                 -0.24006313,
-                                 -0.43065986,
-                                 0.07626268};
+                                        -0.51048076,
+                                        0.32543048,
+                                        2.4410043,
+                                        2.0833702,
+                                        0.44981122,
+                                        1.0044622,
+                                        -0.24006313,
+                                        -0.43065986,
+                                        0.07626268};
     std::vector<float> scale_data    = {-0.02927135};
     std::vector<float> bias_data     = {0.42347777};
     std::vector<float> mean_data     = {-0.00449735};
@@ -309,12 +309,12 @@ TEST_CASE(celu_verify_test)
     std::vector<float> result_vector;
     result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
 
-    std::vector<float> correct(6);
+    std::vector<float> gold(6);
     float alpha = 0.5;
-    std::transform(data.begin(), data.end(), correct.begin(), [&](auto x) {
+    std::transform(data.begin(), data.end(), gold.begin(), [&](auto x) {
         return std::max(0.0f, x) + std::min(0.0f, alpha * std::expm1(x / alpha));
     });
-    EXPECT(migraphx::verify::verify_range(result_vector, correct));
+    EXPECT(migraphx::verify::verify_range(result_vector, gold));
 }
 
 TEST_CASE(clip_args_type_mismatch)
@@ -374,11 +374,11 @@ TEST_CASE(spacetodepth_depthtospace_test)
     // space to depth
     auto p1 = migraphx::parse_onnx("spacetodepth_simple_test.onnx");
     p1.compile(migraphx::make_target("ref"));
-    std::vector<float> data_in(48);
-    std::iota(std::begin(data_in), std::end(data_in), 0);
+    std::vector<float> gold_data_in(48);
+    std::iota(std::begin(gold_data_in), std::end(gold_data_in), 0);
     migraphx::shape s_x_1{migraphx::shape::float_type, {1, 2, 4, 6}};
     migraphx::parameter_map pp1;
-    pp1["x"]     = migraphx::argument(s_x_1, data_in.data());
+    pp1["x"]     = migraphx::argument(s_x_1, gold_data_in.data());
     auto result1 = p1.eval(pp1).back();
     // depth to space
     auto p2 = migraphx::parse_onnx("depthtospace_simple_test.onnx");
@@ -388,7 +388,7 @@ TEST_CASE(spacetodepth_depthtospace_test)
     auto result2 = p2.eval(pp2).back();
     std::vector<float> result_vector2;
     result2.visit([&](auto output) { result_vector2.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(result_vector2, data_in));
+    EXPECT(migraphx::verify::verify_range(result_vector2, gold_data_in));
 }
 
 TEST_CASE(eyelike_verify_test)
@@ -405,8 +405,8 @@ TEST_CASE(eyelike_verify_test)
     std::vector<float> result_vector;
     result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
 
-    std::vector<float> eyelike_mat = {0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.};
-    EXPECT(migraphx::verify::verify_range(result_vector, eyelike_mat));
+    std::vector<float> gold_eyelike_mat = {0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.};
+    EXPECT(migraphx::verify::verify_range(result_vector, gold_eyelike_mat));
 }
 
 TEST_CASE(eyelike_verify_negk_test)
@@ -423,8 +423,8 @@ TEST_CASE(eyelike_verify_negk_test)
     std::vector<float> result_vector;
     result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
 
-    std::vector<float> eyelike_mat = {0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.};
-    EXPECT(migraphx::verify::verify_range(result_vector, eyelike_mat));
+    std::vector<float> gold_eyelike_mat = {0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.};
+    EXPECT(migraphx::verify::verify_range(result_vector, gold_eyelike_mat));
 }
 
 TEST_CASE(gather_elements)
@@ -1012,19 +1012,19 @@ TEST_CASE(lpnormalization_2norm)
     std::vector<float> result_vector;
     result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
 
-    std::vector<float> correct{0.f,
-                               2.f / 3.f,
-                               -2.f / 3.f,
-                               1.f / 3.f,
-                               1.f / 6.f,
-                               -5.f / 6.f,
-                               3.f / 6.f,
-                               -1.f / 6.f,
-                               -4.f / 5.f,
-                               3.f / 5.f,
-                               0.f,
-                               0.f};
-    EXPECT(migraphx::verify::verify_range(result_vector, correct));
+    std::vector<float> gold{0.f,
+                            2.f / 3.f,
+                            -2.f / 3.f,
+                            1.f / 3.f,
+                            1.f / 6.f,
+                            -5.f / 6.f,
+                            3.f / 6.f,
+                            -1.f / 6.f,
+                            -4.f / 5.f,
+                            3.f / 5.f,
+                            0.f,
+                            0.f};
+    EXPECT(migraphx::verify::verify_range(result_vector, gold));
 }
 
 TEST_CASE(mean_broadcast_test)

test/quantization.cpp

@@ -1078,7 +1078,9 @@ TEST_CASE(int8_quantization_dot)
         run_prog(p, ref_t, m, no_quant_result);
 
         EXPECT(migraphx::verify::verify_range_with_threshold(
-            quant_result, migraphx::verify::expected{no_quant_result}, 0.003));
+            quant_result,
+            migraphx::verify::expected{no_quant_result},
+            migraphx::verify::threshold{0.003}));
     }
 }
 

test/ref/broadcast.cpp

@@ -114,6 +114,6 @@ TEST_CASE(isnan_broadcast_test)
     auto result = p.eval({}).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    std::vector<float> correct = {0, 0, 0, 0, 1, 1};
-    EXPECT(migraphx::verify::verify_range(results_vector, correct));
+    std::vector<float> gold = {0, 0, 0, 0, 1, 1};
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }

test/ref/dot_op.cpp

@@ -56,18 +56,7 @@ void dot_2d_test()
                             1.53027987e+00,
                             -3.81407415e-04,
                             -3.29650255e-01};
-    std::vector<float> c = {-1.56327541e+00,
-                            -7.09570140e-01,
-                            -5.37424982e-01,
-                            -2.22994831e-01,
-                            -2.15586437e+00,
-                            2.09177941e-03,
-                            -1.47279677e+00,
-                            2.02627040e-01,
-                            -6.04527691e-01,
-                            -1.29885596e+00,
-                            2.16294914e+00,
-                            -1.48101497e-01};
+
     migraphx::shape a_shape{migraphx::shape::get_type<T>{}, {4, 5}};
     auto al = mm->add_literal(migraphx::literal{a_shape, a});
     migraphx::shape b_shape{migraphx::shape::get_type<T>{}, {5, 3}};
@@ -77,7 +66,19 @@ void dot_2d_test()
     auto result = p.eval({}).back();
     std::vector<T> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(c, results_vector));
+    std::vector<float> gold = {-1.56327541e+00,
+                               -7.09570140e-01,
+                               -5.37424982e-01,
+                               -2.22994831e-01,
+                               -2.15586437e+00,
+                               2.09177941e-03,
+                               -1.47279677e+00,
+                               2.02627040e-01,
+                               -6.04527691e-01,
+                               -1.29885596e+00,
+                               2.16294914e+00,
+                               -1.48101497e-01};
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 TEST_CASE_REGISTER(dot_2d_test<float>)
 TEST_CASE_REGISTER(dot_2d_test<double>)
@@ -87,38 +88,38 @@ void dot_4d_test()
 {
     migraphx::program p;
 
-    auto* mm             = p.get_main_module();
-    std::vector<T> a     = {-0.00925222, 0.56250403, 0.70107397,  0.75402161,  -0.505885,
-                            1.33628943,  -0.11413,   -0.31270559, 1.59336732,  -0.19361027,
-                            -0.91620867, 0.40108416, -0.06969921, 0.68483471,  -0.39906632,
-                            -1.66423624, 0.69040076, -1.31490171, -0.11282616, -0.79391814};
-    std::vector<float> b = {6.09568541e-01,
-                            -6.10527007e-01,
-                            3.66646462e-01,
-                            1.18951101e-01,
-                            5.58777432e-01,
-                            -3.21296298e-01,
-                            -5.95997198e-01,
-                            -5.01425721e-01,
-                            -2.84606807e-01,
-                            -5.73673557e-01,
-                            -8.99430260e-01,
-                            -4.25103093e-01,
-                            1.53027987e+00,
-                            -3.81407415e-04,
-                            -3.29650255e-01};
-    std::vector<float> c = {-1.56327541e+00,
-                            -7.09570140e-01,
-                            -5.37424982e-01,
-                            -2.22994831e-01,
-                            -2.15586437e+00,
-                            2.09177941e-03,
-                            -1.47279677e+00,
-                            2.02627040e-01,
-                            -6.04527691e-01,
-                            -1.29885596e+00,
-                            2.16294914e+00,
-                            -1.48101497e-01};
+    auto* mm                = p.get_main_module();
+    std::vector<T> a        = {-0.00925222, 0.56250403, 0.70107397,  0.75402161,  -0.505885,
+                               1.33628943,  -0.11413,   -0.31270559, 1.59336732,  -0.19361027,
+                               -0.91620867, 0.40108416, -0.06969921, 0.68483471,  -0.39906632,
+                               -1.66423624, 0.69040076, -1.31490171, -0.11282616, -0.79391814};
+    std::vector<float> b    = {6.09568541e-01,
+                               -6.10527007e-01,
+                               3.66646462e-01,
+                               1.18951101e-01,
+                               5.58777432e-01,
+                               -3.21296298e-01,
+                               -5.95997198e-01,
+                               -5.01425721e-01,
+                               -2.84606807e-01,
+                               -5.73673557e-01,
+                               -8.99430260e-01,
+                               -4.25103093e-01,
+                               1.53027987e+00,
+                               -3.81407415e-04,
+                               -3.29650255e-01};
+    std::vector<float> gold = {-1.56327541e+00,
+                               -7.09570140e-01,
+                               -5.37424982e-01,
+                               -2.22994831e-01,
+                               -2.15586437e+00,
+                               2.09177941e-03,
+                               -1.47279677e+00,
+                               2.02627040e-01,
+                               -6.04527691e-01,
+                               -1.29885596e+00,
+                               2.16294914e+00,
+                               -1.48101497e-01};
     migraphx::shape a_shape{migraphx::shape::get_type<T>{}, {1, 1, 4, 5}};
     auto al = mm->add_literal(migraphx::literal{a_shape, a});
     migraphx::shape b_shape{migraphx::shape::get_type<T>{}, {1, 1, 5, 3}};
@@ -128,7 +129,7 @@ void dot_4d_test()
     auto result = p.eval({}).back();
     std::vector<T> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(c, results_vector));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 TEST_CASE_REGISTER(dot_4d_test<float>)
 TEST_CASE_REGISTER(dot_4d_test<double>)
@@ -166,7 +167,7 @@ TEST_CASE(dot_3D_test)
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
-    std::vector<float> m_res = {0.18208394,
+    std::vector<float> gold = {0.18208394,
                                 -0.49276402,
                                 0.87189133,
                                 0.75150114,
@@ -183,7 +184,7 @@ TEST_CASE(dot_3D_test)
                                 0.40245487,
                                 1.80182751};
 
-    EXPECT(migraphx::verify::verify_range(m, m_res));
+    EXPECT(migraphx::verify::verify_range(m, gold));
 }
 
 TEST_CASE(dot_3D_C_test0)
@@ -242,7 +243,7 @@ TEST_CASE(dot_3D_C_test0)
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
-    std::vector<float> m_res = {0.18208394,
+    std::vector<float> gold = {0.18208394,
                                 -0.49276402,
                                 0.87189133,
                                 0.75150114,
@@ -259,7 +260,7 @@ TEST_CASE(dot_3D_C_test0)
                                 0.40245487,
                                 1.80182751};
 
-    EXPECT(migraphx::verify::verify_range(m, m_res));
+    EXPECT(migraphx::verify::verify_range(m, gold));
 }
 
 TEST_CASE(dot_3D_C_test1)
@@ -309,7 +310,7 @@ TEST_CASE(dot_3D_C_test1)
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
-    std::vector<float> m_res = {0.18208394,
+    std::vector<float> gold = {0.18208394,
                                 -0.49276402,
                                 0.87189133,
                                 0.75150114,
@@ -318,7 +319,7 @@ TEST_CASE(dot_3D_C_test1)
                                 -0.95536130,
                                 2.27996211};
 
-    EXPECT(migraphx::verify::verify_range(m, m_res));
+    EXPECT(migraphx::verify::verify_range(m, gold));
 }
 
 TEST_CASE(dot_4D_test1)
@@ -351,13 +352,13 @@ TEST_CASE(dot_4D_test1)
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
-    std::vector<float> m_res = {0.26735861,  -4.30770895, 1.05257728,  -1.19954265, 0.50493170,
+    std::vector<float> gold = {0.26735861,  -4.30770895, 1.05257728,  -1.19954265, 0.50493170,
                                 -0.18729756, 1.09137941,  -1.09298312, 3.42956915,  -0.41681939,
                                 0.17833257,  0.26040336,  0.15351280,  1.87632715,  -0.63545406,
                                 -0.95467340, -1.74728628, -2.42477030, 0.76262372,  0.15539164,
                                 3.32281958,  0.96769613,  0.43727545,  2.43019906};
 
-    EXPECT(migraphx::verify::verify_range(m, m_res));
+    EXPECT(migraphx::verify::verify_range(m, gold));
 }
 
 TEST_CASE(dot_4D_alpha_beta_test)
@@ -405,13 +406,13 @@ TEST_CASE(dot_4D_alpha_beta_test)
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
-    std::vector<float> m_res = {-0.91147203, 0.47540785, -0.30313587, 0.43325099,  -0.43711586,
+    std::vector<float> gold = {-0.91147203, 0.47540785, -0.30313587, 0.43325099,  -0.43711586,
                                 0.50928632,  0.06919868, -0.80382802, -0.05125718, -0.06685650,
                                 -0.06972163, 0.32407764, 0.45677396,  0.25909489,  0.56911252,
                                 -0.17183724, 0.10858734, 0.39406289,  0.04662959,  1.07979824,
                                 0.40355016,  0.52410648, -0.31728447, 1.09550845};
 
-    EXPECT(migraphx::verify::verify_range(m, m_res));
+    EXPECT(migraphx::verify::verify_range(m, gold));
 }
 
 TEST_CASE(dot_4D_alpha_beta_C_test)
@@ -457,13 +458,13 @@ TEST_CASE(dot_4D_alpha_beta_C_test)
     std::vector<float> m;
     result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
 
-    std::vector<float> m_res = {-0.91147203, 0.47540785, -0.30313587, 0.43325099,  -0.43711586,
+    std::vector<float> gold = {-0.91147203, 0.47540785, -0.30313587, 0.43325099,  -0.43711586,
                                 0.50928632,  0.06919868, -0.80382802, -0.05125718, -0.06685650,
                                 -0.06972163, 0.32407764, 0.45677396,  0.25909489,  0.56911252,
                                 -0.17183724, 0.10858734, 0.39406289,  0.04662959,  1.07979824,
                                 0.40355016,  0.52410648, -0.31728447, 1.09550845};
 
-    EXPECT(migraphx::verify::verify_range(m, m_res));
+    EXPECT(migraphx::verify::verify_range(m, gold));
 }
 
 TEST_CASE(dot_2D_C_test0)
@@ -1202,19 +1203,19 @@ TEST_CASE(dot_dyn_2D_test)
     auto result = p.eval(params).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    std::vector<float> c = {-1.56327541e+00,
-                            -7.09570140e-01,
-                            -5.37424982e-01,
-                            -2.22994831e-01,
-                            -2.15586437e+00,
-                            2.09177941e-03,
-                            -1.47279677e+00,
-                            2.02627040e-01,
-                            -6.04527691e-01,
-                            -1.29885596e+00,
-                            2.16294914e+00,
-                            -1.48101497e-01};
-    EXPECT(migraphx::verify::verify_range(c, results_vector));
+    std::vector<float> gold = {-1.56327541e+00,
+                               -7.09570140e-01,
+                               -5.37424982e-01,
+                               -2.22994831e-01,
+                               -2.15586437e+00,
+                               2.09177941e-03,
+                               -1.47279677e+00,
+                               2.02627040e-01,
+                               -6.04527691e-01,
+                               -1.29885596e+00,
+                               2.16294914e+00,
+                               -1.48101497e-01};
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(dot_dyn_4D_test)
@@ -1256,19 +1257,19 @@ TEST_CASE(dot_dyn_4D_test)
     auto result = p.eval(params).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    std::vector<float> c = {-1.56327541e+00,
-                            -7.09570140e-01,
-                            -5.37424982e-01,
-                            -2.22994831e-01,
-                            -2.15586437e+00,
-                            2.09177941e-03,
-                            -1.47279677e+00,
-                            2.02627040e-01,
-                            -6.04527691e-01,
-                            -1.29885596e+00,
-                            2.16294914e+00,
-                            -1.48101497e-01};
-    EXPECT(migraphx::verify::verify_range(c, results_vector));
+    std::vector<float> gold = {-1.56327541e+00,
+                               -7.09570140e-01,
+                               -5.37424982e-01,
+                               -2.22994831e-01,
+                               -2.15586437e+00,
+                               2.09177941e-03,
+                               -1.47279677e+00,
+                               2.02627040e-01,
+                               -6.04527691e-01,
+                               -1.29885596e+00,
+                               2.16294914e+00,
+                               -1.48101497e-01};
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(quant_dot_2args_multi4_1)

test/ref/im2col.cpp

@@ -40,14 +40,14 @@ TEST_CASE(im2col_3x3_no_pad_identity_test)
     std::size_t channels = 1;
 
     std::vector<int32_t> weights(channels * f[0] * f[1]);
-    std::vector<int32_t> input(channels * size[0] * size[1]);
-    std::iota(input.begin(), input.end(), 0);
+    std::vector<int32_t> gold(channels * size[0] * size[1]);
+    std::iota(gold.begin(), gold.end(), 0);
 
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape s_image{migraphx::shape::int32_type, {1, channels, size[0], size[1]}};
     migraphx::shape s_weights{migraphx::shape::int32_type, {1, channels, f[0], f[1]}};
-    auto l_image   = mm->add_literal(migraphx::literal{s_image, input});
+    auto l_image   = mm->add_literal(migraphx::literal{s_image, gold});
     auto l_weights = mm->add_literal(migraphx::literal{s_weights, weights});
     mm->add_instruction(
         migraphx::make_op("im2col",
@@ -61,7 +61,7 @@ TEST_CASE(im2col_3x3_no_pad_identity_test)
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, input));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_no_pad_test)
@@ -91,14 +91,14 @@ TEST_CASE(im2col_3x3_no_pad_test)
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
 
-    std::vector<int> correct = {0, 1, 2, 4, 5, 6,  8,  9,  10, 1, 2, 3, 5, 6,  7,  9,  10, 11,
+    std::vector<int> gold = {0, 1, 2, 4, 5, 6,  8,  9,  10, 1, 2, 3, 5, 6,  7,  9,  10, 11,
                                 4, 5, 6, 8, 9, 10, 12, 13, 14, 5, 6, 7, 9, 10, 11, 13, 14, 15};
 
     std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, correct));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_stride_2_no_pad_test)
@@ -128,15 +128,15 @@ TEST_CASE(im2col_3x3_stride_2_no_pad_test)
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
 
-    std::vector<int> correct = {0,  1,  2,  6,  7,  8,  12, 13, 14, 2,  3,  4,
-                                8,  9,  10, 14, 15, 16, 12, 13, 14, 18, 19, 20,
-                                24, 25, 26, 14, 15, 16, 20, 21, 22, 26, 27, 28};
+    std::vector<int> gold = {0,  1,  2,  6,  7,  8,  12, 13, 14, 2,  3,  4,
+                             8,  9,  10, 14, 15, 16, 12, 13, 14, 18, 19, 20,
+                             24, 25, 26, 14, 15, 16, 20, 21, 22, 26, 27, 28};
 
     std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, correct));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_with_channels_identity_test)
@@ -149,14 +149,14 @@ TEST_CASE(im2col_3x3_with_channels_identity_test)
     std::size_t channels = 2;
 
     std::vector<int32_t> weights(channels * f[0] * f[1]);
-    std::vector<int32_t> input(channels * size[0] * size[1]);
-    std::iota(input.begin(), input.end(), 0);
+    std::vector<int32_t> gold(channels * size[0] * size[1]);
+    std::iota(gold.begin(), gold.end(), 0);
 
     migraphx::program p;
     auto* mm = p.get_main_module();
     migraphx::shape s_image{migraphx::shape::int32_type, {1, channels, size[0], size[1]}};
     migraphx::shape s_weights{migraphx::shape::int32_type, {1, channels, f[0], f[1]}};
-    auto l_image   = mm->add_literal(migraphx::literal{s_image, input});
+    auto l_image   = mm->add_literal(migraphx::literal{s_image, gold});
     auto l_weights = mm->add_literal(migraphx::literal{s_weights, weights});
     mm->add_instruction(
         migraphx::make_op("im2col",
@@ -170,7 +170,7 @@ TEST_CASE(im2col_3x3_with_channels_identity_test)
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, input));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(im2col_3x3_with_padding_test)
@@ -200,12 +200,12 @@ TEST_CASE(im2col_3x3_with_padding_test)
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
 
-    std::vector<int> correct = {0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0,
-                                0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0};
+    std::vector<int> gold = {0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0,
+                             0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0};
 
     std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
     std::size_t col_width  = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
     std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, correct));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }

test/ref/isnan.cpp

@@ -45,8 +45,8 @@ TEST_CASE(isnan_test)
         auto result = p.eval({}).back();
         std::vector<float> results_vector;
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-        std::vector<float> correct = {0, 0, 1, 1, 0, 0};
-        EXPECT(migraphx::verify::verify_range(results_vector, correct));
+        std::vector<float> gold = {0, 0, 1, 1, 0, 0};
+        EXPECT(migraphx::verify::verify_range(results_vector, gold));
     }
 
     // half test
@@ -64,8 +64,8 @@ TEST_CASE(isnan_test)
         auto result = p.eval({}).back();
         std::vector<float> results_vector;
         result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-        std::vector<float> correct = {0, 0, 1, 1, 0, 0};
-        EXPECT(migraphx::verify::verify_range(results_vector, correct));
+        std::vector<float> gold = {0, 0, 1, 1, 0, 0};
+        EXPECT(migraphx::verify::verify_range(results_vector, gold));
     }
 }
 
@@ -86,6 +86,6 @@ TEST_CASE(isnan_dyn_test)
     auto result  = p.eval(params0).back();
     std::vector<float> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    std::vector<float> correct = {0, 0, 1, 1, 0, 0};
-    EXPECT(migraphx::verify::verify_range(results_vector, correct));
+    std::vector<float> gold = {0, 0, 1, 1, 0, 0};
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }

test/ref/multinomial.cpp

@@ -79,5 +79,5 @@ TEST_CASE(multinomial_test)
         return static_cast<double>(n) / res_dist_sum;
     });
     EXPECT(migraphx::verify::verify_range_with_threshold(
-        res_norm, migraphx::verify::expected{norm}, 0.01));
+        res_norm, migraphx::verify::expected{norm}, migraphx::verify::threshold{0.01}));
 }

test/ref/pooling.cpp

@@ -565,12 +565,6 @@ TEST_CASE(maxpool_test)
         -0.88503587, 0.6629802,   1.47319221,  -1.05829155, -0.97027361, -0.93187737, -1.39954746,
         -0.52359426, -0.14743951, 1.51522756,  0.2078452,   -1.28156149, -1.19363916, -0.78680223,
         -0.89094824, 1.30212069,  -0.77974445, -0.58411664, 0.48764706,  -0.67132682};
-    std::vector<float> c = {1.33493888, 1.54562736, 1.22098756, 1.33493888, 1.18358743, 1.99097753,
-                            1.00170159, 1.45862222, 1.39087725, 1.46645272, 1.18943918, -0.01443311,
-                            1.47151589, 2.36277103, 2.24768877, 0.68883753, 0.82949388, 0.71550399,
-                            1.95433736, 2.46601582, 1.53285873, 1.95433736, 1.06763375, 1.4545635,
-                            1.33624589, 1.16736257, 0.6126079,  1.36892557, 2.40126371, 1.53441942,
-                            0.52119428, 2.07681108, 0.88494766, 1.51522756, 0.54275119, 0.6629802};
     migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 6, 6}};
     auto al = mm->add_literal(migraphx::literal{a_shape, a});
     mm->add_instruction(migraphx::make_op("pooling",
@@ -583,7 +577,15 @@ TEST_CASE(maxpool_test)
     auto result = p.eval({}).back();
     std::vector<float> results_vector(36);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, c));
+    std::vector<float> gold = {
+        1.33493888, 1.54562736, 1.22098756, 1.33493888, 1.18358743, 1.99097753,
+        1.00170159, 1.45862222, 1.39087725, 1.46645272, 1.18943918, -0.01443311,
+        1.47151589, 2.36277103, 2.24768877, 0.68883753, 0.82949388, 0.71550399,
+        1.95433736, 2.46601582, 1.53285873, 1.95433736, 1.06763375, 1.4545635,
+        1.33624589, 1.16736257, 0.6126079,  1.36892557, 2.40126371, 1.53441942,
+        0.52119428, 2.07681108, 0.88494766, 1.51522756, 0.54275119, 0.6629802};
+
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(maxpool_pad_test)
@@ -591,7 +593,6 @@ TEST_CASE(maxpool_pad_test)
     migraphx::program p;
     auto* mm             = p.get_main_module();
     std::vector<float> a = {-6, -5, -4, -3, -5, -1, 0, 1, 2, 3, 4, 5};
-    std::vector<float> c = {-4, -3, -4, -1, 2, 3, 4, 5};
     migraphx::shape a_shape{migraphx::shape::float_type, {1, 2, 3, 2}};
     auto al = mm->add_literal(migraphx::literal{a_shape, a});
     mm->add_instruction(migraphx::make_op("pooling",
@@ -611,8 +612,8 @@ TEST_CASE(maxpool_pad_test)
     auto result = p.eval({}).back();
     std::vector<float> results_vector(8);
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-
-    EXPECT(migraphx::verify::verify_range(results_vector, c));
+    std::vector<float> gold = {-4, -3, -4, -1, 2, 3, 4, 5};
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(maxpool_rank3_test0)

test/ref/quant_convolution.cpp

@@ -47,7 +47,7 @@ TEST_CASE(quant_conv2d_padding_stride_test)
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
 
-    std::vector<int32_t> s = {4521,
+    std::vector<int32_t> gold = {4521,
                               7014,
                               7830,
                               11952,
@@ -65,7 +65,7 @@ TEST_CASE(quant_conv2d_padding_stride_test)
                               82746};
     std::vector<int32_t> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, s));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(quant_conv2d_padding_test)
@@ -83,8 +83,8 @@ TEST_CASE(quant_conv2d_padding_test)
     mm->add_instruction(
         migraphx::make_op("quant_convolution", {{"padding", {1, 1}}, {"stride", {1, 1}}}), al, cl);
     p.compile(migraphx::make_target("ref"));
-    auto result            = p.eval({}).back();
-    std::vector<int32_t> s = {
+    auto result               = p.eval({}).back();
+    std::vector<int32_t> gold = {
         4521,  6753,  7014,  4635,  6858,  10197, 10548, 6939,  7830,  11601, 11952, 7839,  5007,
         7383,  7590,  4953,  10515, 15987, 16734, 11277, 16821, 25506, 26586, 17874, 19737, 29826,
         30906, 20718, 13593, 20505, 21198, 14187, 13161, 19281, 19542, 12699, 18522, 27045, 27396,
@@ -93,7 +93,7 @@ TEST_CASE(quant_conv2d_padding_test)
 
     std::vector<int32_t> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, s));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(quant_conv2d_test)
@@ -114,24 +114,24 @@ TEST_CASE(quant_conv2d_test)
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
 
-    std::vector<int32_t> s = {10197,
-                              10548,
-                              11601,
-                              11952,
-                              25506,
-                              26586,
-                              29826,
-                              30906,
-                              27045,
-                              27396,
-                              28449,
-                              28800,
-                              77346,
-                              78426,
-                              81666,
-                              82746};
+    std::vector<int32_t> gold = {10197,
+                                 10548,
+                                 11601,
+                                 11952,
+                                 25506,
+                                 26586,
+                                 29826,
+                                 30906,
+                                 27045,
+                                 27396,
+                                 28449,
+                                 28800,
+                                 77346,
+                                 78426,
+                                 81666,
+                                 82746};
 
     std::vector<int32_t> results_vector;
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, s));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }

test/ref/random_uniform.cpp

@@ -68,8 +68,9 @@ TEST_CASE(random_uniform_test)
     std::uniform_real_distribution<> dis(0.0, 1.0);
     std::vector<float> rand_samples(sample_size);
     std::generate(rand_samples.begin(), rand_samples.end(), [&]() { return dis(gen); });
-    EXPECT(migraphx::verify::verify_range_with_threshold(
-        result_vec, migraphx::verify::expected{rand_samples}, 0.00001));
+    EXPECT(migraphx::verify::verify_range_with_threshold(result_vec,
+                                                         migraphx::verify::expected{rand_samples},
+                                                         migraphx::verify::threshold{0.00001}));
 }
 
 TEST_CASE(random_uniform_int_test)
@@ -103,9 +104,9 @@ TEST_CASE(random_uniform_int_test)
     // Compare result with the STL's mt19937 generator
     std::mt19937 gen(seed);
     std::uniform_int_distribution<uint16_t> dis;
-    std::vector<uint16_t> rand_samples(sample_size);
-    std::generate(rand_samples.begin(), rand_samples.end(), [&]() { return dis(gen); });
-    EXPECT(migraphx::verify::verify_range(result_vec, rand_samples));
+    std::vector<uint16_t> gold_rand_samples(sample_size);
+    std::generate(gold_rand_samples.begin(), gold_rand_samples.end(), [&]() { return dis(gen); });
+    EXPECT(migraphx::verify::verify_range(result_vec, gold_rand_samples));
 }
 
 TEST_CASE(random_uniform_dyn_test)
@@ -142,9 +143,9 @@ TEST_CASE(random_uniform_dyn_test)
     // Compare result with the STL's mt19937 generator
     std::mt19937 gen(seed);
     std::uniform_real_distribution<> dis(0.0, 1.0);
-    std::vector<float> rand_samples(sample_size);
-    std::generate(rand_samples.begin(), rand_samples.end(), [&]() { return dis(gen); });
-    EXPECT(migraphx::verify::verify_range(result_vec, rand_samples));
+    std::vector<float> gold_rand_samples(sample_size);
+    std::generate(gold_rand_samples.begin(), gold_rand_samples.end(), [&]() { return dis(gen); });
+    EXPECT(migraphx::verify::verify_range(result_vec, gold_rand_samples));
 }
 
 TEST_CASE(random_uniform_and_seed_test)

test/ref/reshape.cpp

@@ -33,52 +33,52 @@
 TEST_CASE(reshape_test0)
 {
     migraphx::shape a_shape{migraphx::shape::float_type, {24, 1, 1, 1}};
-    std::vector<float> data(24);
-    std::iota(data.begin(), data.end(), -3);
+    std::vector<float> gold(24);
+    std::iota(gold.begin(), gold.end(), -3);
     migraphx::program p;
     auto* mm                       = p.get_main_module();
-    auto l                         = mm->add_literal(migraphx::literal{a_shape, data});
+    auto l                         = mm->add_literal(migraphx::literal{a_shape, gold});
     std::vector<int64_t> new_shape = {8, 3, 1, 1};
     mm->add_instruction(migraphx::make_op("reshape", {{"dims", new_shape}}), l);
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
     std::vector<float> results_vector{};
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, data));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(reshape_test1)
 {
     migraphx::shape a_shape{migraphx::shape::float_type, {24, 1, 1, 1}};
-    std::vector<float> data(24);
-    std::iota(data.begin(), data.end(), -3);
+    std::vector<float> gold(24);
+    std::iota(gold.begin(), gold.end(), -3);
     migraphx::program p;
     auto* mm                       = p.get_main_module();
-    auto l                         = mm->add_literal(migraphx::literal{a_shape, data});
+    auto l                         = mm->add_literal(migraphx::literal{a_shape, gold});
     std::vector<int64_t> new_shape = {1, 3, 4, 2};
     mm->add_instruction(migraphx::make_op("reshape", {{"dims", new_shape}}), l);
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
     std::vector<float> results_vector{};
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, data));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(reshape_test2)
 {
     migraphx::shape a_shape{migraphx::shape::float_type, {24, 1, 1, 1}};
-    std::vector<float> data(24);
-    std::iota(data.begin(), data.end(), -3);
+    std::vector<float> gold(24);
+    std::iota(gold.begin(), gold.end(), -3);
     migraphx::program p;
     auto* mm                       = p.get_main_module();
-    auto l                         = mm->add_literal(migraphx::literal{a_shape, data});
+    auto l                         = mm->add_literal(migraphx::literal{a_shape, gold});
     std::vector<int64_t> new_shape = {1, 2, 3, 4};
     mm->add_instruction(migraphx::make_op("reshape", {{"dims", new_shape}}), l);
     p.compile(migraphx::make_target("ref"));
     auto result = p.eval({}).back();
     std::vector<float> results_vector{};
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, data));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }
 
 TEST_CASE(reshape_dyn_test)
@@ -91,13 +91,13 @@ TEST_CASE(reshape_dyn_test)
     mm->add_instruction(migraphx::make_op("reshape", {{"dims", new_shape}}), input);
     p.compile(migraphx::make_target("ref"));
 
-    std::vector<float> data(48);
-    std::iota(data.begin(), data.end(), -3);
+    std::vector<float> gold(48);
+    std::iota(gold.begin(), gold.end(), -3);
     migraphx::parameter_map params;
     migraphx::shape input_fixed_shape{migraphx::shape::float_type, {2, 24, 1, 1}};
-    params["X"] = migraphx::argument(input_fixed_shape, data.data());
+    params["X"] = migraphx::argument(input_fixed_shape, gold.data());
     auto result = p.eval(params).back();
     std::vector<float> results_vector{};
     result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
-    EXPECT(migraphx::verify::verify_range(results_vector, data));
+    EXPECT(migraphx::verify::verify_range(results_vector, gold));
 }