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

Commit 5f0fc364 authored by Amy Zhang's avatar Amy Zhang Committed by Automerger Merge Worker
Browse files

Merge "Convert VtsHalTvInputV1_0TargetTest to parameterized gtest" into rvc-dev am: 704ada8d 

Change-Id: I372c361dbeb9ac468a47b1a560e1f3fa828ea10f
parents 9c886cd0 704ada8d

tv/input/1.0/vts/functional/Android.bp

+5 −2
Original line number Original line Diff line number Diff line
@@ -19,6 +19,9 @@ cc_test { 
    defaults: ["VtsHalTargetTestDefaults"],

    defaults: ["VtsHalTargetTestDefaults"],

    srcs: ["VtsHalTvInputV1_0TargetTest.cpp"],

    srcs: ["VtsHalTvInputV1_0TargetTest.cpp"],

    static_libs: ["android.hardware.tv.input@1.0"],

    static_libs: ["android.hardware.tv.input@1.0"],

    test_suites: ["general-tests"],

    test_suites: [

        "general-tests",

        "vts-core",

    ],

    require_root: true,

}
 
}

tv/input/1.0/vts/functional/VtsHalTvInputV1_0TargetTest.cpp

+237 −269
Original line number Original line Diff line number Diff line
@@ -17,11 +17,12 @@ 
#define LOG_TAG "tv_input_hidl_hal_test"

#define LOG_TAG "tv_input_hidl_hal_test"

#include <android-base/logging.h>

#include <android-base/logging.h>





#include <android/hardware/tv/input/1.0/types.h>

#include <android/hardware/tv/input/1.0/ITvInput.h>

#include <android/hardware/tv/input/1.0/ITvInput.h>

#include <android/hardware/tv/input/1.0/ITvInputCallback.h>

#include <android/hardware/tv/input/1.0/ITvInputCallback.h>



#include <android/hardware/tv/input/1.0/types.h>

#include <VtsHalHidlTargetTestBase.h>

#include <gtest/gtest.h>

#include <hidl/GtestPrinter.h>

#include <hidl/ServiceManagement.h>

#include <utils/KeyedVector.h>

#include <utils/KeyedVector.h>

#include <mutex>

#include <mutex>

#include <vector>

#include <vector>
@@ -42,28 +43,11 @@ using ::android::sp; 
#define WAIT_FOR_EVENT_TIMEOUT 5

#define WAIT_FOR_EVENT_TIMEOUT 5

#define DEFAULT_ID INT32_MIN

#define DEFAULT_ID INT32_MIN





// Test environment for TvInput HIDL HAL.

class TvInputHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {

 public:

  // get the test environment singleton

  static TvInputHidlEnvironment* Instance() {

    static TvInputHidlEnvironment* instance = new TvInputHidlEnvironment;

    return instance;

  }



  virtual void registerTestServices() override { registerTestService<ITvInput>(); }



 private:

  TvInputHidlEnvironment() {}

};



/* The main test class for TV Input HIDL HAL. */

/* The main test class for TV Input HIDL HAL. */

class TvInputHidlTest : public ::testing::VtsHalHidlTargetTestBase {

class TvInputHidlTest : public testing::TestWithParam<std::string> {

  public:

  public:

