86f31e76b0
If SAT/DT is not supported, should be marked as ignored but they are marked as failures. If no support for SAT/DT the implementation returns INVALID_ARGUMENTS and test is calling the printSkipped function. Instead of calling printSkipped, if GTEST_SKIP() called unsupported TC results are parsed properly and test cases will move to ignored category Bug: 191229970 Test: VtsHalBroadcastradioV1_0TargetTest Signed-off-by: V,Anilkumar <anilkumar.v@intel.com> Change-Id: I4ed7828757a6cc8b83bae989e11289da1a3e814f
736 lines
24 KiB
C++
736 lines
24 KiB
C++
/*
|
|
* Copyright (C) 2016 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 "BroadcastRadioHidlHalTest"
|
|
#include <android-base/logging.h>
|
|
#include <cutils/native_handle.h>
|
|
#include <cutils/properties.h>
|
|
#include <gtest/gtest.h>
|
|
#include <hidl/GtestPrinter.h>
|
|
#include <hidl/HidlTransportSupport.h>
|
|
#include <hidl/ServiceManagement.h>
|
|
#include <utils/threads.h>
|
|
|
|
#include <android/hardware/broadcastradio/1.0/IBroadcastRadio.h>
|
|
#include <android/hardware/broadcastradio/1.0/IBroadcastRadioFactory.h>
|
|
#include <android/hardware/broadcastradio/1.0/ITuner.h>
|
|
#include <android/hardware/broadcastradio/1.0/ITunerCallback.h>
|
|
#include <android/hardware/broadcastradio/1.0/types.h>
|
|
#include <broadcastradio-vts-utils/hal-1.x-enum-utils.h>
|
|
|
|
using ::android::Condition;
|
|
using ::android::Mutex;
|
|
using ::android::sp;
|
|
using ::android::hardware::Return;
|
|
using ::android::hardware::Void;
|
|
using ::android::hardware::broadcastradio::V1_0::Band;
|
|
using ::android::hardware::broadcastradio::V1_0::BandConfig;
|
|
using ::android::hardware::broadcastradio::V1_0::Class;
|
|
using ::android::hardware::broadcastradio::V1_0::Direction;
|
|
using ::android::hardware::broadcastradio::V1_0::IBroadcastRadio;
|
|
using ::android::hardware::broadcastradio::V1_0::IBroadcastRadioFactory;
|
|
using ::android::hardware::broadcastradio::V1_0::ITuner;
|
|
using ::android::hardware::broadcastradio::V1_0::ITunerCallback;
|
|
using ::android::hardware::broadcastradio::V1_0::MetaData;
|
|
using ::android::hardware::broadcastradio::V1_0::MetadataKey;
|
|
using ::android::hardware::broadcastradio::V1_0::MetadataType;
|
|
using ::android::hardware::broadcastradio::V1_0::ProgramInfo;
|
|
using ::android::hardware::broadcastradio::V1_0::Properties;
|
|
using ::android::hardware::broadcastradio::V1_0::Result;
|
|
using ::android::hardware::broadcastradio::V1_0::vts::RadioClassFromString;
|
|
|
|
#define RETURN_IF_SKIPPED \
|
|
if (skipped) { \
|
|
GTEST_SKIP() << "This device class is not supported."; \
|
|
}
|
|
|
|
// The main test class for Broadcast Radio HIDL HAL.
|
|
class BroadcastRadioHidlTest
|
|
: public ::testing::TestWithParam<std::tuple<std::string, std::string>> {
|
|
protected:
|
|
virtual void SetUp() override {
|
|
ASSERT_EQ(nullptr, mRadio.get());
|
|
|
|
radioClass = RadioClassFromString(std::get<1>(GetParam()));
|
|
|
|
skipped = false;
|
|
|
|
sp<IBroadcastRadioFactory> factory =
|
|
IBroadcastRadioFactory::getService(std::get<0>(GetParam()));
|
|
ASSERT_NE(nullptr, factory.get());
|
|
|
|
Result connectResult;
|
|
factory->connectModule(radioClass, [&](Result ret, const sp<IBroadcastRadio>& radio) {
|
|
connectResult = ret;
|
|
mRadio = radio;
|
|
onCallback_l();
|
|
});
|
|
EXPECT_EQ(true, waitForCallback(kConnectCallbacktimeoutNs));
|
|
mCallbackCalled = false;
|
|
|
|
if (connectResult == Result::INVALID_ARGUMENTS) {
|
|
skipped = true;
|
|
return;
|
|
}
|
|
ASSERT_EQ(connectResult, Result::OK);
|
|
|
|
mTunerCallback = new MyCallback(this);
|
|
ASSERT_NE(nullptr, mRadio.get());
|
|
ASSERT_NE(nullptr, mTunerCallback.get());
|
|
}
|
|
|
|
virtual void TearDown() override {
|
|
mTuner.clear();
|
|
mRadio.clear();
|
|
}
|
|
|
|
class MyCallback : public ITunerCallback {
|
|
public:
|
|
|
|
// ITunerCallback methods (see doc in ITunerCallback.hal)
|
|
virtual Return<void> hardwareFailure() {
|
|
ALOGI("%s", __FUNCTION__);
|
|
mParentTest->onHwFailureCallback();
|
|
return Void();
|
|
}
|
|
|
|
virtual Return<void> configChange(Result result, const BandConfig& config) {
|
|
ALOGI("%s result %d", __FUNCTION__, result);
|
|
mParentTest->onConfigChangeCallback(result, config);
|
|
return Void();
|
|
}
|
|
|
|
virtual Return<void> tuneComplete(Result result, const ProgramInfo& info) {
|
|
ALOGI("%s result %d", __FUNCTION__, result);
|
|
mParentTest->onTuneCompleteCallback(result, info);
|
|
return Void();
|
|
}
|
|
|
|
virtual Return<void> afSwitch(const ProgramInfo& info __unused) {
|
|
return Void();
|
|
}
|
|
|
|
virtual Return<void> antennaStateChange(bool connected) {
|
|
ALOGI("%s connected %d", __FUNCTION__, connected);
|
|
return Void();
|
|
}
|
|
|
|
virtual Return<void> trafficAnnouncement(bool active) {
|
|
ALOGI("%s active %d", __FUNCTION__, active);
|
|
return Void();
|
|
}
|
|
|
|
virtual Return<void> emergencyAnnouncement(bool active) {
|
|
ALOGI("%s active %d", __FUNCTION__, active);
|
|
return Void();
|
|
}
|
|
|
|
virtual Return<void> newMetadata(uint32_t channel __unused, uint32_t subChannel __unused,
|
|
const ::android::hardware::hidl_vec<MetaData>& metadata __unused) {
|
|
ALOGI("%s", __FUNCTION__);
|
|
return Void();
|
|
}
|
|
|
|
MyCallback(BroadcastRadioHidlTest *parentTest) : mParentTest(parentTest) {}
|
|
|
|
private:
|
|
// BroadcastRadioHidlTest instance to which callbacks will be notified.
|
|
BroadcastRadioHidlTest *mParentTest;
|
|
};
|
|
|
|
|
|
/**
|
|
* Method called by MyCallback when a callback with no status or boolean value is received
|
|
*/
|
|
void onCallback() {
|
|
Mutex::Autolock _l(mLock);
|
|
onCallback_l();
|
|
}
|
|
|
|
/**
|
|
* Method called by MyCallback when hardwareFailure() callback is received
|
|
*/
|
|
void onHwFailureCallback() {
|
|
Mutex::Autolock _l(mLock);
|
|
mHwFailure = true;
|
|
onCallback_l();
|
|
}
|
|
|
|
/**
|
|
* Method called by MyCallback when configChange() callback is received.
|
|
*/
|
|
void onConfigChangeCallback(Result result, const BandConfig& config) {
|
|
Mutex::Autolock _l(mLock);
|
|
mResultCallbackData = result;
|
|
mBandConfigCallbackData = config;
|
|
onCallback_l();
|
|
}
|
|
|
|
/**
|
|
* Method called by MyCallback when tuneComplete() callback is received.
|
|
*/
|
|
void onTuneCompleteCallback(Result result, const ProgramInfo& info) {
|
|
Mutex::Autolock _l(mLock);
|
|
mResultCallbackData = result;
|
|
mProgramInfoCallbackData = info;
|
|
onCallback_l();
|
|
}
|
|
|
|
/**
|
|
* Method called by MyCallback when a boolean indication is received
|
|
*/
|
|
void onBoolCallback(bool result) {
|
|
Mutex::Autolock _l(mLock);
|
|
mBoolCallbackData = result;
|
|
onCallback_l();
|
|
}
|
|
|
|
|
|
BroadcastRadioHidlTest()
|
|
: mCallbackCalled(false), mBoolCallbackData(false), mResultCallbackData(Result::OK),
|
|
mHwFailure(false) {}
|
|
|
|
void onCallback_l() {
|
|
if (!mCallbackCalled) {
|
|
mCallbackCalled = true;
|
|
mCallbackCond.broadcast();
|
|
}
|
|
}
|
|
|
|
|
|
bool waitForCallback(nsecs_t reltime = 0) {
|
|
Mutex::Autolock _l(mLock);
|
|
nsecs_t endTime = systemTime() + reltime;
|
|
while (!mCallbackCalled) {
|
|
if (reltime == 0) {
|
|
mCallbackCond.wait(mLock);
|
|
} else {
|
|
nsecs_t now = systemTime();
|
|
if (now > endTime) {
|
|
return false;
|
|
}
|
|
mCallbackCond.waitRelative(mLock, endTime - now);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool getProperties();
|
|
bool openTuner();
|
|
bool checkAntenna();
|
|
|
|
/**
|
|
* Retrieves AM/FM band configuration from module properties.
|
|
*
|
|
* The configuration may not exist: if radio type is other than AM/FM
|
|
* or provided index is out of bounds.
|
|
* In such case, empty configuration is returned.
|
|
*
|
|
* @param idx Band index to retrieve.
|
|
* @return Band configuration reference.
|
|
*/
|
|
const BandConfig& getBand(unsigned idx);
|
|
|
|
static const nsecs_t kConnectCallbacktimeoutNs = seconds_to_nanoseconds(1);
|
|
static const nsecs_t kConfigCallbacktimeoutNs = seconds_to_nanoseconds(10);
|
|
static const nsecs_t kTuneCallbacktimeoutNs = seconds_to_nanoseconds(30);
|
|
|
|
Class radioClass;
|
|
bool skipped;
|
|
sp<IBroadcastRadio> mRadio;
|
|
Properties mHalProperties;
|
|
bool mHalPropertiesInitialized = false;
|
|
sp<ITuner> mTuner;
|
|
sp<MyCallback> mTunerCallback;
|
|
Mutex mLock;
|
|
Condition mCallbackCond;
|
|
bool mCallbackCalled;
|
|
bool mBoolCallbackData;
|
|
Result mResultCallbackData;
|
|
ProgramInfo mProgramInfoCallbackData;
|
|
BandConfig mBandConfigCallbackData;
|
|
bool mHwFailure;
|
|
};
|
|
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace broadcastradio {
|
|
namespace V1_0 {
|
|
|
|
/**
|
|
* Compares two BandConfig objects for testing purposes.
|
|
*/
|
|
static bool operator==(const BandConfig& l, const BandConfig& r) {
|
|
if (l.type != r.type) return false;
|
|
if (l.antennaConnected != r.antennaConnected) return false;
|
|
if (l.lowerLimit != r.lowerLimit) return false;
|
|
if (l.upperLimit != r.upperLimit) return false;
|
|
if (l.spacings != r.spacings) return false;
|
|
if (l.type == Band::AM || l.type == Band::AM_HD) {
|
|
return l.ext.am == r.ext.am;
|
|
} else if (l.type == Band::FM || l.type == Band::FM_HD) {
|
|
return l.ext.fm == r.ext.fm;
|
|
} else {
|
|
// unsupported type
|
|
return false;
|
|
}
|
|
}
|
|
|
|
} // V1_0
|
|
} // broadcastradio
|
|
} // hardware
|
|
} // android
|
|
|
|
bool BroadcastRadioHidlTest::getProperties()
|
|
{
|
|
if (mHalPropertiesInitialized) return true;
|
|
|
|
Result halResult = Result::NOT_INITIALIZED;
|
|
auto hidlReturn = mRadio->getProperties([&](Result result, const Properties& properties) {
|
|
halResult = result;
|
|
if (result == Result::OK) {
|
|
mHalProperties = properties;
|
|
}
|
|
});
|
|
|
|
EXPECT_TRUE(hidlReturn.isOk());
|
|
EXPECT_EQ(Result::OK, halResult);
|
|
EXPECT_EQ(radioClass, mHalProperties.classId);
|
|
EXPECT_GT(mHalProperties.numTuners, 0u);
|
|
if (radioClass == Class::AM_FM) {
|
|
EXPECT_GT(mHalProperties.bands.size(), 0u);
|
|
}
|
|
|
|
if (hidlReturn.isOk() && halResult == Result::OK) {
|
|
mHalPropertiesInitialized = true;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool BroadcastRadioHidlTest::openTuner()
|
|
{
|
|
if (!getProperties()) {
|
|
return false;
|
|
}
|
|
if (mTuner.get() == nullptr) {
|
|
Result halResult = Result::NOT_INITIALIZED;
|
|
auto openCb = [&](Result result, const sp<ITuner>& tuner) {
|
|
halResult = result;
|
|
if (result == Result::OK) {
|
|
mTuner = tuner;
|
|
}
|
|
};
|
|
auto hidlReturn = mRadio->openTuner(getBand(0), true, mTunerCallback, openCb);
|
|
EXPECT_TRUE(hidlReturn.isOk());
|
|
EXPECT_EQ(Result::OK, halResult);
|
|
if (radioClass == Class::AM_FM) {
|
|
EXPECT_EQ(true, waitForCallback(kConfigCallbacktimeoutNs));
|
|
}
|
|
}
|
|
EXPECT_NE(nullptr, mTuner.get());
|
|
return nullptr != mTuner.get();
|
|
}
|
|
|
|
bool BroadcastRadioHidlTest::checkAntenna()
|
|
{
|
|
if (radioClass != Class::AM_FM) return true;
|
|
|
|
BandConfig halConfig;
|
|
Result halResult = Result::NOT_INITIALIZED;
|
|
Return<void> hidlReturn =
|
|
mTuner->getConfiguration([&](Result result, const BandConfig& config) {
|
|
halResult = result;
|
|
if (result == Result::OK) {
|
|
halConfig = config;
|
|
}
|
|
});
|
|
|
|
return ((halResult == Result::OK) && (halConfig.antennaConnected == true));
|
|
}
|
|
|
|
const BandConfig& BroadcastRadioHidlTest::getBand(unsigned idx) {
|
|
static BandConfig dummyBandConfig = {};
|
|
if (radioClass == Class::AM_FM) {
|
|
EXPECT_GT(mHalProperties.bands.size(), idx);
|
|
if (mHalProperties.bands.size() > idx) {
|
|
return mHalProperties.bands[idx];
|
|
} else {
|
|
return dummyBandConfig;
|
|
}
|
|
} else {
|
|
return dummyBandConfig;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test IBroadcastRadio::getProperties() method
|
|
*
|
|
* Verifies that:
|
|
* - the HAL implements the method
|
|
* - the method returns 0 (no error)
|
|
* - the implementation class is radioClass
|
|
* - the implementation supports at least one tuner
|
|
* - the implementation supports at one band
|
|
*/
|
|
TEST_P(BroadcastRadioHidlTest, GetProperties) {
|
|
RETURN_IF_SKIPPED;
|
|
EXPECT_EQ(true, getProperties());
|
|
}
|
|
|
|
/**
|
|
* Test IBroadcastRadio::openTuner() method
|
|
*
|
|
* Verifies that:
|
|
* - the HAL implements the method
|
|
* - the method returns 0 (no error) and a valid ITuner interface
|
|
*/
|
|
TEST_P(BroadcastRadioHidlTest, OpenTuner) {
|
|
RETURN_IF_SKIPPED;
|
|
EXPECT_EQ(true, openTuner());
|
|
}
|
|
|
|
/**
|
|
* Test IBroadcastRadio::openTuner() after ITuner disposal.
|
|
*
|
|
* Verifies that:
|
|
* - ITuner destruction gets propagated through HAL
|
|
* - the openTuner method works well when called for the second time
|
|
*/
|
|
TEST_P(BroadcastRadioHidlTest, ReopenTuner) {
|
|
RETURN_IF_SKIPPED;
|
|
EXPECT_TRUE(openTuner());
|
|
mTuner.clear();
|
|
EXPECT_TRUE(openTuner());
|
|
}
|
|
|
|
/**
|
|
* Test IBroadcastRadio::openTuner() method called twice.
|
|
*
|
|
* Verifies that:
|
|
* - the openTuner method fails with INVALID_STATE or succeeds when called for the second time
|
|
* without deleting previous ITuner instance
|
|
*/
|
|
TEST_P(BroadcastRadioHidlTest, OpenTunerTwice) {
|
|
RETURN_IF_SKIPPED;
|
|
EXPECT_TRUE(openTuner());
|
|
|
|
Result halResult = Result::NOT_INITIALIZED;
|
|
auto openCb = [&](Result result, const sp<ITuner>&) { halResult = result; };
|
|
auto hidlReturn = mRadio->openTuner(getBand(0), true, mTunerCallback, openCb);
|
|
EXPECT_TRUE(hidlReturn.isOk());
|
|
if (halResult == Result::OK) {
|
|
if (radioClass == Class::AM_FM) {
|
|
EXPECT_TRUE(waitForCallback(kConfigCallbacktimeoutNs));
|
|
}
|
|
} else {
|
|
EXPECT_EQ(Result::INVALID_STATE, halResult);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test ITuner::setConfiguration() and getConfiguration methods
|
|
*
|
|
* Verifies that:
|
|
* - the HAL implements both methods
|
|
* - the methods return 0 (no error)
|
|
* - the configuration callback is received within kConfigCallbacktimeoutNs ns
|
|
* - the configuration read back from HAl has the same class Id
|
|
*
|
|
* Skipped for other radio classes than AM/FM, because setConfiguration
|
|
* applies only for these bands.
|
|
*/
|
|
TEST_P(BroadcastRadioHidlTest, SetAndGetConfiguration) {
|
|
if (radioClass != Class::AM_FM) skipped = true;
|
|
RETURN_IF_SKIPPED;
|
|
ASSERT_EQ(true, openTuner());
|
|
// test setConfiguration
|
|
mCallbackCalled = false;
|
|
Return<Result> hidlResult = mTuner->setConfiguration(getBand(1));
|
|
EXPECT_TRUE(hidlResult.isOk());
|
|
EXPECT_EQ(Result::OK, hidlResult);
|
|
EXPECT_EQ(true, waitForCallback(kConfigCallbacktimeoutNs));
|
|
EXPECT_EQ(Result::OK, mResultCallbackData);
|
|
EXPECT_EQ(getBand(1), mBandConfigCallbackData);
|
|
|
|
// test getConfiguration
|
|
BandConfig halConfig;
|
|
Result halResult;
|
|
Return<void> hidlReturn =
|
|
mTuner->getConfiguration([&](Result result, const BandConfig& config) {
|
|
halResult = result;
|
|
if (result == Result::OK) {
|
|
halConfig = config;
|
|
}
|
|
});
|
|
EXPECT_TRUE(hidlReturn.isOk());
|
|
EXPECT_EQ(Result::OK, halResult);
|
|
EXPECT_EQ(getBand(1), halConfig);
|
|
}
|
|
|
|
/**
|
|
* Test ITuner::setConfiguration() with invalid arguments.
|
|
*
|
|
* Verifies that:
|
|
* - the methods returns INVALID_ARGUMENTS on invalid arguments
|
|
* - the method recovers and succeeds after passing correct arguments
|
|
*
|
|
* Skipped for other radio classes than AM/FM, because setConfiguration
|
|
* applies only for these bands.
|
|
*/
|
|
TEST_P(BroadcastRadioHidlTest, SetConfigurationFails) {
|
|
if (radioClass != Class::AM_FM) skipped = true;
|
|
RETURN_IF_SKIPPED;
|
|
ASSERT_EQ(true, openTuner());
|
|
|
|
// Let's define a config that's bad for sure.
|
|
BandConfig badConfig = {};
|
|
badConfig.type = Band::FM;
|
|
badConfig.lowerLimit = 0xFFFFFFFF;
|
|
badConfig.upperLimit = 0;
|
|
badConfig.spacings = (std::vector<uint32_t>){ 0 };
|
|
|
|
// Test setConfiguration failing on bad data.
|
|
mCallbackCalled = false;
|
|
auto setResult = mTuner->setConfiguration(badConfig);
|
|
EXPECT_TRUE(setResult.isOk());
|
|
EXPECT_EQ(Result::INVALID_ARGUMENTS, setResult);
|
|
|
|
// Test setConfiguration recovering after passing good data.
|
|
mCallbackCalled = false;
|
|
setResult = mTuner->setConfiguration(getBand(0));
|
|
EXPECT_TRUE(setResult.isOk());
|
|
EXPECT_EQ(Result::OK, setResult);
|
|
EXPECT_EQ(true, waitForCallback(kConfigCallbacktimeoutNs));
|
|
EXPECT_EQ(Result::OK, mResultCallbackData);
|
|
}
|
|
|
|
/**
|
|
* Test ITuner::scan
|
|
*
|
|
* Verifies that:
|
|
* - the HAL implements the method
|
|
* - the method returns 0 (no error)
|
|
* - the tuned callback is received within kTuneCallbacktimeoutNs ns
|
|
* - skipping sub-channel or not does not fail the call
|
|
*/
|
|
TEST_P(BroadcastRadioHidlTest, Scan) {
|
|
RETURN_IF_SKIPPED;
|
|
ASSERT_EQ(true, openTuner());
|
|
ASSERT_TRUE(checkAntenna());
|
|
// test scan UP
|
|
mCallbackCalled = false;
|
|
Return<Result> hidlResult = mTuner->scan(Direction::UP, true);
|
|
EXPECT_TRUE(hidlResult.isOk());
|
|
EXPECT_EQ(Result::OK, hidlResult);
|
|
EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs));
|
|
|
|
// test scan DOWN
|
|
mCallbackCalled = false;
|
|
hidlResult = mTuner->scan(Direction::DOWN, false);
|
|
EXPECT_TRUE(hidlResult.isOk());
|
|
EXPECT_EQ(Result::OK, hidlResult);
|
|
EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs));
|
|
}
|
|
|
|
/**
|
|
* Test ITuner::step
|
|
*
|
|
* Verifies that:
|
|
* - the HAL implements the method
|
|
* - the method returns 0 (no error)
|
|
* - the tuned callback is received within kTuneCallbacktimeoutNs ns
|
|
* - skipping sub-channel or not does not fail the call
|
|
*
|
|
* Skipped for other radio classes than AM/FM, because step is not possible
|
|
* on DAB nor satellite.
|
|
*/
|
|
TEST_P(BroadcastRadioHidlTest, Step) {
|
|
if (radioClass != Class::AM_FM) skipped = true;
|
|
RETURN_IF_SKIPPED;
|
|
ASSERT_EQ(true, openTuner());
|
|
ASSERT_TRUE(checkAntenna());
|
|
// test step UP
|
|
mCallbackCalled = false;
|
|
Return<Result> hidlResult = mTuner->step(Direction::UP, false);
|
|
EXPECT_TRUE(hidlResult.isOk());
|
|
EXPECT_EQ(Result::OK, hidlResult);
|
|
EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs));
|
|
|
|
// test step DOWN
|
|
mCallbackCalled = false;
|
|
hidlResult = mTuner->step(Direction::DOWN, true);
|
|
EXPECT_TRUE(hidlResult.isOk());
|
|
EXPECT_EQ(Result::OK, hidlResult);
|
|
EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs));
|
|
}
|
|
|
|
/**
|
|
* Test ITuner::tune, getProgramInformation and cancel methods
|
|
*
|
|
* Verifies that:
|
|
* - the HAL implements the methods
|
|
* - the methods return 0 (no error)
|
|
* - the tuned callback is received within kTuneCallbacktimeoutNs ns after tune()
|
|
*
|
|
* Skipped for other radio classes than AM/FM, because tune to frequency
|
|
* is not possible on DAB nor satellite.
|
|
*/
|
|
TEST_P(BroadcastRadioHidlTest, TuneAndGetProgramInformationAndCancel) {
|
|
if (radioClass != Class::AM_FM) skipped = true;
|
|
RETURN_IF_SKIPPED;
|
|
ASSERT_EQ(true, openTuner());
|
|
ASSERT_TRUE(checkAntenna());
|
|
|
|
auto& band = getBand(0);
|
|
|
|
// test tune
|
|
ASSERT_GT(band.spacings.size(), 0u);
|
|
ASSERT_GT(band.upperLimit, band.lowerLimit);
|
|
|
|
// test scan UP
|
|
uint32_t lowerLimit = band.lowerLimit;
|
|
uint32_t upperLimit = band.upperLimit;
|
|
uint32_t spacing = band.spacings[0];
|
|
|
|
uint32_t channel =
|
|
lowerLimit + (((upperLimit - lowerLimit) / 2 + spacing - 1) / spacing) * spacing;
|
|
mCallbackCalled = false;
|
|
mResultCallbackData = Result::NOT_INITIALIZED;
|
|
Return<Result> hidlResult = mTuner->tune(channel, 0);
|
|
EXPECT_TRUE(hidlResult.isOk());
|
|
EXPECT_EQ(Result::OK, hidlResult);
|
|
EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs));
|
|
EXPECT_EQ(channel, mProgramInfoCallbackData.channel);
|
|
|
|
// test getProgramInformation
|
|
ProgramInfo halInfo;
|
|
Result halResult = Result::NOT_INITIALIZED;
|
|
Return<void> hidlReturn = mTuner->getProgramInformation(
|
|
[&](Result result, const ProgramInfo& info) {
|
|
halResult = result;
|
|
if (result == Result::OK) {
|
|
halInfo = info;
|
|
}
|
|
});
|
|
EXPECT_TRUE(hidlReturn.isOk());
|
|
EXPECT_EQ(Result::OK, halResult);
|
|
if (mResultCallbackData == Result::OK) {
|
|
EXPECT_LE(halInfo.channel, upperLimit);
|
|
EXPECT_GE(halInfo.channel, lowerLimit);
|
|
}
|
|
|
|
// test cancel
|
|
mTuner->tune(lowerLimit, 0);
|
|
hidlResult = mTuner->cancel();
|
|
EXPECT_TRUE(hidlResult.isOk());
|
|
EXPECT_EQ(Result::OK, hidlResult);
|
|
}
|
|
|
|
/**
|
|
* Test ITuner::tune failing when channel out of the range is provided.
|
|
*
|
|
* Verifies that:
|
|
* - the method returns INVALID_ARGUMENTS when applicable
|
|
* - the method recovers and succeeds after passing correct arguments
|
|
*
|
|
* Skipped for other radio classes than AM/FM, because tune to frequency
|
|
* is not possible on DAB nor satellite.
|
|
*/
|
|
TEST_P(BroadcastRadioHidlTest, TuneFailsOutOfBounds) {
|
|
if (radioClass != Class::AM_FM) skipped = true;
|
|
RETURN_IF_SKIPPED;
|
|
ASSERT_TRUE(openTuner());
|
|
ASSERT_TRUE(checkAntenna());
|
|
|
|
// get current channel bounds
|
|
BandConfig halConfig;
|
|
Result halResult;
|
|
auto configResult = mTuner->getConfiguration([&](Result result, const BandConfig& config) {
|
|
halResult = result;
|
|
halConfig = config;
|
|
});
|
|
ASSERT_TRUE(configResult.isOk());
|
|
ASSERT_EQ(Result::OK, halResult);
|
|
|
|
// try to tune slightly above the limit and expect to fail
|
|
auto badChannel = halConfig.upperLimit + halConfig.spacings[0];
|
|
auto tuneResult = mTuner->tune(badChannel, 0);
|
|
EXPECT_TRUE(tuneResult.isOk());
|
|
EXPECT_EQ(Result::INVALID_ARGUMENTS, tuneResult);
|
|
EXPECT_TRUE(waitForCallback(kTuneCallbacktimeoutNs));
|
|
|
|
// tuning exactly at the limit should succeed
|
|
auto goodChannel = halConfig.upperLimit;
|
|
tuneResult = mTuner->tune(goodChannel, 0);
|
|
EXPECT_TRUE(tuneResult.isOk());
|
|
EXPECT_EQ(Result::OK, tuneResult);
|
|
EXPECT_TRUE(waitForCallback(kTuneCallbacktimeoutNs));
|
|
}
|
|
|
|
/**
|
|
* Test proper image format in metadata.
|
|
*
|
|
* Verifies that:
|
|
* - all images in metadata are provided in-band (as a binary blob, not by id)
|
|
*
|
|
* This is a counter-test for OobImagesOnly from 1.1 VTS.
|
|
*/
|
|
TEST_P(BroadcastRadioHidlTest, IbImagesOnly) {
|
|
RETURN_IF_SKIPPED;
|
|
ASSERT_TRUE(openTuner());
|
|
ASSERT_TRUE(checkAntenna());
|
|
|
|
bool firstScan = true;
|
|
uint32_t firstChannel, prevChannel;
|
|
while (true) {
|
|
mCallbackCalled = false;
|
|
auto hidlResult = mTuner->scan(Direction::UP, true);
|
|
ASSERT_TRUE(hidlResult.isOk());
|
|
if (hidlResult == Result::TIMEOUT) {
|
|
ALOGI("Got timeout on scan operation");
|
|
break;
|
|
}
|
|
ASSERT_EQ(Result::OK, hidlResult);
|
|
ASSERT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs));
|
|
|
|
if (firstScan) {
|
|
firstScan = false;
|
|
firstChannel = mProgramInfoCallbackData.channel;
|
|
} else {
|
|
// scanned the whole band
|
|
if (mProgramInfoCallbackData.channel >= firstChannel && prevChannel <= firstChannel) {
|
|
break;
|
|
}
|
|
}
|
|
prevChannel = mProgramInfoCallbackData.channel;
|
|
|
|
for (auto&& entry : mProgramInfoCallbackData.metadata) {
|
|
if (entry.key != MetadataKey::ICON && entry.key != MetadataKey::ART) continue;
|
|
EXPECT_EQ(MetadataType::RAW, entry.type);
|
|
EXPECT_EQ(0, entry.intValue);
|
|
EXPECT_GT(entry.rawValue.size(), 0u);
|
|
}
|
|
}
|
|
}
|
|
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(BroadcastRadioHidlTest);
|
|
INSTANTIATE_TEST_CASE_P(
|
|
PerInstance, BroadcastRadioHidlTest,
|
|
testing::Combine(testing::ValuesIn(android::hardware::getAllHalInstanceNames(
|
|
IBroadcastRadioFactory::descriptor)),
|
|
::testing::Values("AM_FM", "SAT", "DT")),
|
|
android::hardware::PrintInstanceTupleNameToString<>);
|