Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f26f67a1 authored by Kevin Rocard's avatar Kevin Rocard
Browse files

Audio HAL VTS: Improve ASSERT of Result and Return 



Previously tests on Result and Return were using ASSERT_NO_FATAL_FAILURE
and helper methods.
This leaded to complex error messages were the error did not pointed to
the helper methods instead of the ASSERT_RESULT call.
Additionally SCOPE_TRACE messages are repeated
for each ASSERT_NO_FATAL_FAILURE level.

Use ::testing::AssertionResult to improve drastically the error messages.

Test: vts-tradefed run vts --module VtsHalAudioV2_0Target
Test: call/play music/record/video...
Bug: 36311550
Change-Id: If705502546606d678df3f1966b0cd9f3ef8c2529
Signed-off-by: default avatarKevin Rocard <krocard@google.com>
parent 304b6c81

audio/2.0/vts/functional/AudioPrimaryHidlHalTest.cpp

+12 −12
Original line number Diff line number Diff line
@@ -318,7 +318,7 @@ class AudioPatchPrimaryHidlTest : public AudioPrimaryHidlTest { 
   protected:

    bool areAudioPatchesSupported() {

        auto result = device->supportsAudioPatches();

        EXPECT_TRUE(result.isOk());

        EXPECT_IS_OK(result);

        return result;

    }

};
@@ -494,10 +494,10 @@ TEST_F(AudioPrimaryHidlTest, setScreenState) { 
    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 @@ INSTANTIATE_TEST_CASE_P( 
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 @@ static void testGetDevice(IStream* stream, AudioDevice expectedDevice) { 
    // 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 @@ TEST_IO_STREAM(SetHwAvSync, "Try to set hardware sync to an invalid value", 
                             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 testUnitaryGain(std::function<Return<Result>(float)> setGain) { 
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 @@ TEST_P(InputStreamTest, GetInputFramesLost) { 
    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(InputStreamTest, getCapturePosition) { 
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 @@ struct Capability { 
    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, DrainEarlyNotify) { 
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;

audio/2.0/vts/functional/utility/AssertOk.h

+69 −25
Original line number Diff line number Diff line
@@ -26,49 +26,93 @@ namespace detail { 
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,

// 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) {

    ASSERT_TRUE(ret.isOk());

    Result result = ret;

    assertResult(expected, result);

    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)