diff --git a/audio/2.0/vts/functional/AudioPrimaryHidlHalTest.cpp b/audio/2.0/vts/functional/AudioPrimaryHidlHalTest.cpp
index 46a2f78..447ceaa 100644
--- a/audio/2.0/vts/functional/AudioPrimaryHidlHalTest.cpp
+++ b/audio/2.0/vts/functional/AudioPrimaryHidlHalTest.cpp
@@ -318,7 +318,7 @@
    protected:
     bool areAudioPatchesSupported() {
         auto result = device->supportsAudioPatches();
-        EXPECT_TRUE(result.isOk());
+        EXPECT_IS_OK(result);
         return result;
     }
 };
@@ -494,10 +494,10 @@
     doc::test("Check that the hal can receive the screen state");
     for (bool turnedOn : {false, true, true, false, false}) {
         auto ret = device->setScreenState(turnedOn);
-        ASSERT_TRUE(ret.isOk());
+        ASSERT_IS_OK(ret);
         Result result = ret;
-        ASSERT_TRUE(result == Result::OK || result == Result::NOT_SUPPORTED)
-            << toString(result);
+        auto okOrNotSupported = {Result::OK, Result::NOT_SUPPORTED};
+        ASSERT_RESULT(okOrNotSupported, result);
     }
 }
 
