diff --git a/broadcastradio/1.0/Android.mk b/broadcastradio/1.0/Android.mk new file mode 100644 index 0000000000..f9e32763ff --- /dev/null +++ b/broadcastradio/1.0/Android.mk @@ -0,0 +1,19 @@ +# +# 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. +# + +LOCAL_PATH := $(call my-dir) + +include $(call all-subdir-makefiles) diff --git a/broadcastradio/1.0/vts/Android.mk b/broadcastradio/1.0/vts/Android.mk new file mode 100644 index 0000000000..f9e32763ff --- /dev/null +++ b/broadcastradio/1.0/vts/Android.mk @@ -0,0 +1,19 @@ +# +# 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. +# + +LOCAL_PATH := $(call my-dir) + +include $(call all-subdir-makefiles) diff --git a/broadcastradio/1.0/vts/functional/Android.bp b/broadcastradio/1.0/vts/functional/Android.bp new file mode 100644 index 0000000000..0edfcab49d --- /dev/null +++ b/broadcastradio/1.0/vts/functional/Android.bp @@ -0,0 +1,37 @@ +// +// 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. +// + +cc_test { + name: "broadcastradio_hidl_hal_test", + gtest: true, + srcs: ["broadcastradio_hidl_hal_test.cpp"], + shared_libs: [ + "libbase", + "liblog", + "libcutils", + "libhidlbase", + "libhidltransport", + "libhwbinder", + "libnativehelper", + "libutils", + "android.hardware.broadcastradio@1.0", + ], + static_libs: ["libgtest"], + cflags: [ + "-O0", + "-g", + ], +} diff --git a/broadcastradio/1.0/vts/functional/Android.mk b/broadcastradio/1.0/vts/functional/Android.mk new file mode 100644 index 0000000000..f9e32763ff --- /dev/null +++ b/broadcastradio/1.0/vts/functional/Android.mk @@ -0,0 +1,19 @@ +# +# 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. +# + +LOCAL_PATH := $(call my-dir) + +include $(call all-subdir-makefiles) diff --git a/broadcastradio/1.0/vts/functional/broadcastradio_hidl_hal_test.cpp b/broadcastradio/1.0/vts/functional/broadcastradio_hidl_hal_test.cpp new file mode 100644 index 0000000000..26666d68d2 --- /dev/null +++ b/broadcastradio/1.0/vts/functional/broadcastradio_hidl_hal_test.cpp @@ -0,0 +1,471 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + + +using ::android::sp; +using ::android::Mutex; +using ::android::Condition; +using ::android::hardware::ProcessState; +using ::android::hardware::Return; +using ::android::hardware::Status; +using ::android::hardware::Void; +using ::android::hardware::broadcastradio::V1_0::IBroadcastRadioFactory; +using ::android::hardware::broadcastradio::V1_0::IBroadcastRadio; +using ::android::hardware::broadcastradio::V1_0::ITuner; +using ::android::hardware::broadcastradio::V1_0::ITunerCallback; +using ::android::hardware::broadcastradio::V1_0::Result; +using ::android::hardware::broadcastradio::V1_0::Class; +using ::android::hardware::broadcastradio::V1_0::Properties; +using ::android::hardware::broadcastradio::V1_0::BandConfig; +using ::android::hardware::broadcastradio::V1_0::Direction; +using ::android::hardware::broadcastradio::V1_0::ProgramInfo; +using ::android::hardware::broadcastradio::V1_0::MetaData; + + +// The main test class for Sound Trigger HIDL HAL. + +class BroadcastRadioHidlTest : public ::testing::Test { + protected: + virtual void SetUp() override { + bool getStub = false; + char getsubProperty[PROPERTY_VALUE_MAX]; + if (property_get("vts.hidl.get_stub", getsubProperty, "") > 0) { + if (!strcmp(getsubProperty, "true") || + !strcmp(getsubProperty, "True") || + !strcmp(getsubProperty, "1")) { + getStub = true; + } + } + sp factory = + IBroadcastRadioFactory::getService("broadcastradio", getStub); + if (factory != 0) { + factory->connectModule(Class::AM_FM, + [&](Result retval, const ::android::sp& result) { + if (retval == Result::OK) { + mRadio = result; + } + }); + } + mTunerCallback = new MyCallback(this); + ASSERT_NE(nullptr, mRadio.get()); + ASSERT_EQ(!getStub, mRadio->isRemote()); + 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 hardwareFailure() { + ALOGI("%s", __FUNCTION__); + mParentTest->onHwFailureCallback(); + return Void(); + } + + virtual Return configChange(Result result, const BandConfig& config __unused) { + ALOGI("%s result %d", __FUNCTION__, result); + mParentTest->onResultCallback(result); + return Void(); + } + + virtual Return tuneComplete(Result result, const ProgramInfo& info __unused) { + ALOGI("%s result %d", __FUNCTION__, result); + mParentTest->onResultCallback(result); + return Void(); + } + + virtual Return afSwitch(const ProgramInfo& info __unused) { + return Void(); + } + + virtual Return antennaStateChange(bool connected) { + ALOGI("%s connected %d", __FUNCTION__, connected); + return Void(); + } + + virtual Return trafficAnnouncement(bool active) { + ALOGI("%s active %d", __FUNCTION__, active); + return Void(); + } + + virtual Return emergencyAnnouncement(bool active) { + ALOGI("%s active %d", __FUNCTION__, active); + return Void(); + } + + virtual Return newMetadata(uint32_t channel __unused, uint32_t subChannel __unused, + const ::android::hardware::hidl_vec& 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 a callback with status is received + */ + void onResultCallback(Result result) { + Mutex::Autolock _l(mLock); + mResultCallbackData = result; + 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(); + + static const nsecs_t kConfigCallbacktimeoutNs = seconds_to_nanoseconds(10); + static const nsecs_t kTuneCallbacktimeoutNs = seconds_to_nanoseconds(30); + + sp mRadio; + Properties mHalProperties; + sp mTuner; + sp mTunerCallback; + Mutex mLock; + Condition mCallbackCond; + bool mCallbackCalled; + bool mBoolCallbackData; + Result mResultCallbackData; + bool mHwFailure; +}; + +// A class for test environment setup (kept since this file is a template). +class BroadcastRadioHidlEnvironment : public ::testing::Environment { + public: + virtual void SetUp() {} + virtual void TearDown() {} +}; + +bool BroadcastRadioHidlTest::getProperties() +{ + if (mHalProperties.bands.size() == 0) { + Result halResult = Result::NOT_INITIALIZED; + Return hidlReturn = + mRadio->getProperties([&](Result result, const Properties& properties) { + halResult = result; + if (result == Result::OK) { + mHalProperties = properties; + } + }); + + EXPECT_EQ(Status::EX_NONE, hidlReturn.getStatus().exceptionCode()); + EXPECT_EQ(Result::OK, halResult); + EXPECT_EQ(Class::AM_FM, mHalProperties.classId); + EXPECT_GT(mHalProperties.numTuners, 0u); + EXPECT_GT(mHalProperties.bands.size(), 0u); + } + return mHalProperties.bands.size() > 0; +} + +bool BroadcastRadioHidlTest::openTuner() +{ + if (!getProperties()) { + return false; + } + if (mTuner.get() == nullptr) { + Result halResult = Result::NOT_INITIALIZED; + Return hidlReturn = + mRadio->openTuner(mHalProperties.bands[0], true, mTunerCallback, + [&](Result result, const sp& tuner) { + halResult = result; + if (result == Result::OK) { + mTuner = tuner; + } + }); + EXPECT_EQ(Status::EX_NONE, hidlReturn.getStatus().exceptionCode()); + EXPECT_EQ(Result::OK, halResult); + EXPECT_EQ(true, waitForCallback(kConfigCallbacktimeoutNs)); + } + EXPECT_NE(nullptr, mTuner.get()); + return nullptr != mTuner.get(); +} + +bool BroadcastRadioHidlTest::checkAntenna() +{ + BandConfig halConfig; + Result halResult = Result::NOT_INITIALIZED; + Return hidlReturn = + mTuner->getConfiguration([&](Result result, const BandConfig& config) { + halResult = result; + if (result == Result::OK) { + halConfig = config; + } + }); + + return ((halResult == Result::OK) && (halConfig.antennaConnected == true)); +} + + +/** + * Test IBroadcastRadio::getProperties() method + * + * Verifies that: + * - the HAL implements the method + * - the method returns 0 (no error) + * - the implementation class is AM_FM + * - the implementation supports at least one tuner + * - the implementation supports at one band + */ +TEST_F(BroadcastRadioHidlTest, GetProperties) { + 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_F(BroadcastRadioHidlTest, OpenTuner) { + EXPECT_EQ(true, openTuner()); +} + +/** + * 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 + */ +TEST_F(BroadcastRadioHidlTest, SetAndGetConfiguration) { + ASSERT_EQ(true, openTuner()); + // test setConfiguration + mCallbackCalled = false; + Return hidlResult = mTuner->setConfiguration(mHalProperties.bands[0]); + EXPECT_EQ(Status::EX_NONE, hidlResult.getStatus().exceptionCode()); + EXPECT_EQ(Result::OK, hidlResult); + EXPECT_EQ(true, waitForCallback(kConfigCallbacktimeoutNs)); + EXPECT_EQ(Result::OK, mResultCallbackData); + + // test getConfiguration + BandConfig halConfig; + Result halResult; + Return hidlReturn = + mTuner->getConfiguration([&](Result result, const BandConfig& config) { + halResult = result; + if (result == Result::OK) { + halConfig = config; + } + }); + EXPECT_EQ(Status::EX_NONE, hidlReturn.getStatus().exceptionCode()); + EXPECT_EQ(Result::OK, halResult); + EXPECT_EQ(mHalProperties.bands[0].type, halConfig.type); +} + +/** + * Test ITuner::scan + * + * Verifies that: + * - the HAL implements the method + * - the method returns 0 (no error) + * - the tuned callback is received within kTuneCallbacktimeoutNs ns + */ +TEST_F(BroadcastRadioHidlTest, Scan) { + ASSERT_EQ(true, openTuner()); + ASSERT_TRUE(checkAntenna()); + // test scan UP + mCallbackCalled = false; + Return hidlResult = mTuner->scan(Direction::UP, true); + EXPECT_EQ(Status::EX_NONE, hidlResult.getStatus().exceptionCode()); + EXPECT_EQ(Result::OK, hidlResult); + EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs)); + + // test scan DOWN + mCallbackCalled = false; + hidlResult = mTuner->scan(Direction::DOWN, true); + EXPECT_EQ(Status::EX_NONE, hidlResult.getStatus().exceptionCode()); + 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 + */ +TEST_F(BroadcastRadioHidlTest, Step) { + ASSERT_EQ(true, openTuner()); + ASSERT_TRUE(checkAntenna()); + // test step UP + mCallbackCalled = false; + Return hidlResult = mTuner->step(Direction::UP, true); + EXPECT_EQ(Status::EX_NONE, hidlResult.getStatus().exceptionCode()); + EXPECT_EQ(Result::OK, hidlResult); + EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs)); + + // test step DOWN + mCallbackCalled = false; + hidlResult = mTuner->step(Direction::DOWN, true); + EXPECT_EQ(Status::EX_NONE, hidlResult.getStatus().exceptionCode()); + 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() + */ +TEST_F(BroadcastRadioHidlTest, TuneAndGetProgramInformationAndCancel) { + ASSERT_EQ(true, openTuner()); + ASSERT_TRUE(checkAntenna()); + + // test tune + ASSERT_GT(mHalProperties.bands[0].spacings.size(), 0u); + ASSERT_GT(mHalProperties.bands[0].upperLimit, mHalProperties.bands[0].lowerLimit); + + // test scan UP + uint32_t lowerLimit = mHalProperties.bands[0].lowerLimit; + uint32_t upperLimit = mHalProperties.bands[0].upperLimit; + uint32_t spacing = mHalProperties.bands[0].spacings[0]; + + uint32_t channel = + lowerLimit + (((upperLimit - lowerLimit) / 2 + spacing - 1) / spacing) * spacing; + mCallbackCalled = false; + mResultCallbackData = Result::NOT_INITIALIZED; + Return hidlResult = mTuner->tune(channel, 0); + EXPECT_EQ(Status::EX_NONE, hidlResult.getStatus().exceptionCode()); + EXPECT_EQ(Result::OK, hidlResult); + EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs)); + + // test getProgramInformation + ProgramInfo halInfo; + Result halResult = Result::NOT_INITIALIZED; + Return hidlReturn = mTuner->getProgramInformation( + false, [&](Result result, const ProgramInfo& info) { + halResult = result; + if (result == Result::OK) { + halInfo = info; + } + }); + EXPECT_EQ(Status::EX_NONE, hidlReturn.getStatus().exceptionCode()); + EXPECT_EQ(Result::OK, halResult); + if (mResultCallbackData == Result::OK) { + EXPECT_EQ(true, halInfo.tuned); + EXPECT_LE(halInfo.channel, upperLimit); + EXPECT_GE(halInfo.channel, lowerLimit); + } else { + EXPECT_EQ(false, halInfo.tuned); + } + + // test cancel + mTuner->tune(lowerLimit, 0); + hidlResult = mTuner->cancel(); + EXPECT_EQ(Status::EX_NONE, hidlResult.getStatus().exceptionCode()); + EXPECT_EQ(Result::OK, hidlResult); +} + + +int main(int argc, char** argv) { + sp proc(ProcessState::self()); + ProcessState::self()->startThreadPool(); + ::testing::AddGlobalTestEnvironment(new BroadcastRadioHidlEnvironment); + ::testing::InitGoogleTest(&argc, argv); + int status = RUN_ALL_TESTS(); + ALOGI("Test result = %d", status); + return status; +} diff --git a/broadcastradio/1.0/vts/functional/vts/Android.mk b/broadcastradio/1.0/vts/functional/vts/Android.mk new file mode 100644 index 0000000000..f9e32763ff --- /dev/null +++ b/broadcastradio/1.0/vts/functional/vts/Android.mk @@ -0,0 +1,19 @@ +# +# 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. +# + +LOCAL_PATH := $(call my-dir) + +include $(call all-subdir-makefiles) diff --git a/broadcastradio/1.0/vts/functional/vts/testcases/Android.mk b/broadcastradio/1.0/vts/functional/vts/testcases/Android.mk new file mode 100644 index 0000000000..f9e32763ff --- /dev/null +++ b/broadcastradio/1.0/vts/functional/vts/testcases/Android.mk @@ -0,0 +1,19 @@ +# +# 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. +# + +LOCAL_PATH := $(call my-dir) + +include $(call all-subdir-makefiles) diff --git a/broadcastradio/1.0/vts/functional/vts/testcases/hal/Android.mk b/broadcastradio/1.0/vts/functional/vts/testcases/hal/Android.mk new file mode 100644 index 0000000000..f9e32763ff --- /dev/null +++ b/broadcastradio/1.0/vts/functional/vts/testcases/hal/Android.mk @@ -0,0 +1,19 @@ +# +# 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. +# + +LOCAL_PATH := $(call my-dir) + +include $(call all-subdir-makefiles) diff --git a/broadcastradio/1.0/vts/functional/vts/testcases/hal/broadcastradio/Android.mk b/broadcastradio/1.0/vts/functional/vts/testcases/hal/broadcastradio/Android.mk new file mode 100644 index 0000000000..f9e32763ff --- /dev/null +++ b/broadcastradio/1.0/vts/functional/vts/testcases/hal/broadcastradio/Android.mk @@ -0,0 +1,19 @@ +# +# 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. +# + +LOCAL_PATH := $(call my-dir) + +include $(call all-subdir-makefiles) diff --git a/broadcastradio/1.0/vts/functional/vts/testcases/hal/broadcastradio/hidl/Android.mk b/broadcastradio/1.0/vts/functional/vts/testcases/hal/broadcastradio/hidl/Android.mk new file mode 100644 index 0000000000..f9e32763ff --- /dev/null +++ b/broadcastradio/1.0/vts/functional/vts/testcases/hal/broadcastradio/hidl/Android.mk @@ -0,0 +1,19 @@ +# +# 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. +# + +LOCAL_PATH := $(call my-dir) + +include $(call all-subdir-makefiles) diff --git a/broadcastradio/1.0/vts/functional/vts/testcases/hal/broadcastradio/hidl/target/Android.mk b/broadcastradio/1.0/vts/functional/vts/testcases/hal/broadcastradio/hidl/target/Android.mk new file mode 100644 index 0000000000..153dcd6550 --- /dev/null +++ b/broadcastradio/1.0/vts/functional/vts/testcases/hal/broadcastradio/hidl/target/Android.mk @@ -0,0 +1,25 @@ +# +# 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. +# + +LOCAL_PATH := $(call my-dir) + +include $(call all-subdir-makefiles) + +include $(CLEAR_VARS) + +LOCAL_MODULE := HalBroadcastRadioHidlTargetBasicTest +VTS_CONFIG_SRC_DIR := testcases/hal/broadcastradio/hidl/target +include test/vts/tools/build/Android.host_config.mk diff --git a/broadcastradio/1.0/vts/functional/vts/testcases/hal/broadcastradio/hidl/target/AndroidTest.xml b/broadcastradio/1.0/vts/functional/vts/testcases/hal/broadcastradio/hidl/target/AndroidTest.xml new file mode 100644 index 0000000000..4c03855989 --- /dev/null +++ b/broadcastradio/1.0/vts/functional/vts/testcases/hal/broadcastradio/hidl/target/AndroidTest.xml @@ -0,0 +1,30 @@ + + + + + + + + + diff --git a/broadcastradio/Android.bp b/broadcastradio/Android.bp index bbb3e4bac0..33f70ebae2 100644 --- a/broadcastradio/Android.bp +++ b/broadcastradio/Android.bp @@ -1,4 +1,5 @@ // This is an autogenerated file, do not edit. subdirs = [ "1.0", + "1.0/vts/functional", ] diff --git a/broadcastradio/Android.mk b/broadcastradio/Android.mk new file mode 100644 index 0000000000..f9e32763ff --- /dev/null +++ b/broadcastradio/Android.mk @@ -0,0 +1,19 @@ +# +# 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. +# + +LOCAL_PATH := $(call my-dir) + +include $(call all-subdir-makefiles)