tv/input/1.0/vts/functional/VtsHalTvInputV1_0TargetTest.cpp - platform/hardware/interfaces - Git at Google

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "tv_input_hidl_hal_test"
 #include <android-base/logging.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/types.h>
 #include <gtest/gtest.h>
 #include <hidl/GtestPrinter.h>
 #include <hidl/ServiceManagement.h>
 #include <utils/KeyedVector.h>
 #include <mutex>
 #include <vector>

 using ::android::hardware::tv::input::V1_0::ITvInput;
 using ::android::hardware::tv::input::V1_0::ITvInputCallback;
 using ::android::hardware::tv::input::V1_0::Result;
 using ::android::hardware::tv::input::V1_0::TvInputType;
 using ::android::hardware::tv::input::V1_0::TvInputDeviceInfo;
 using ::android::hardware::tv::input::V1_0::TvInputEventType;
 using ::android::hardware::tv::input::V1_0::TvInputEvent;
 using ::android::hardware::tv::input::V1_0::TvStreamConfig;
 using ::android::hardware::Return;
 using ::android::hardware::Void;
 using ::android::hardware::hidl_vec;
 using ::android::sp;

 #define WAIT_FOR_EVENT_TIMEOUT 5
 #define DEFAULT_ID INT32_MIN

 /* The main test class for TV Input HIDL HAL. */
 class TvInputHidlTest : public testing::TestWithParam<std::string> {
   public:
     virtual void SetUp() override {
         tv_input_ = ITvInput::getService(GetParam());
         tv_input_callback_ = new TvInputCallback(*this);
         ASSERT_NE(tv_input_callback_, nullptr);
         tv_input_->setCallback(tv_input_callback_);
         // All events received within the timeout should be handled.
         sleep(WAIT_FOR_EVENT_TIMEOUT);
     }

     virtual void TearDown() override {}

     /* Called when a DEVICE_AVAILABLE event is received. */
     void onDeviceAvailable(const TvInputDeviceInfo& deviceInfo) {
         device_info_.add(deviceInfo.deviceId, deviceInfo);
     }

     /* Called when a DEVICE_UNAVAILABLE event is received. */
     void onDeviceUnavailable(int32_t deviceId) { device_info_.removeItem(deviceId); }

     /* Called when a DEVICE_CONFIGURATIONS_CHANGED event is received. */
     Result onStreamConfigurationsChanged(int32_t deviceId) {
         return updateStreamConfigurations(deviceId);
     }

     /* Gets and updates the stream configurations for a device. */
     Result updateStreamConfigurations(int32_t deviceId) {
         stream_config_.removeItem(deviceId);
         Result result = Result::UNKNOWN;
         hidl_vec<TvStreamConfig> list;
         tv_input_->getStreamConfigurations(
                 deviceId, [&result, &list](Result res, hidl_vec<TvStreamConfig> configs) {
                     result = res;
                     if (res == Result::OK) {
                         list = configs;
                     }
                 });
         if (result == Result::OK) {
             stream_config_.add(deviceId, list);
         }
         return result;
     }

     /* Gets and updates the stream configurations for all existing devices. */
     void updateAllStreamConfigurations() {
         for (size_t i = 0; i < device_info_.size(); i++) {
             int32_t device_id = device_info_.keyAt(i);
             updateStreamConfigurations(device_id);
         }
     }

     /* Returns a list of indices of stream_config_ whose corresponding values are not empty. */
     std::vector<size_t> getConfigIndices() {
         std::vector<size_t> indices;
         for (size_t i = 0; i < stream_config_.size(); i++) {
             if (stream_config_.valueAt(i).size() != 0) {
                 indices.push_back(i);
             }
         }
         return indices;
     }

     /*
      * Returns DEFAULT_ID if there is no missing integer in the range [0, the size of nums).
      * Otherwise, returns the smallest missing non-negative integer.
      */
     int32_t getNumNotIn(std::vector<int32_t>& nums) {
         int32_t result = DEFAULT_ID;
         int32_t size = static_cast<int32_t>(nums.size());
         for (int32_t i = 0; i < size; i++) {
             // Put every element to its target position, if possible.
             int32_t target_pos = nums[i];
             while (target_pos >= 0 && target_pos < size && i != target_pos &&
                    nums[i] != nums[target_pos]) {
                 std::swap(nums[i], nums[target_pos]);
                 target_pos = nums[i];
             }
         }

         for (int32_t i = 0; i < size; i++) {
             if (nums[i] != i) {
                 return i;
             }
         }
         return result;
     }

     /* A simple test implementation of TvInputCallback for TV Input Events. */
     class TvInputCallback : public ITvInputCallback {
       public:
         TvInputCallback(TvInputHidlTest& parent) : parent_(parent){};

         virtual ~TvInputCallback() = default;

         /*
          * Notifies the client that an event has occurred. For possible event types,
          * check TvInputEventType.
          */
         Return<void> notify(const TvInputEvent& event) override {
             std::unique_lock<std::mutex> lock(parent_.mutex_);
             switch (event.type) {
                 case TvInputEventType::DEVICE_AVAILABLE:
                     parent_.onDeviceAvailable(event.deviceInfo);
                     break;
                 case TvInputEventType::DEVICE_UNAVAILABLE:
                     parent_.onDeviceUnavailable(event.deviceInfo.deviceId);
                     break;
                 case TvInputEventType::STREAM_CONFIGURATIONS_CHANGED:
                     parent_.onStreamConfigurationsChanged(event.deviceInfo.deviceId);
                     break;
             }
             return Void();
         };

       private:
         /* The test contains this callback instance. */
         TvInputHidlTest& parent_;
     };

     /* The TvInput used for the test. */
     sp<ITvInput> tv_input_;

     /* The TvInputCallback used for the test. */
     sp<ITvInputCallback> tv_input_callback_;

     /*
      * A KeyedVector stores device information of every available device.
      * A key is a device ID and the corresponding value is the TvInputDeviceInfo.
      */
     android::KeyedVector<int32_t, TvInputDeviceInfo> device_info_;

     /*
      * A KeyedVector stores a list of stream configurations of every available device.
      * A key is a device ID and the corresponding value is the stream configuration list.
      */
     android::KeyedVector<int32_t, hidl_vec<TvStreamConfig>> stream_config_;

     /* The mutex controls the access of shared data. */
     std::mutex mutex_;
 };

 /*
  * GetStreamConfigTest:
  * Calls updateStreamConfigurations() for each existing device
  * Checks returned results
  */
 TEST_P(TvInputHidlTest, GetStreamConfigTest) {
     std::unique_lock<std::mutex> lock(mutex_);
     for (size_t i = 0; i < device_info_.size(); i++) {
         int32_t device_id = device_info_.keyAt(i);
         Result result = updateStreamConfigurations(device_id);
         EXPECT_EQ(Result::OK, result);
     }
 }

 /*
  * OpenAndCloseStreamTest:
  * Calls openStream() and then closeStream() for each existing stream
  * Checks returned results
  */
 TEST_P(TvInputHidlTest, OpenAndCloseStreamTest) {
     std::unique_lock<std::mutex> lock(mutex_);
     updateAllStreamConfigurations();
     for (size_t j = 0; j < stream_config_.size(); j++) {
         int32_t device_id = stream_config_.keyAt(j);
         hidl_vec<TvStreamConfig> config = stream_config_.valueAt(j);
         for (size_t i = 0; i < config.size(); i++) {
             Result result = Result::UNKNOWN;
             int32_t stream_id = config[i].streamId;
             tv_input_->openStream(device_id, stream_id,
                                   [&result](Result res, const native_handle_t*) { result = res; });
             EXPECT_EQ(Result::OK, result);

             result = Result::UNKNOWN;
             result = tv_input_->closeStream(device_id, stream_id);
             EXPECT_EQ(Result::OK, result);
         }
     }
 }

 /*
  * InvalidDeviceIdTest:
  * Calls updateStreamConfigurations(), openStream(), and closeStream()
  * for a non-existing device
  * Checks returned results
  * The results should be Result::INVALID_ARGUMENTS
  */
 TEST_P(TvInputHidlTest, InvalidDeviceIdTest) {
     std::unique_lock<std::mutex> lock(mutex_);

     std::vector<int32_t> device_ids;
     for (size_t i = 0; i < device_info_.size(); i++) {
         device_ids.push_back(device_info_.keyAt(i));
     }
     // Get a non-existing device ID.
     int32_t id = getNumNotIn(device_ids);
     EXPECT_EQ(Result::INVALID_ARGUMENTS, updateStreamConfigurations(id));

     Result result = Result::UNKNOWN;
     int32_t stream_id = 0;
     tv_input_->openStream(id, stream_id,
                           [&result](Result res, const native_handle_t*) { result = res; });
     EXPECT_EQ(Result::INVALID_ARGUMENTS, result);

     result = Result::UNKNOWN;
     result = tv_input_->closeStream(id, stream_id);
     EXPECT_EQ(Result::INVALID_ARGUMENTS, result);
 }

 /*
  * InvalidStreamIdTest:
  * Calls openStream(), and closeStream() for a non-existing stream
  * Checks returned results
  * The results should be Result::INVALID_ARGUMENTS
  */
 TEST_P(TvInputHidlTest, InvalidStreamIdTest) {
     std::unique_lock<std::mutex> lock(mutex_);
     if (device_info_.isEmpty()) {
         return;
     }
     updateAllStreamConfigurations();

     int32_t device_id = device_info_.keyAt(0);
     // Get a non-existing stream ID.
     int32_t id = DEFAULT_ID;
     if (stream_config_.indexOfKey(device_id) >= 0) {
         std::vector<int32_t> stream_ids;
         hidl_vec<TvStreamConfig> config = stream_config_.valueFor(device_id);
         for (size_t i = 0; i < config.size(); i++) {
             stream_ids.push_back(config[i].streamId);
         }
         id = getNumNotIn(stream_ids);
     }

     Result result = Result::UNKNOWN;
     tv_input_->openStream(device_id, id,
                           [&result](Result res, const native_handle_t*) { result = res; });
     EXPECT_EQ(Result::INVALID_ARGUMENTS, result);

     result = Result::UNKNOWN;
     result = tv_input_->closeStream(device_id, id);
     EXPECT_EQ(Result::INVALID_ARGUMENTS, result);
 }

 /*
  * OpenAnOpenedStreamsTest:
  * Calls openStream() twice for a stream (if any)
  * Checks returned results
  * The result of the second call should be Result::INVALID_STATE
  */
 TEST_P(TvInputHidlTest, OpenAnOpenedStreamsTest) {
     std::unique_lock<std::mutex> lock(mutex_);
     updateAllStreamConfigurations();
     std::vector<size_t> indices = getConfigIndices();
     if (indices.empty()) {
         return;
     }
     int32_t device_id = stream_config_.keyAt(indices[0]);
     int32_t stream_id = stream_config_.valueAt(indices[0])[0].streamId;

     Result result = Result::UNKNOWN;
     tv_input_->openStream(device_id, stream_id,
                           [&result](Result res, const native_handle_t*) { result = res; });
     EXPECT_EQ(Result::OK, result);

     tv_input_->openStream(device_id, stream_id,
                           [&result](Result res, const native_handle_t*) { result = res; });
     EXPECT_EQ(Result::INVALID_STATE, result);

     // close stream as subsequent tests assume no open streams
     EXPECT_EQ(Result::OK, tv_input_->closeStream(device_id, stream_id));
 }

 /*
  * CloseStreamBeforeOpenTest:
  * Calls closeStream() without calling openStream() for a stream (if any)
  * Checks the returned result
  * The result should be Result::INVALID_STATE
  */
 TEST_P(TvInputHidlTest, CloseStreamBeforeOpenTest) {
     std::unique_lock<std::mutex> lock(mutex_);
     updateAllStreamConfigurations();
     std::vector<size_t> indices = getConfigIndices();
     if (indices.empty()) {
         return;
     }
     int32_t device_id = stream_config_.keyAt(indices[0]);
     int32_t stream_id = stream_config_.valueAt(indices[0])[0].streamId;
     EXPECT_EQ(Result::INVALID_STATE, tv_input_->closeStream(device_id, stream_id));
 }

 INSTANTIATE_TEST_SUITE_P(
         PerInstance, TvInputHidlTest,
         testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITvInput::descriptor)),
         android::hardware::PrintInstanceNameToString);

 // TODO remove from the allow list once the cf tv target is enabled for testing
 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(TvInputHidlTest);
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "tv_input_hidl_hal_test"
	#include <android-base/logging.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/types.h>
	#include <gtest/gtest.h>
	#include <hidl/GtestPrinter.h>
	#include <hidl/ServiceManagement.h>
	#include <utils/KeyedVector.h>
	#include <mutex>
	#include <vector>

	using ::android::hardware::tv::input::V1_0::ITvInput;
	using ::android::hardware::tv::input::V1_0::ITvInputCallback;
	using ::android::hardware::tv::input::V1_0::Result;
	using ::android::hardware::tv::input::V1_0::TvInputType;
	using ::android::hardware::tv::input::V1_0::TvInputDeviceInfo;
	using ::android::hardware::tv::input::V1_0::TvInputEventType;
	using ::android::hardware::tv::input::V1_0::TvInputEvent;
	using ::android::hardware::tv::input::V1_0::TvStreamConfig;
	using ::android::hardware::Return;
	using ::android::hardware::Void;
	using ::android::hardware::hidl_vec;
	using ::android::sp;

	#define WAIT_FOR_EVENT_TIMEOUT 5
	#define DEFAULT_ID INT32_MIN

	/* The main test class for TV Input HIDL HAL. */
	class TvInputHidlTest : public testing::TestWithParam<std::string> {
	public:
	virtual void SetUp() override {
	tv_input_ = ITvInput::getService(GetParam());
	tv_input_callback_ = new TvInputCallback(*this);
	ASSERT_NE(tv_input_callback_, nullptr);
	tv_input_->setCallback(tv_input_callback_);
	// All events received within the timeout should be handled.
	sleep(WAIT_FOR_EVENT_TIMEOUT);
	}

	virtual void TearDown() override {}

	/* Called when a DEVICE_AVAILABLE event is received. */
	void onDeviceAvailable(const TvInputDeviceInfo& deviceInfo) {
	device_info_.add(deviceInfo.deviceId, deviceInfo);
	}

	/* Called when a DEVICE_UNAVAILABLE event is received. */
	void onDeviceUnavailable(int32_t deviceId) { device_info_.removeItem(deviceId); }

	/* Called when a DEVICE_CONFIGURATIONS_CHANGED event is received. */
	Result onStreamConfigurationsChanged(int32_t deviceId) {
	return updateStreamConfigurations(deviceId);
	}

	/* Gets and updates the stream configurations for a device. */
	Result updateStreamConfigurations(int32_t deviceId) {
	stream_config_.removeItem(deviceId);
	Result result = Result::UNKNOWN;
	hidl_vec<TvStreamConfig> list;
	tv_input_->getStreamConfigurations(
	deviceId, [&result, &list](Result res, hidl_vec<TvStreamConfig> configs) {
	result = res;
	if (res == Result::OK) {
	list = configs;
	}
	});
	if (result == Result::OK) {
	stream_config_.add(deviceId, list);
	}
	return result;
	}

	/* Gets and updates the stream configurations for all existing devices. */
	void updateAllStreamConfigurations() {
	for (size_t i = 0; i < device_info_.size(); i++) {
	int32_t device_id = device_info_.keyAt(i);
	updateStreamConfigurations(device_id);
	}
	}

	/* Returns a list of indices of stream_config_ whose corresponding values are not empty. */
	std::vector<size_t> getConfigIndices() {
	std::vector<size_t> indices;
	for (size_t i = 0; i < stream_config_.size(); i++) {
	if (stream_config_.valueAt(i).size() != 0) {
	indices.push_back(i);
	}
	}
	return indices;
	}

	/*
	* Returns DEFAULT_ID if there is no missing integer in the range [0, the size of nums).
	* Otherwise, returns the smallest missing non-negative integer.
	*/
	int32_t getNumNotIn(std::vector<int32_t>& nums) {
	int32_t result = DEFAULT_ID;
	int32_t size = static_cast<int32_t>(nums.size());
	for (int32_t i = 0; i < size; i++) {
	// Put every element to its target position, if possible.
	int32_t target_pos = nums[i];
	while (target_pos >= 0 && target_pos < size && i != target_pos &&
	nums[i] != nums[target_pos]) {
	std::swap(nums[i], nums[target_pos]);
	target_pos = nums[i];
	}
	}

	for (int32_t i = 0; i < size; i++) {
	if (nums[i] != i) {
	return i;
	}
	}
	return result;
	}

	/* A simple test implementation of TvInputCallback for TV Input Events. */
	class TvInputCallback : public ITvInputCallback {
	public:
	TvInputCallback(TvInputHidlTest& parent) : parent_(parent){};

	virtual ~TvInputCallback() = default;

	/*
	* Notifies the client that an event has occurred. For possible event types,
	* check TvInputEventType.
	*/
	Return<void> notify(const TvInputEvent& event) override {
	std::unique_lock<std::mutex> lock(parent_.mutex_);
	switch (event.type) {
	case TvInputEventType::DEVICE_AVAILABLE:
	parent_.onDeviceAvailable(event.deviceInfo);
	break;
	case TvInputEventType::DEVICE_UNAVAILABLE:
	parent_.onDeviceUnavailable(event.deviceInfo.deviceId);
	break;
	case TvInputEventType::STREAM_CONFIGURATIONS_CHANGED:
	parent_.onStreamConfigurationsChanged(event.deviceInfo.deviceId);
	break;
	}
	return Void();
	};

	private:
	/* The test contains this callback instance. */
	TvInputHidlTest& parent_;
	};

	/* The TvInput used for the test. */
	sp<ITvInput> tv_input_;

	/* The TvInputCallback used for the test. */
	sp<ITvInputCallback> tv_input_callback_;

	/*
	* A KeyedVector stores device information of every available device.
	* A key is a device ID and the corresponding value is the TvInputDeviceInfo.
	*/
	android::KeyedVector<int32_t, TvInputDeviceInfo> device_info_;

	/*
	* A KeyedVector stores a list of stream configurations of every available device.
	* A key is a device ID and the corresponding value is the stream configuration list.
	*/
	android::KeyedVector<int32_t, hidl_vec<TvStreamConfig>> stream_config_;

	/* The mutex controls the access of shared data. */
	std::mutex mutex_;
	};

	/*
	* GetStreamConfigTest:
	* Calls updateStreamConfigurations() for each existing device
	* Checks returned results
	*/
	TEST_P(TvInputHidlTest, GetStreamConfigTest) {
	std::unique_lock<std::mutex> lock(mutex_);
	for (size_t i = 0; i < device_info_.size(); i++) {
	int32_t device_id = device_info_.keyAt(i);
	Result result = updateStreamConfigurations(device_id);
	EXPECT_EQ(Result::OK, result);
	}
	}

	/*
	* OpenAndCloseStreamTest:
	* Calls openStream() and then closeStream() for each existing stream
	* Checks returned results
	*/
	TEST_P(TvInputHidlTest, OpenAndCloseStreamTest) {
	std::unique_lock<std::mutex> lock(mutex_);
	updateAllStreamConfigurations();
	for (size_t j = 0; j < stream_config_.size(); j++) {
	int32_t device_id = stream_config_.keyAt(j);
	hidl_vec<TvStreamConfig> config = stream_config_.valueAt(j);
	for (size_t i = 0; i < config.size(); i++) {
	Result result = Result::UNKNOWN;
	int32_t stream_id = config[i].streamId;
	tv_input_->openStream(device_id, stream_id,
	[&result](Result res, const native_handle_t*) { result = res; });
	EXPECT_EQ(Result::OK, result);

	result = Result::UNKNOWN;
	result = tv_input_->closeStream(device_id, stream_id);
	EXPECT_EQ(Result::OK, result);
	}
	}
	}

	/*
	* InvalidDeviceIdTest:
	* Calls updateStreamConfigurations(), openStream(), and closeStream()
	* for a non-existing device
	* Checks returned results
	* The results should be Result::INVALID_ARGUMENTS
	*/
	TEST_P(TvInputHidlTest, InvalidDeviceIdTest) {
	std::unique_lock<std::mutex> lock(mutex_);

	std::vector<int32_t> device_ids;
	for (size_t i = 0; i < device_info_.size(); i++) {
	device_ids.push_back(device_info_.keyAt(i));
	}
	// Get a non-existing device ID.
	int32_t id = getNumNotIn(device_ids);
	EXPECT_EQ(Result::INVALID_ARGUMENTS, updateStreamConfigurations(id));

	Result result = Result::UNKNOWN;
	int32_t stream_id = 0;
	tv_input_->openStream(id, stream_id,
	[&result](Result res, const native_handle_t*) { result = res; });
	EXPECT_EQ(Result::INVALID_ARGUMENTS, result);

	result = Result::UNKNOWN;
	result = tv_input_->closeStream(id, stream_id);
	EXPECT_EQ(Result::INVALID_ARGUMENTS, result);
	}

	/*
	* InvalidStreamIdTest:
	* Calls openStream(), and closeStream() for a non-existing stream
	* Checks returned results
	* The results should be Result::INVALID_ARGUMENTS
	*/
	TEST_P(TvInputHidlTest, InvalidStreamIdTest) {
	std::unique_lock<std::mutex> lock(mutex_);
	if (device_info_.isEmpty()) {
	return;
	}
	updateAllStreamConfigurations();

	int32_t device_id = device_info_.keyAt(0);
	// Get a non-existing stream ID.
	int32_t id = DEFAULT_ID;
	if (stream_config_.indexOfKey(device_id) >= 0) {
	std::vector<int32_t> stream_ids;
	hidl_vec<TvStreamConfig> config = stream_config_.valueFor(device_id);
	for (size_t i = 0; i < config.size(); i++) {
	stream_ids.push_back(config[i].streamId);
	}
	id = getNumNotIn(stream_ids);
	}

	Result result = Result::UNKNOWN;
	tv_input_->openStream(device_id, id,
	[&result](Result res, const native_handle_t*) { result = res; });
	EXPECT_EQ(Result::INVALID_ARGUMENTS, result);

	result = Result::UNKNOWN;
	result = tv_input_->closeStream(device_id, id);
	EXPECT_EQ(Result::INVALID_ARGUMENTS, result);
	}

	/*
	* OpenAnOpenedStreamsTest:
	* Calls openStream() twice for a stream (if any)
	* Checks returned results
	* The result of the second call should be Result::INVALID_STATE
	*/
	TEST_P(TvInputHidlTest, OpenAnOpenedStreamsTest) {
	std::unique_lock<std::mutex> lock(mutex_);
	updateAllStreamConfigurations();
	std::vector<size_t> indices = getConfigIndices();
	if (indices.empty()) {
	return;
	}
	int32_t device_id = stream_config_.keyAt(indices[0]);
	int32_t stream_id = stream_config_.valueAt(indices[0])[0].streamId;

	Result result = Result::UNKNOWN;
	tv_input_->openStream(device_id, stream_id,
	[&result](Result res, const native_handle_t*) { result = res; });
	EXPECT_EQ(Result::OK, result);

	tv_input_->openStream(device_id, stream_id,
	[&result](Result res, const native_handle_t*) { result = res; });
	EXPECT_EQ(Result::INVALID_STATE, result);

	// close stream as subsequent tests assume no open streams
	EXPECT_EQ(Result::OK, tv_input_->closeStream(device_id, stream_id));
	}

	/*
	* CloseStreamBeforeOpenTest:
	* Calls closeStream() without calling openStream() for a stream (if any)
	* Checks the returned result
	* The result should be Result::INVALID_STATE
	*/
	TEST_P(TvInputHidlTest, CloseStreamBeforeOpenTest) {
	std::unique_lock<std::mutex> lock(mutex_);
	updateAllStreamConfigurations();
	std::vector<size_t> indices = getConfigIndices();
	if (indices.empty()) {
	return;
	}
	int32_t device_id = stream_config_.keyAt(indices[0]);
	int32_t stream_id = stream_config_.valueAt(indices[0])[0].streamId;
	EXPECT_EQ(Result::INVALID_STATE, tv_input_->closeStream(device_id, stream_id));
	}

	INSTANTIATE_TEST_SUITE_P(
	PerInstance, TvInputHidlTest,
	testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITvInput::descriptor)),
	android::hardware::PrintInstanceNameToString);

	// TODO remove from the allow list once the cf tv target is enabled for testing
	GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(TvInputHidlTest);