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

Commit af8a2f93 authored by Brian Duddie's avatar Brian Duddie
Browse files

Run clang-format on context hub 1.0 VTS 

Test: n/a
Change-Id: I80eb0a7c0b722ede4ed84087a7b5e4ed318e5fd5
parent a7bf0d20

contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp

+159 −177
Original line number Diff line number Diff line
@@ -30,10 +30,11 @@ 
#include <future>

#include <utility>



using ::android::hardware::Return;

using ::android::hardware::Void;

using ::android::sp;

using ::android::hardware::hidl_string;

using ::android::hardware::hidl_vec;

using ::android::hardware::Return;

using ::android::hardware::Void;

using ::android::hardware::contexthub::V1_0::AsyncEventType;

using ::android::hardware::contexthub::V1_0::ContextHub;

using ::android::hardware::contexthub::V1_0::ContextHubMsg;
@@ -43,7 +44,6 @@ using ::android::hardware::contexthub::V1_0::IContexthubCallback; 
using ::android::hardware::contexthub::V1_0::NanoAppBinary;

using ::android::hardware::contexthub::V1_0::Result;

using ::android::hardware::contexthub::V1_0::TransactionResult;

using ::android::sp;



#define ASSERT_OK(result) ASSERT_EQ(result, Result::OK)

#define EXPECT_OK(result) EXPECT_EQ(result, Result::OK)
@@ -57,8 +57,7 @@ constexpr uint64_t kNonExistentAppId = 0x476f6f6754555555; 
// Helper that does explicit conversion of an enum class to its underlying/base

// type. Useful for stream output of enum values.

template <typename EnumType>