@@ -715,7 +715,7 @@
 template <class R>
 static R extract(Return<R> ret) {
     if (!ret.isOk()) {
-        ADD_FAILURE();
+        EXPECT_IS_OK(ret);
         return R{};
     }
     return ret;
@@ -819,7 +819,7 @@
     // NOT_SUPPORTED
     // Thus allow NONE as signaling that the call is not supported.
     auto ret = stream->getDevice();
-    ASSERT_TRUE(ret.isOk());
+    ASSERT_IS_OK(ret);
     AudioDevice device = ret;
     ASSERT_TRUE(device == expectedDevice || device == AudioDevice::NONE)
         << "Expected: " << ::testing::PrintToString(expectedDevice)
@@ -891,7 +891,7 @@
                              stream->setHwAvSync(666)))
 
 TEST_IO_STREAM(GetHwAvSync, "Get hardware sync can not fail",
-               ASSERT_TRUE(device->getHwAvSync().isOk()))
+               ASSERT_IS_OK(device->getHwAvSync()));
 
 static void checkGetNoParameter(IStream* stream, hidl_vec<hidl_string> keys,
                                 vector<Result> expectedResults) {
@@ -1048,7 +1048,7 @@
 static void testOptionalUnitaryGain(
     std::function<Return<Result>(float)> setGain, string debugName) {
     auto result = setGain(1);
-    ASSERT_TRUE(result.isOk());
+    ASSERT_IS_OK(result);
     if (result == Result::NOT_SUPPORTED) {
         doc::partialTest(debugName + " is not supported");
         return;
@@ -1098,7 +1098,7 @@
     doc::test(
         "The number of frames lost on a never started stream should be 0");
     auto ret = stream->getInputFramesLost();
-    ASSERT_TRUE(ret.isOk());
+    ASSERT_IS_OK(ret);
     uint32_t framesLost{ret};
     ASSERT_EQ(0U, framesLost);
 }
@@ -1120,7 +1120,7 @@
 TEST_P(OutputStreamTest, getLatency) {
     doc::test("Make sure latency is over 0");
     auto result = stream->getLatency();
-    ASSERT_TRUE(result.isOk());
+    ASSERT_IS_OK(result);
     ASSERT_GT(result, 0U);
 }
 
@@ -1166,7 +1166,7 @@
     Capability(IStreamOut* stream) {
         EXPECT_OK(stream->supportsPauseAndResume(returnIn(pause, resume)));
         auto ret = stream->supportsDrain();
-        EXPECT_TRUE(ret.isOk());
+        EXPECT_IS_OK(ret);
         if (ret.isOk()) {
             drain = ret;
         }
@@ -1301,7 +1301,7 @@
 TEST_P(OutputStreamTest, FlushStop) {
     doc::test("If supported, a stream should always succeed to flush");
     auto ret = stream->flush();
-    ASSERT_TRUE(ret.isOk());
+    ASSERT_IS_OK(ret);
     if (ret == Result::NOT_SUPPORTED) {
         doc::partialTest("Flush is not supported");
         return;
diff --git a/audio/2.0/vts/functional/utility/AssertOk.h b/audio/2.0/vts/functional/utility/AssertOk.h
index 6891dc4..4c8440e 100644
--- a/audio/2.0/vts/functional/utility/AssertOk.h
+++ b/audio/2.0/vts/functional/utility/AssertOk.h
@@ -26,49 +26,93 @@
 using ::android::hardware::Return;
 using ::android::hardware::audio::V2_0::Result;
 
-inline void assertResult(Result expected, Result result) {
-    ASSERT_EQ(expected, result);
+template <class T>
+inline ::testing::AssertionResult assertIsOk(const char* expr,
+                                             const Return<T>& ret) {
+    return ::testing::AssertionResult(ret.isOk())
+           << "Expected: " << expr
+           << "\n to be an OK Return but it is not: " << ret.description();
 }
 
-inline void assertResult(Result expected, const Return<Result>& ret) {
-    ASSERT_TRUE(ret.isOk());
-    Result result = ret;
-    assertResult(expected, result);
+// Call continuation if the provided result isOk
+template <class T, class Continuation>
+inline ::testing::AssertionResult continueIfIsOk(const char* expr,
+                                                 const Return<T>& ret,
+                                                 Continuation continuation) {
+    auto isOkStatus = assertIsOk(expr, ret);
+    return !isOkStatus ? isOkStatus : continuation();
 }
 
-inline void assertResult(const std::vector<Result>& expected, Result result) {
+// Expect two equal Results
+inline ::testing::AssertionResult assertResult(const char* e_expr,
+                                               const char* r_expr,
+                                               Result expected, Result result) {
+    return ::testing::AssertionResult(expected == result)
+           << "Value of: " << r_expr
+           << "\n  Actual: " << ::testing::PrintToString(result)
+           << "\nExpected: " << e_expr
+           << "\nWhich is: " << ::testing::PrintToString(expected);
+}
+
+// Expect two equal Results one being wrapped in an OK Return
+inline ::testing::AssertionResult assertResult(const char* e_expr,
+                                               const char* r_expr,
+                                               Result expected,
+                                               const Return<Result>& ret) {
+    return continueIfIsOk(r_expr, ret, [&] {
+        return assertResult(e_expr, r_expr, expected, Result{ret});
+    });
+}
+
+// Expect a Result to be part of a list of Results
+inline ::testing::AssertionResult assertResult(
+    const char* e_expr, const char* r_expr, const std::vector<Result>& expected,
+    Result result) {
     if (std::find(expected.begin(), expected.end(), result) != expected.end()) {
-        return;  // result is in expected
+        return ::testing::AssertionSuccess();  // result is in expected
     }
-    FAIL() << "Expected result " << ::testing::PrintToString(result)
-           << " to be one of " << ::testing::PrintToString(expected);
+    return ::testing::AssertionFailure()
+           << "Value of: " << r_expr
+           << "\n  Actual: " << ::testing::PrintToString(result)
+           << "\nExpected one of: " << e_expr
+           << "\n       Which is: " << ::testing::PrintToString(expected);
 }
 
-inline void assertResult(const std::vector<Result>& expected,
-                         const Return<Result>& ret) {
-    ASSERT_TRUE(ret.isOk());
-    Result result = ret;
-    assertResult(expected, result);
+// Expect a Result wrapped in an OK Return to be part of a list of Results
+inline ::testing::AssertionResult assertResult(
+    const char* e_expr, const char* r_expr, const std::vector<Result>& expected,
+    const Return<Result>& ret) {
+    return continueIfIsOk(r_expr, ret, [&] {
+        return assertResult(e_expr, r_expr, expected, Result{ret});
+    });
 }
 
-inline void assertOk(const Return<void>& ret) {
-    ASSERT_TRUE(ret.isOk());
+inline ::testing::AssertionResult assertOk(const char* expr,
+                                           const Return<void>& ret) {
+    return assertIsOk(expr, ret);
 }
 
-inline void assertOk(Result result) {
-    assertResult(Result::OK, result);
+inline ::testing::AssertionResult assertOk(const char* expr, Result result) {
+    return ::testing::AssertionResult(result == Result::OK)
+           << "Expected success: " << expr
+           << "\nActual: " << ::testing::PrintToString(result);
 }
 
-inline void assertOk(const Return<Result>& ret) {
-    assertResult(Result::OK, ret);
+inline ::testing::AssertionResult assertOk(const char* expr,
+                                           const Return<Result>& ret) {
+    return continueIfIsOk(expr, ret,
+                          [&] { return assertOk(expr, Result{ret}); });
 }
 }
 
+#define ASSERT_IS_OK(ret) ASSERT_PRED_FORMAT1(detail::assertIsOk, ret)
+#define EXPECT_IS_OK(ret) EXPECT_PRED_FORMAT1(detail::assertIsOk, ret)
+
 // Test anything provided is and contains only OK
-#define ASSERT_OK(ret) ASSERT_NO_FATAL_FAILURE(detail::assertOk(ret))
-#define EXPECT_OK(ret) EXPECT_NO_FATAL_FAILURE(detail::assertOk(ret))
+#define ASSERT_OK(ret) ASSERT_PRED_FORMAT1(detail::assertOk, ret)
+#define EXPECT_OK(ret) EXPECT_PRED_FORMAT1(detail::assertOk, ret)
 
 #define ASSERT_RESULT(expected, ret) \
-    ASSERT_NO_FATAL_FAILURE(detail::assertResult(expected, ret))
+    ASSERT_PRED_FORMAT2(detail::assertResult, expected, ret)
 #define EXPECT_RESULT(expected, ret) \
-    EXPECT_NO_FATAL_FAILURE(detail::assertResult(expected, ret))
+    EXPECT_PRED_FORMAT2(detail::assertResult, expected, ret)