    virtual void SetUp() override {

    virtual void SetUp() override {

    tv_input_ = ::testing::VtsHalHidlTargetTestBase::getService<ITvInput>(

        tv_input_ = ITvInput::getService(GetParam());

          TvInputHidlEnvironment::Instance()->getServiceName<ITvInput>());

    ASSERT_NE(tv_input_, nullptr);

        tv_input_callback_ = new TvInputCallback(*this);

        tv_input_callback_ = new TvInputCallback(*this);

        ASSERT_NE(tv_input_callback_, nullptr);

        ASSERT_NE(tv_input_callback_, nullptr);

        tv_input_->setCallback(tv_input_callback_);

        tv_input_->setCallback(tv_input_callback_);
@@ -79,9 +63,7 @@ class TvInputHidlTest : public ::testing::VtsHalHidlTargetTestBase { 
    }

    }





    /* Called when a DEVICE_UNAVAILABLE event is received. */

    /* Called when a DEVICE_UNAVAILABLE event is received. */

  void onDeviceUnavailable(int32_t deviceId) {

    void onDeviceUnavailable(int32_t deviceId) { device_info_.removeItem(deviceId); }

    device_info_.removeItem(deviceId);

  }





    /* Called when a DEVICE_CONFIGURATIONS_CHANGED event is received. */

    /* Called when a DEVICE_CONFIGURATIONS_CHANGED event is received. */

    Result onStreamConfigurationsChanged(int32_t deviceId) {

    Result onStreamConfigurationsChanged(int32_t deviceId) {
@@ -93,8 +75,8 @@ class TvInputHidlTest : public ::testing::VtsHalHidlTargetTestBase { 
        stream_config_.removeItem(deviceId);

        stream_config_.removeItem(deviceId);

        Result result = Result::UNKNOWN;

        Result result = Result::UNKNOWN;

        hidl_vec<TvStreamConfig> list;

        hidl_vec<TvStreamConfig> list;

    tv_input_->getStreamConfigurations(deviceId,

        tv_input_->getStreamConfigurations(

        [&result, &list](Result res, hidl_vec<TvStreamConfig> configs) {

                deviceId, [&result, &list](Result res, hidl_vec<TvStreamConfig> configs) {

                    result = res;

                    result = res;

                    if (res == Result::OK) {

                    if (res == Result::OK) {

                        list = configs;

                        list = configs;
@@ -135,7 +117,8 @@ class TvInputHidlTest : public ::testing::VtsHalHidlTargetTestBase { 
        for (int32_t i = 0; i < size; i++) {

        for (int32_t i = 0; i < size; i++) {

            // Put every element to its target position, if possible.

            // Put every element to its target position, if possible.

            int32_t target_pos = nums[i];

            int32_t target_pos = nums[i];

      while (target_pos >= 0 && target_pos < size && i != target_pos && nums[i] != nums[target_pos]) {

            while (target_pos >= 0 && target_pos < size && i != target_pos &&

                   nums[i] != nums[target_pos]) {

                std::swap(nums[i], nums[target_pos]);

                std::swap(nums[i], nums[target_pos]);

                target_pos = nums[i];

                target_pos = nums[i];

            }

            }
@@ -157,7 +140,7 @@ class TvInputHidlTest : public ::testing::VtsHalHidlTargetTestBase { 
        virtual ~TvInputCallback() = default;

        virtual ~TvInputCallback() = default;





        /*

        /*

      * Notifies the client that an event has occured. For possible event types,

         * Notifies the client that an event has occurred. For possible event types,

         * check TvInputEventType.

         * check TvInputEventType.

         */

         */

        Return<void> notify(const TvInputEvent& event) override {

        Return<void> notify(const TvInputEvent& event) override {
@@ -175,6 +158,7 @@ class TvInputHidlTest : public ::testing::VtsHalHidlTargetTestBase { 
            }

            }

            return Void();

            return Void();

        };

        };



      private:

      private:

        /* The test contains this callback instance. */

        /* The test contains this callback instance. */

        TvInputHidlTest& parent_;

        TvInputHidlTest& parent_;
@@ -202,13 +186,12 @@ class TvInputHidlTest : public ::testing::VtsHalHidlTargetTestBase { 
    std::mutex mutex_;

    std::mutex mutex_;

};

};







/*

/*

 * GetStreamConfigTest:

 * GetStreamConfigTest:

 * Calls updateStreamConfigurations() for each existing device

 * Calls updateStreamConfigurations() for each existing device

 * Checks returned results

 * Checks returned results

 */

 */

TEST_F(TvInputHidlTest, GetStreamConfigTest) {

TEST_P(TvInputHidlTest, GetStreamConfigTest) {

    std::unique_lock<std::mutex> lock(mutex_);

    std::unique_lock<std::mutex> lock(mutex_);

    for (size_t i = 0; i < device_info_.size(); i++) {

    for (size_t i = 0; i < device_info_.size(); i++) {

        int32_t device_id = device_info_.keyAt(i);

        int32_t device_id = device_info_.keyAt(i);
@@ -222,7 +205,7 @@ TEST_F(TvInputHidlTest, GetStreamConfigTest) { 
 * Calls openStream() and then closeStream() for each existing stream

 * Calls openStream() and then closeStream() for each existing stream

 * Checks returned results

 * Checks returned results

 */

 */

TEST_F(TvInputHidlTest, OpenAndCloseStreamTest) {

TEST_P(TvInputHidlTest, OpenAndCloseStreamTest) {

    std::unique_lock<std::mutex> lock(mutex_);

    std::unique_lock<std::mutex> lock(mutex_);

    updateAllStreamConfigurations();

    updateAllStreamConfigurations();

    for (size_t j = 0; j < stream_config_.size(); j++) {

    for (size_t j = 0; j < stream_config_.size(); j++) {
@@ -232,9 +215,7 @@ TEST_F(TvInputHidlTest, OpenAndCloseStreamTest) { 
            Result result = Result::UNKNOWN;

            Result result = Result::UNKNOWN;

            int32_t stream_id = config[i].streamId;

            int32_t stream_id = config[i].streamId;

            tv_input_->openStream(device_id, stream_id,

            tv_input_->openStream(device_id, stream_id,

          [&result](Result res, const native_handle_t*) {

                                  [&result](Result res, const native_handle_t*) { result = res; });

              result = res;

          });

            EXPECT_EQ(Result::OK, result);

            EXPECT_EQ(Result::OK, result);





            result = Result::UNKNOWN;

            result = Result::UNKNOWN;
@@ -251,7 +232,7 @@ TEST_F(TvInputHidlTest, OpenAndCloseStreamTest) { 
 * Checks returned results

 * Checks returned results

 * The results should be Result::INVALID_ARGUMENTS

 * The results should be Result::INVALID_ARGUMENTS

 */

 */

TEST_F(TvInputHidlTest, InvalidDeviceIdTest) {

TEST_P(TvInputHidlTest, InvalidDeviceIdTest) {

    std::unique_lock<std::mutex> lock(mutex_);

    std::unique_lock<std::mutex> lock(mutex_);





    std::vector<int32_t> device_ids;

    std::vector<int32_t> device_ids;
@@ -265,9 +246,7 @@ TEST_F(TvInputHidlTest, InvalidDeviceIdTest) { 
    Result result = Result::UNKNOWN;

    Result result = Result::UNKNOWN;

    int32_t stream_id = 0;

    int32_t stream_id = 0;

    tv_input_->openStream(id, stream_id,

    tv_input_->openStream(id, stream_id,

      [&result](Result res, const native_handle_t*) {

                          [&result](Result res, const native_handle_t*) { result = res; });

          result = res;

      });

    EXPECT_EQ(Result::INVALID_ARGUMENTS, result);

    EXPECT_EQ(Result::INVALID_ARGUMENTS, result);





    result = Result::UNKNOWN;

    result = Result::UNKNOWN;
@@ -281,7 +260,7 @@ TEST_F(TvInputHidlTest, InvalidDeviceIdTest) { 
 * Checks returned results

 * Checks returned results

 * The results should be Result::INVALID_ARGUMENTS

 * The results should be Result::INVALID_ARGUMENTS

 */

 */

TEST_F(TvInputHidlTest, InvalidStreamIdTest) {

TEST_P(TvInputHidlTest, InvalidStreamIdTest) {

    std::unique_lock<std::mutex> lock(mutex_);

    std::unique_lock<std::mutex> lock(mutex_);

    if (device_info_.isEmpty()) {

    if (device_info_.isEmpty()) {

        return;

        return;
@@ -302,9 +281,7 @@ TEST_F(TvInputHidlTest, InvalidStreamIdTest) { 




    Result result = Result::UNKNOWN;

    Result result = Result::UNKNOWN;

    tv_input_->openStream(device_id, id,

    tv_input_->openStream(device_id, id,

      [&result](Result res, const native_handle_t*) {

                          [&result](Result res, const native_handle_t*) { result = res; });

          result = res;

      });

    EXPECT_EQ(Result::INVALID_ARGUMENTS, result);

    EXPECT_EQ(Result::INVALID_ARGUMENTS, result);





    result = Result::UNKNOWN;

    result = Result::UNKNOWN;
@@ -318,7 +295,7 @@ TEST_F(TvInputHidlTest, InvalidStreamIdTest) { 
 * Checks returned results

 * Checks returned results

 * The result of the second call should be Result::INVALID_STATE

 * The result of the second call should be Result::INVALID_STATE

 */

 */

TEST_F(TvInputHidlTest, OpenAnOpenedStreamsTest) {

TEST_P(TvInputHidlTest, OpenAnOpenedStreamsTest) {

    std::unique_lock<std::mutex> lock(mutex_);

    std::unique_lock<std::mutex> lock(mutex_);

    updateAllStreamConfigurations();

    updateAllStreamConfigurations();

    std::vector<size_t> indices = getConfigIndices();

    std::vector<size_t> indices = getConfigIndices();
@@ -330,15 +307,11 @@ TEST_F(TvInputHidlTest, OpenAnOpenedStreamsTest) { 




    Result result = Result::UNKNOWN;

    Result result = Result::UNKNOWN;

    tv_input_->openStream(device_id, stream_id,

    tv_input_->openStream(device_id, stream_id,

      [&result](Result res, const native_handle_t*) {

                          [&result](Result res, const native_handle_t*) { result = res; });

          result = res;

      });

    EXPECT_EQ(Result::OK, result);

    EXPECT_EQ(Result::OK, result);





    tv_input_->openStream(device_id, stream_id,

    tv_input_->openStream(device_id, stream_id,

      [&result](Result res, const native_handle_t*) {

                          [&result](Result res, const native_handle_t*) { result = res; });

          result = res;

      });

    EXPECT_EQ(Result::INVALID_STATE, result);

    EXPECT_EQ(Result::INVALID_STATE, result);

}

}
@@ -348,7 +321,7 @@ TEST_F(TvInputHidlTest, OpenAnOpenedStreamsTest) { 
 * Checks the returned result

 * Checks the returned result

 * The result should be Result::INVALID_STATE

 * The result should be Result::INVALID_STATE

 */

 */

TEST_F(TvInputHidlTest, CloseStreamBeforeOpenTest) {

TEST_P(TvInputHidlTest, CloseStreamBeforeOpenTest) {

    std::unique_lock<std::mutex> lock(mutex_);

    std::unique_lock<std::mutex> lock(mutex_);

    updateAllStreamConfigurations();

    updateAllStreamConfigurations();

    std::vector<size_t> indices = getConfigIndices();

    std::vector<size_t> indices = getConfigIndices();
@@ -360,12 +333,7 @@ TEST_F(TvInputHidlTest, CloseStreamBeforeOpenTest) { 
    EXPECT_EQ(Result::INVALID_STATE, tv_input_->closeStream(device_id, stream_id));

    EXPECT_EQ(Result::INVALID_STATE, tv_input_->closeStream(device_id, stream_id));

}

}





int main(int argc, char **argv) {

INSTANTIATE_TEST_SUITE_P(

  ::testing::AddGlobalTestEnvironment(TvInputHidlEnvironment::Instance());

        PerInstance, TvInputHidlTest,

  ::testing::InitGoogleTest(&argc, argv);

        testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITvInput::descriptor)),

  TvInputHidlEnvironment::Instance()->init(&argc, argv);

        android::hardware::PrintInstanceNameToString);
 
  int status = RUN_ALL_TESTS();

  ALOGI("Test result = %d", status);

  return status;

}