diff --git a/tests/unit_tests/lapack/include/lapack_gtest_suite.hpp b/tests/unit_tests/lapack/include/lapack_gtest_suite.hpp
index 41e349d7c..d3cd2b12e 100644
--- a/tests/unit_tests/lapack/include/lapack_gtest_suite.hpp
+++ b/tests/unit_tests/lapack/include/lapack_gtest_suite.hpp
@@ -80,49 +80,55 @@ using ComplexDoublePrecisionUsm = std::complex<double>;
     DEFINE_TEST_ACCURACY_USM_COMPLEX(SUITE);                \
     INSTANTIATE_TEST_CLASS(SUITE, AccuracyUsm)
 
-#define DEFINE_TEST_ACCURACY_USM_REAL(SUITE)                                                   \
-    TEST_P(SUITE##AccuracyUsm, RealSinglePrecision) {                                          \
-        test_log::padding = "[          ] ";                                                   \
-        EXPECT_TRUE(accuracy_controller.run(::accuracy<RealSinglePrecisionUsm>, *GetParam())); \
-    }                                                                                          \
-    TEST_P(SUITE##AccuracyUsm, RealDoublePrecision) {                                          \
-        CHECK_DOUBLE_ON_DEVICE(GetParam());                                                    \
-        test_log::padding = "[          ] ";                                                   \
-        EXPECT_TRUE(accuracy_controller.run(::accuracy<RealDoublePrecisionUsm>, *GetParam())); \
+#define DEFINE_TEST_ACCURACY_USM_REAL(SUITE)                                           \
+    TEST_P(SUITE##AccuracyUsm, RealSinglePrecision) {                                  \
+        test_log::padding = "[          ] ";                                           \
+        EXPECT_TRUEORSKIP(                                                             \
+            accuracy_controller.run(::accuracy<RealSinglePrecisionUsm>, *GetParam())); \
+    }                                                                                  \
+    TEST_P(SUITE##AccuracyUsm, RealDoublePrecision) {                                  \
+        CHECK_DOUBLE_ON_DEVICE(GetParam());                                            \
+        test_log::padding = "[          ] ";                                           \
+        EXPECT_TRUEORSKIP(                                                             \
+            accuracy_controller.run(::accuracy<RealDoublePrecisionUsm>, *GetParam())); \
     }
 
-#define DEFINE_TEST_ACCURACY_USM_COMPLEX(SUITE)                                                   \
-    TEST_P(SUITE##AccuracyUsm, ComplexSinglePrecision) {                                          \
-        test_log::padding = "[          ] ";                                                      \
-        EXPECT_TRUE(accuracy_controller.run(::accuracy<ComplexSinglePrecisionUsm>, *GetParam())); \
-    }                                                                                             \
-    TEST_P(SUITE##AccuracyUsm, ComplexDoublePrecision) {                                          \
-        CHECK_DOUBLE_ON_DEVICE(GetParam());                                                       \
-        test_log::padding = "[          ] ";                                                      \
-        EXPECT_TRUE(accuracy_controller.run(::accuracy<ComplexDoublePrecisionUsm>, *GetParam())); \
+#define DEFINE_TEST_ACCURACY_USM_COMPLEX(SUITE)                                           \
+    TEST_P(SUITE##AccuracyUsm, ComplexSinglePrecision) {                                  \
+        test_log::padding = "[          ] ";                                              \
+        EXPECT_TRUEORSKIP(                                                                \
+            accuracy_controller.run(::accuracy<ComplexSinglePrecisionUsm>, *GetParam())); \
+    }                                                                                     \
+    TEST_P(SUITE##AccuracyUsm, ComplexDoublePrecision) {                                  \
+        CHECK_DOUBLE_ON_DEVICE(GetParam());                                               \
+        test_log::padding = "[          ] ";                                              \
+        EXPECT_TRUEORSKIP(                                                                \
+            accuracy_controller.run(::accuracy<ComplexDoublePrecisionUsm>, *GetParam())); \
     }
 
-#define DEFINE_TEST_ACCURACY_BUFFER_REAL(SUITE)                                                   \
-    TEST_P(SUITE##AccuracyBuffer, RealSinglePrecision) {                                          \
-        test_log::padding = "[          ] ";                                                      \
-        EXPECT_TRUE(accuracy_controller.run(::accuracy<RealSinglePrecisionBuffer>, *GetParam())); \
-    }                                                                                             \
-    TEST_P(SUITE##AccuracyBuffer, RealDoublePrecision) {                                          \
-        CHECK_DOUBLE_ON_DEVICE(GetParam());                                                       \
-        test_log::padding = "[          ] ";                                                      \
-        EXPECT_TRUE(accuracy_controller.run(::accuracy<RealDoublePrecisionBuffer>, *GetParam())); \
+#define DEFINE_TEST_ACCURACY_BUFFER_REAL(SUITE)                                           \
+    TEST_P(SUITE##AccuracyBuffer, RealSinglePrecision) {                                  \
+        test_log::padding = "[          ] ";                                              \
+        EXPECT_TRUEORSKIP(                                                                \
+            accuracy_controller.run(::accuracy<RealSinglePrecisionBuffer>, *GetParam())); \
+    }                                                                                     \
+    TEST_P(SUITE##AccuracyBuffer, RealDoublePrecision) {                                  \
+        CHECK_DOUBLE_ON_DEVICE(GetParam());                                               \
+        test_log::padding = "[          ] ";                                              \
+        EXPECT_TRUEORSKIP(                                                                \
+            accuracy_controller.run(::accuracy<RealDoublePrecisionBuffer>, *GetParam())); \
     }
 
 #define DEFINE_TEST_ACCURACY_BUFFER_COMPLEX(SUITE)                                           \
     TEST_P(SUITE##AccuracyBuffer, ComplexSinglePrecision) {                                  \
         test_log::padding = "[          ] ";                                                 \
-        EXPECT_TRUE(                                                                         \
+        EXPECT_TRUEORSKIP(                                                                   \
             accuracy_controller.run(::accuracy<ComplexSinglePrecisionBuffer>, *GetParam())); \
     }                                                                                        \
     TEST_P(SUITE##AccuracyBuffer, ComplexDoublePrecision) {                                  \
         CHECK_DOUBLE_ON_DEVICE(GetParam());                                                  \
         test_log::padding = "[          ] ";                                                 \
-        EXPECT_TRUE(                                                                         \
+        EXPECT_TRUEORSKIP(                                                                   \
             accuracy_controller.run(::accuracy<ComplexDoublePrecisionBuffer>, *GetParam())); \
     }
 
@@ -145,25 +151,25 @@ using ComplexDoublePrecisionUsm = std::complex<double>;
 #define DEFINE_TEST_DEPENDENCY_REAL(SUITE)                                                     \
     TEST_P(SUITE##DependencyUsm, RealSinglePrecision) {                                        \
         test_log::padding = "[          ] ";                                                   \
-        EXPECT_TRUE(                                                                           \
+        EXPECT_TRUEORSKIP(                                                                     \
             dependency_controller.run(::usm_dependency<RealSinglePrecisionUsm>, *GetParam())); \
     }                                                                                          \
     TEST_P(SUITE##DependencyUsm, RealDoublePrecision) {                                        \
         CHECK_DOUBLE_ON_DEVICE(GetParam());                                                    \
         test_log::padding = "[          ] ";                                                   \
-        EXPECT_TRUE(                                                                           \
+        EXPECT_TRUEORSKIP(                                                                     \
             dependency_controller.run(::usm_dependency<RealDoublePrecisionUsm>, *GetParam())); \
     }
 
 #define DEFINE_TEST_DEPENDENCY_COMPLEX(SUITE)                                                     \
     TEST_P(SUITE##DependencyUsm, ComplexSinglePrecision) {                                        \
         test_log::padding = "[          ] ";                                                      \
-        EXPECT_TRUE(                                                                              \
+        EXPECT_TRUEORSKIP(                                                                        \
             dependency_controller.run(::usm_dependency<ComplexSinglePrecisionUsm>, *GetParam())); \
     }                                                                                             \
     TEST_P(SUITE##DependencyUsm, ComplexDoublePrecision) {                                        \
         CHECK_DOUBLE_ON_DEVICE(GetParam());                                                       \
         test_log::padding = "[          ] ";                                                      \
-        EXPECT_TRUE(                                                                              \
+        EXPECT_TRUEORSKIP(                                                                        \
             dependency_controller.run(::usm_dependency<ComplexDoublePrecisionUsm>, *GetParam())); \
     }\
diff --git a/tests/unit_tests/lapack/include/lapack_test_controller.hpp b/tests/unit_tests/lapack/include/lapack_test_controller.hpp
index 3e21fa104..21de7cdb8 100644
--- a/tests/unit_tests/lapack/include/lapack_test_controller.hpp
+++ b/tests/unit_tests/lapack/include/lapack_test_controller.hpp
@@ -33,6 +33,8 @@
 #include "lapack_common.hpp"
 #include "oneapi/math/exceptions.hpp"
 
+#include "test_helper.hpp"
+
 template <class T>
 std::istream& operator>>(std::istream& is, T& t) {
     int64_t i;
@@ -71,7 +73,7 @@ inline std::ostream& operator<<(std::ostream& os, const oneapi::math::generate&
 
 class result_T {
 public:
-    enum class result { fail, pass, exception };
+    enum result { fail, pass, skipped, exception };
 
     result_T() : result_{ result::pass } {}
     result_T(bool b) : result_{ b ? result::pass : result::fail } {}
@@ -79,11 +81,15 @@ class result_T {
             : result_{ t },
               what_{ e.what() } {}
 
-    operator bool() const& {
-        return result_ == result::pass;
+    inline operator int() {
+        std::cout << result_ << std::endl;
+        if (result_ == result::skipped)
+            return test_skipped;
+        else
+            return result_ == result::pass;
     }
-
     friend bool operator==(const result_T& lhs, const result_T& rhs);
+    friend bool operator!=(const result_T& lhs, const int& rhs);
     friend std::ostream& operator<<(std::ostream& os, result_T result);
 
 private:
@@ -97,10 +103,13 @@ inline bool operator==(const result_T& lhs, const result_T& rhs) {
 inline bool operator!=(const result_T& lhs, const result_T& rhs) {
     return !(lhs == rhs);
 }
-
+inline bool operator!=(const result_T& lhs, const int& rhs) {
+    return !(lhs.result_ == rhs);
+}
 inline std::ostream& operator<<(std::ostream& os, result_T result) {
     switch (result.result_) {
         case result_T::result::pass: os << "PASS"; break;
+        case result_T::result::skipped: os << "SKIPPED"; break;
         case result_T::result::fail: os << "FAIL"; break;
         case result_T::result::exception: os << "EXCEPTION " << result.what_; break;
     }
@@ -174,10 +183,10 @@ struct InputTestController {
             result = std::apply(tp, tp_args);
         }
         catch (const oneapi::math::unsupported_device& e) {
-            result = result_T{ e, result_T::result::pass };
+            result = result_T{ e, result_T::result::skipped };
         }
         catch (const oneapi::math::unimplemented& e) {
-            result = result_T{ e, result_T::result::pass };
+            result = result_T{ e, result_T::result::skipped };
         }
         catch (const std::exception& e) {
             result = result_T{ e };
@@ -201,7 +210,7 @@ struct InputTestController {
             size_t input_file_line = 1;
             for (auto& args : vargs) {
                 result_T result = call_test(tp, dev, args);
-                if (!result) {
+                if (result != result_T::result::pass) {
                     aggregate_result = result;
                 }
                 print_result(input_file_line++, result, args,