constexpr typename std::underlying_type<EnumType>::type asBaseType(

    EnumType value) {

constexpr typename std::underlying_type<EnumType>::type asBaseType(EnumType value) {

    return static_cast<typename std::underlying_type<EnumType>::type>(value);

}
@@ -125,10 +124,9 @@ class ContexthubCallbackBase : public IContexthubCallback { 
        return Void();

    }



  virtual Return<void> handleTxnResult(

      uint32_t txnId, TransactionResult result) override {

    ALOGD("Got transaction result callback for txnId %" PRIu32 " with result %"

          PRId32, txnId, result);

    virtual Return<void> handleTxnResult(uint32_t txnId, TransactionResult result) override {

        ALOGD("Got transaction result callback for txnId %" PRIu32 " with result %" PRId32, txnId,

              result);

        return Void();

    }
@@ -137,15 +135,15 @@ class ContexthubCallbackBase : public IContexthubCallback { 
        return Void();

    }



  virtual Return<void> handleAppAbort(uint64_t appId, uint32_t abortCode)

      override {

    ALOGD("Got app abort notification for appId 0x%" PRIx64 " with abort code "

          "0x%" PRIx32, appId, abortCode);

    virtual Return<void> handleAppAbort(uint64_t appId, uint32_t abortCode) override {

        ALOGD("Got app abort notification for appId 0x%" PRIx64

              " with abort code "

              "0x%" PRIx32,

              appId, abortCode);

        return Void();

    }



  virtual Return<void> handleAppsInfo(const hidl_vec<HubAppInfo>& /*appInfo*/)

      override {

    virtual Return<void> handleAppsInfo(const hidl_vec<HubAppInfo>& /*appInfo*/) override {

        ALOGD("Got app info callback");

        return Void();

    }
@@ -155,9 +153,7 @@ class ContexthubCallbackBase : public IContexthubCallback { 
// provided timeout. If the future is invalid or the callback does not come

// within the given time, returns false.

template <class ReturnType>

bool waitForCallback(

    std::future<ReturnType> future,

    ReturnType *result,

bool waitForCallback(std::future<ReturnType> future, ReturnType* result,

                     std::chrono::milliseconds timeout = std::chrono::seconds(5)) {

    auto expiration = std::chrono::system_clock::now() + timeout;
@@ -165,8 +161,7 @@ bool waitForCallback( 
    EXPECT_TRUE(future.valid());

    if (result != nullptr && future.valid()) {

        std::future_status status = future.wait_until(expiration);

    EXPECT_NE(status, std::future_status::timeout)

        << "Timed out waiting for callback";

        EXPECT_NE(status, std::future_status::timeout) << "Timed out waiting for callback";



        if (status == std::future_status::ready) {

            *result = future.get();
@@ -211,8 +206,7 @@ TEST_P(ContexthubHidlTest, TestRegisterNullCallback) { 
// Helper callback that puts the async appInfo callback data into a promise

class QueryAppsCallback : public ContexthubCallbackBase {

  public:

  virtual Return<void> handleAppsInfo(const hidl_vec<HubAppInfo>& appInfo)

      override {

    virtual Return<void> handleAppsInfo(const hidl_vec<HubAppInfo>& appInfo) override {

        ALOGD("Got app info callback with %zu apps", appInfo.size());

        promise.set_value(appInfo);

        return Void();
@@ -243,10 +237,10 @@ TEST_P(ContexthubHidlTest, TestQueryApps) { 
// promise

class TxnResultCallback : public ContexthubCallbackBase {

  public:

  virtual Return<void> handleTxnResult(

      uint32_t txnId, TransactionResult result) override {

    ALOGD("Got transaction result callback for txnId %" PRIu32 " (expecting %"

          PRIu32 ") with result %" PRId32, txnId, expectedTxnId, result);

    virtual Return<void> handleTxnResult(uint32_t txnId, TransactionResult result) override {

        ALOGD("Got transaction result callback for txnId %" PRIu32 " (expecting %" PRIu32

              ") with result %" PRId32,

              txnId, expectedTxnId, result);

        if (txnId == expectedTxnId) {

            promise.set_value(result);

        }
@@ -268,22 +262,19 @@ class ContexthubTxnTest : public ContexthubHidlTest { 
    sp<TxnResultCallback> cb = new TxnResultCallback();

};





// Checks cases where the hub implementation is expected to return an error, but

// that error can be returned either synchronously or in the asynchronous

// transaction callback. Returns an AssertionResult that can be used in

// ASSERT/EXPECT_TRUE. Allows checking the sync result against 1 additional

// allowed error code apart from OK and TRANSACTION_FAILED, which are always

// allowed.

::testing::AssertionResult checkFailureSyncOrAsync(

    Result result, Result allowedSyncResult,

::testing::AssertionResult checkFailureSyncOrAsync(Result result, Result allowedSyncResult,

                                                   std::future<TransactionResult>&& future) {

    if (result == Result::OK) {

        // No error reported synchronously - this is OK, but then we should get an

        // async callback with a failure status

        TransactionResult asyncResult;

    if (!waitForCallback(std::forward<std::future<TransactionResult>>(future),

                         &asyncResult)) {

        if (!waitForCallback(std::forward<std::future<TransactionResult>>(future), &asyncResult)) {

            return ::testing::AssertionFailure()

                   << "Got successful sync result, then failed to receive async cb";

        } else if (asyncResult == TransactionResult::SUCCESS) {
@@ -291,10 +282,9 @@ class ContexthubTxnTest : public ContexthubHidlTest { 
                   << "Got successful sync result, then unexpected successful async "

                      "result";

        }

  } else if (result != allowedSyncResult &&

             result != Result::TRANSACTION_FAILED) {

    return ::testing::AssertionFailure() << "Got sync result "

        << asBaseType(result) << ", expected TRANSACTION_FAILED or "

    } else if (result != allowedSyncResult && result != Result::TRANSACTION_FAILED) {

        return ::testing::AssertionFailure()

               << "Got sync result " << asBaseType(result) << ", expected TRANSACTION_FAILED or "

               << asBaseType(allowedSyncResult);

    }
@@ -310,8 +300,7 @@ TEST_P(ContexthubTxnTest, TestSendMessageToNonExistentNanoApp) { 


    ALOGD("Sending message to non-existent nanoapp");

    Result result = hubApi->sendMessageToHub(getHubId(), msg);

  if (result != Result::OK &&

      result != Result::BAD_PARAMS &&

    if (result != Result::OK && result != Result::BAD_PARAMS &&

        result != Result::TRANSACTION_FAILED) {

        FAIL() << "Got result " << asBaseType(result) << ", expected OK, BAD_PARAMS"

               << ", or TRANSACTION_FAILED";
@@ -330,38 +319,31 @@ TEST_P(ContexthubTxnTest, TestLoadEmptyNanoApp) { 


    ALOGD("Loading empty nanoapp");

    Result result = hubApi->loadNanoApp(getHubId(), emptyApp, cb->expectedTxnId);

  EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS,

                                      cb->promise.get_future()));

    EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future()));

}



TEST_P(ContexthubTxnTest, TestUnloadNonexistentNanoApp) {

    cb->expectedTxnId = 1234;



    ALOGD("Unloading nonexistent nanoapp");

  Result result = hubApi->unloadNanoApp(getHubId(), kNonExistentAppId,

                                        cb->expectedTxnId);

  EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS,

                                      cb->promise.get_future()));

    Result result = hubApi->unloadNanoApp(getHubId(), kNonExistentAppId, cb->expectedTxnId);

    EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future()));

}



TEST_P(ContexthubTxnTest, TestEnableNonexistentNanoApp) {

    cb->expectedTxnId = 2345;



    ALOGD("Enabling nonexistent nanoapp");

  Result result = hubApi->enableNanoApp(getHubId(), kNonExistentAppId,

                                        cb->expectedTxnId);

  EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS,

                                      cb->promise.get_future()));

    Result result = hubApi->enableNanoApp(getHubId(), kNonExistentAppId, cb->expectedTxnId);

    EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future()));

}



TEST_P(ContexthubTxnTest, TestDisableNonexistentNanoApp) {

    cb->expectedTxnId = 3456;



    ALOGD("Disabling nonexistent nanoapp");

  Result result = hubApi->disableNanoApp(getHubId(), kNonExistentAppId,

                                         cb->expectedTxnId);

  EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS,

                                      cb->promise.get_future()));

    Result result = hubApi->disableNanoApp(getHubId(), kNonExistentAppId, cb->expectedTxnId);

    EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future()));

}



// Return the test parameters of a vecter of tuples for all IContexthub services and each of its hub