Google Git
Sign in
android / platform / packages / modules / NeuralNetworks / refs/heads/android11-mainline-conscrypt-release / . / runtime / test / TestVersionedInterfaces.cpp
blob: 6d1306d571fbcb4d5608290994dfc96b1d0af5da [file] [log] [blame] [edit]
/*
* Copyright (C) 2020 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.
*/
#include <android-base/logging.h>
#include <android/hardware/neuralnetworks/1.0/ADevice.h>
#include <android/hardware/neuralnetworks/1.1/ADevice.h>
#include <android/hardware/neuralnetworks/1.2/ADevice.h>
#include <android/hardware/neuralnetworks/1.3/ADevice.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <hidl/Status.h>
#include <utils/Errors.h>
#include <limits>
#include <memory>
#include <utility>
#include <vector>
#include "HalInterfaces.h"
#include "MemoryUtils.h"
#include "MetaModel.h"
#include "VersionedInterfaces.h"
namespace android::nn {
namespace {
using namespace hal;
using testing::_;
using testing::Invoke;
using testing::InvokeWithoutArgs;
using testing::MockFunction;
using MockDeviceFactory = MockFunction<sp<V1_0::IDevice>(bool blocking)>;
constexpr uint32_t kNoCacheFilesNeeded = 0;
constexpr uint32_t kMaxNumberOfCacheFiles =
static_cast<uint32_t>(Constant::MAX_NUMBER_OF_CACHE_FILES);
constexpr Timing kNoTiming = {.timeOnDevice = std::numeric_limits<uint64_t>::max(),
.timeInDriver = std::numeric_limits<uint64_t>::max()};
template <typename... Args>
auto makeCallbackReturn(Args&&... args) {
return [argPack = std::make_tuple(std::forward<Args>(args)...)](const auto& cb) {
std::apply(cb, argPack);
return Void();
};
};
class MockDevice : public IDevice {
public:
static sp<MockDevice> create() {
const sp<MockDevice> mockDevice = new MockDevice();
const auto linkToDeathRet_ret = []() -> Return<bool> { return true; };
const auto getCapabilities_ret =
makeCallbackReturn(V1_0::ErrorStatus::NONE, V1_0::Capabilities{});
const auto getCapabilities_1_1_ret =
makeCallbackReturn(V1_0::ErrorStatus::NONE, V1_1::Capabilities{});
const auto getVersionString_ret =
makeCallbackReturn(V1_0::ErrorStatus::NONE, "Google-MockV1");
const auto getType_ret = makeCallbackReturn(V1_0::ErrorStatus::NONE, DeviceType::OTHER);
const auto getCapabilities_1_2_ret =
makeCallbackReturn(V1_0::ErrorStatus::NONE, V1_2::Capabilities{});
const auto getSupportedExtensions_ret =
makeCallbackReturn(V1_0::ErrorStatus::NONE, hidl_vec<Extension>{});
const auto getNumberOfCacheFilesNeeded_ret = makeCallbackReturn(
V1_0::ErrorStatus::NONE, kMaxNumberOfCacheFiles, kMaxNumberOfCacheFiles);
const auto getCapabilities_1_3_ret =
makeCallbackReturn(V1_3::ErrorStatus::NONE, V1_3::Capabilities{});
ON_CALL(*mockDevice, linkToDeathRet()).WillByDefault(Invoke(linkToDeathRet_ret));
ON_CALL(*mockDevice, getCapabilities(_)).WillByDefault(Invoke(getCapabilities_ret));
ON_CALL(*mockDevice, getCapabilities_1_1(_)).WillByDefault(Invoke(getCapabilities_1_1_ret));
ON_CALL(*mockDevice, getVersionString(_)).WillByDefault(Invoke(getVersionString_ret));
ON_CALL(*mockDevice, getType(_)).WillByDefault(Invoke(getType_ret));
ON_CALL(*mockDevice, getCapabilities_1_2(_)).WillByDefault(Invoke(getCapabilities_1_2_ret));
ON_CALL(*mockDevice, getSupportedExtensions(_))
.WillByDefault(Invoke(getSupportedExtensions_ret));
ON_CALL(*mockDevice, getNumberOfCacheFilesNeeded(_))
.WillByDefault(Invoke(getNumberOfCacheFilesNeeded_ret));
ON_CALL(*mockDevice, getCapabilities_1_3(_)).WillByDefault(Invoke(getCapabilities_1_3_ret));
// These EXPECT_CALL(...).Times(testing::AnyNumber()) calls are to
// suppress warnings on the uninteresting methods calls.
EXPECT_CALL(*mockDevice, linkToDeathRet()).Times(testing::AnyNumber());
EXPECT_CALL(*mockDevice, getCapabilities(_)).Times(testing::AnyNumber());
EXPECT_CALL(*mockDevice, getCapabilities_1_1(_)).Times(testing::AnyNumber());
EXPECT_CALL(*mockDevice, getVersionString(_)).Times(testing::AnyNumber());
EXPECT_CALL(*mockDevice, getType(_)).Times(testing::AnyNumber());
EXPECT_CALL(*mockDevice, getCapabilities_1_2(_)).Times(testing::AnyNumber());
EXPECT_CALL(*mockDevice, getSupportedExtensions(_)).Times(testing::AnyNumber());
EXPECT_CALL(*mockDevice, getNumberOfCacheFilesNeeded(_)).Times(testing::AnyNumber());
EXPECT_CALL(*mockDevice, getCapabilities_1_3(_)).Times(testing::AnyNumber());
return mockDevice;
}
// IBase methods below.
Return<bool> linkToDeath(const sp<hidl_death_recipient>& recipient,
uint64_t /*cookie*/) override {
mDeathRecipient = recipient;
return linkToDeathRet();
}
MOCK_METHOD(Return<void>, ping, (), (override));
// V1_0 methods below.
MOCK_METHOD(Return<void>, getCapabilities, (getCapabilities_cb cb), (override));
MOCK_METHOD(Return<void>, getSupportedOperations,
(const V1_0::Model& model, getSupportedOperations_cb cb), (override));
MOCK_METHOD(Return<V1_0::ErrorStatus>, prepareModel,
(const V1_0::Model& model, const sp<V1_0::IPreparedModelCallback>& callback),
(override));
MOCK_METHOD(Return<DeviceStatus>, getStatus, (), (override));
// V1_1 methods below.
MOCK_METHOD(Return<void>, getCapabilities_1_1, (getCapabilities_1_1_cb cb), (override));
MOCK_METHOD(Return<void>, getSupportedOperations_1_1,
(const V1_1::Model& model, getSupportedOperations_1_1_cb cb), (override));
MOCK_METHOD(Return<V1_0::ErrorStatus>, prepareModel_1_1,
(const V1_1::Model& model, ExecutionPreference preference,
const sp<V1_0::IPreparedModelCallback>& callback),
(override));
// V1_2 methods below.
MOCK_METHOD(Return<void>, getVersionString, (getVersionString_cb cb), (override));
MOCK_METHOD(Return<void>, getType, (getType_cb cb), (override));
MOCK_METHOD(Return<void>, getCapabilities_1_2, (getCapabilities_1_2_cb cb), (override));
MOCK_METHOD(Return<void>, getSupportedExtensions, (getSupportedExtensions_cb cb), (override));
MOCK_METHOD(Return<void>, getSupportedOperations_1_2,
(const V1_2::Model& model, getSupportedOperations_1_2_cb cb), (override));
MOCK_METHOD(Return<void>, getNumberOfCacheFilesNeeded, (getNumberOfCacheFilesNeeded_cb cb),
(override));
MOCK_METHOD(Return<V1_0::ErrorStatus>, prepareModel_1_2,
(const V1_2::Model& model, ExecutionPreference preference,
const hidl_vec<hidl_handle>& modelCache, const hidl_vec<hidl_handle>& dataCache,
const CacheToken& token, const sp<V1_2::IPreparedModelCallback>& callback),
(override));
MOCK_METHOD(Return<V1_0::ErrorStatus>, prepareModelFromCache,
(const hidl_vec<hidl_handle>& modelCache, const hidl_vec<hidl_handle>& dataCache,
const CacheToken& token, const sp<V1_2::IPreparedModelCallback>& callback),
(override));
// V1_3 methods below.
MOCK_METHOD(Return<void>, getCapabilities_1_3, (getCapabilities_1_3_cb cb), (override));
MOCK_METHOD(Return<void>, getSupportedOperations_1_3,
(const V1_3::Model& model, getSupportedOperations_1_3_cb cb), (override));
MOCK_METHOD(Return<V1_3::ErrorStatus>, prepareModel_1_3,
(const V1_3::Model& model, ExecutionPreference preference, Priority priority,
const OptionalTimePoint& deadline, const hidl_vec<hidl_handle>& modelCache,
const hidl_vec<hidl_handle>& dataCache, const CacheToken& token,
const sp<V1_3::IPreparedModelCallback>& callback),
(override));
MOCK_METHOD(Return<V1_3::ErrorStatus>, prepareModelFromCache_1_3,
(const OptionalTimePoint& deadline, const hidl_vec<hidl_handle>& modelCache,
const hidl_vec<hidl_handle>& dataCache, const CacheToken& token,
const sp<V1_3::IPreparedModelCallback>& callback),
(override));
MOCK_METHOD(Return<void>, allocate,
(const BufferDesc& desc, const hidl_vec<sp<V1_3::IPreparedModel>>& preparedModels,
const hidl_vec<BufferRole>& inputRoles, const hidl_vec<BufferRole>& outputRoles,
allocate_cb cb),
(override));
// Helper methods.
MOCK_METHOD(Return<bool>, linkToDeathRet, ());
void simulateCrash() {
ASSERT_NE(nullptr, mDeathRecipient.get());
// Currently, the VersionedInterfaces code will not use the `cookie` or
// `who` arguments, so we pass in 0 and nullptr for these arguments
// instead. Normally, they are used by the hidl_death_recipient to
// determine which object is dead. However, the VersionedInterfaces
// code only pairs a single death recipient with a single HIDL
// interface object, so these arguments are redundant.
mDeathRecipient->serviceDied(0, nullptr);
}
private:
// Members.
sp<hidl_death_recipient> mDeathRecipient;
};
class MockPreparedModel : public IPreparedModel {
public:
static sp<MockPreparedModel> create() {
const sp<MockPreparedModel> mockPreparedModel = new MockPreparedModel();
const auto linkToDeathRet_ret = []() -> Return<bool> { return true; };
ON_CALL(*mockPreparedModel, linkToDeathRet()).WillByDefault(Invoke(linkToDeathRet_ret));
// This EXPECT_CALL(...).Times(testing::AnyNumber()) calls are to
// suppress warnings on the uninteresting methods calls.
EXPECT_CALL(*mockPreparedModel, linkToDeathRet()).Times(testing::AnyNumber());
return mockPreparedModel;
}
// IBase methods below.
Return<bool> linkToDeath(const sp<hidl_death_recipient>& recipient,
uint64_t /*cookie*/) override {
mDeathRecipient = recipient;
return linkToDeathRet();
}
MOCK_METHOD(Return<void>, ping, (), (override));
// V1_0 methods below.
MOCK_METHOD(Return<V1_0::ErrorStatus>, execute,
(const V1_0::Request& request, const sp<V1_0::IExecutionCallback>& callback),
(override));
// V1_2 methods below.
MOCK_METHOD(Return<V1_0::ErrorStatus>, execute_1_2,
(const V1_0::Request& request, MeasureTiming measure,
const sp<V1_2::IExecutionCallback>& callback),
(override));
MOCK_METHOD(Return<void>, executeSynchronously,
(const V1_0::Request& request, MeasureTiming measure, executeSynchronously_cb cb),
(override));
MOCK_METHOD(Return<void>, configureExecutionBurst,
(const sp<V1_2::IBurstCallback>& callback,
const hardware::MQDescriptorSync<V1_2::FmqRequestDatum>& requestChannel,
const hardware::MQDescriptorSync<V1_2::FmqResultDatum>& resultChannel,
configureExecutionBurst_cb cb),
(override));
// V1_3 methods below.
MOCK_METHOD(Return<ErrorStatus>, execute_1_3,
(const V1_3::Request& request, MeasureTiming measure,
const OptionalTimePoint& deadline,
const OptionalTimeoutDuration& loopTimeoutDuration,
const sp<IExecutionCallback>& callback),
(override));
MOCK_METHOD(Return<void>, executeSynchronously_1_3,
(const V1_3::Request& request, MeasureTiming measure,
const OptionalTimePoint& deadline,
const OptionalTimeoutDuration& loopTimeoutDuration,
executeSynchronously_1_3_cb cb),
(override));
MOCK_METHOD(Return<void>, executeFenced,
(const V1_3::Request& request, const hidl_vec<hidl_handle>& waitFor,
MeasureTiming measure, const OptionalTimePoint& deadline,
const OptionalTimeoutDuration& loopTimeoutDuration,
const OptionalTimeoutDuration& duration, executeFenced_cb cb),
(override));
// Helper methods.
MOCK_METHOD(Return<bool>, linkToDeathRet, ());
void simulateCrash() {
ASSERT_NE(nullptr, mDeathRecipient.get());
// Currently, the VersionedInterfaces code will not use the `cookie` or
// `who` arguments, so we pass in 0 and nullptr for these arguments
// instead. Normally, they are used by the hidl_death_recipient to
// determine which object is dead. However, the VersionedInterfaces
// code only pairs a single death recipient with a single HIDL
// interface object, so these arguments are redundant.
mDeathRecipient->serviceDied(0, nullptr);
}
private:
// Members.
sp<hidl_death_recipient> mDeathRecipient;
};
class MockBurstContext : public V1_2::IBurstContext {
public:
// V1_2 methods below.
MOCK_METHOD(Return<void>, freeMemory, (int32_t slot), (override));
};
class MockFencedExecutionCallback : public IFencedExecutionCallback {
public:
// V1_3 methods below.
MOCK_METHOD(Return<void>, getExecutionInfo, (getExecutionInfo_cb cb), (override));
};
class MockBuffer : public IBuffer {
public:
// V1_3 methods below.
MOCK_METHOD(Return<ErrorStatus>, copyTo, (const hidl_memory& dst), (override));
MOCK_METHOD(Return<ErrorStatus>, copyFrom,
(const hidl_memory& src, const hidl_vec<uint32_t>& dimensions), (override));
};
enum class Version { V1_0, V1_1, V1_2, V1_3, MOCK };
sp<V1_0::IDevice> adaptAs(const sp<MockDevice>& mockDevice, Version version) {
switch (version) {
case Version::V1_0:
return new V1_0::ADevice(mockDevice);
case Version::V1_1:
return new V1_1::ADevice(mockDevice);
case Version::V1_2:
return new V1_2::ADevice(mockDevice);
case Version::V1_3:
return new V1_3::ADevice(mockDevice);
case Version::MOCK:
return mockDevice;
}
LOG(FATAL) << "unrecognized version: " << static_cast<int>(version);
return nullptr;
}
auto makePreparedModelReturn(V1_0::ErrorStatus launchStatus, V1_0::ErrorStatus returnStatus,
const sp<MockPreparedModel>& preparedModel) {
return [launchStatus, returnStatus, preparedModel](
const V1_0::Model& /*model*/,
const sp<V1_0::IPreparedModelCallback>& cb) -> Return<V1_0::ErrorStatus> {
cb->notify(returnStatus, preparedModel).isOk();
return launchStatus;
};
}
auto makePreparedModel_1_1Return(V1_0::ErrorStatus launchStatus, V1_0::ErrorStatus returnStatus,
const sp<MockPreparedModel>& preparedModel) {
return [launchStatus, returnStatus, preparedModel](
const V1_1::Model& /*model*/, ExecutionPreference /*preference*/,
const sp<V1_0::IPreparedModelCallback>& cb) -> Return<V1_0::ErrorStatus> {
cb->notify(returnStatus, preparedModel).isOk();
return launchStatus;
};
}
auto makePreparedModel_1_2Return(V1_0::ErrorStatus launchStatus, V1_0::ErrorStatus returnStatus,
const sp<MockPreparedModel>& preparedModel) {
return [launchStatus, returnStatus, preparedModel](
const V1_2::Model& /*model*/, ExecutionPreference /*preference*/,
const auto& /*modelCache*/, const auto& /*dataCache*/, const auto& /*token*/,
const sp<V1_2::IPreparedModelCallback>& cb) -> Return<V1_0::ErrorStatus> {
cb->notify_1_2(returnStatus, preparedModel).isOk();
return launchStatus;
};
}
auto makePreparedModel_1_3Return(V1_3::ErrorStatus launchStatus, V1_3::ErrorStatus returnStatus,
const sp<MockPreparedModel>& preparedModel) {
return [launchStatus, returnStatus, preparedModel](
const V1_3::Model& /*model*/, ExecutionPreference /*preference*/,
Priority /*priority*/, const OptionalTimePoint& /*deadline*/,
const hidl_vec<hidl_handle>& /*modelCache*/,
const hidl_vec<hidl_handle>& /*dataCache*/, const CacheToken& /*token*/,
const sp<V1_3::IPreparedModelCallback>& cb) -> Return<V1_3::ErrorStatus> {
cb->notify_1_3(returnStatus, preparedModel).isOk();
return launchStatus;
};
}
auto makeExecuteReturn(V1_0::ErrorStatus launchStatus, V1_0::ErrorStatus returnStatus) {
return [launchStatus, returnStatus](
const V1_0::Request& /*request*/,
const sp<V1_0::IExecutionCallback>& cb) -> Return<V1_0::ErrorStatus> {
cb->notify(returnStatus);
return launchStatus;
};
}
auto makeExecute_1_2Return(V1_0::ErrorStatus launchStatus, V1_0::ErrorStatus returnStatus,
const std::vector<OutputShape>& outputShapes, const Timing& timing) {
return [launchStatus, returnStatus, outputShapes, timing](
const V1_0::Request& /*request*/, MeasureTiming /*measureTiming*/,
const sp<V1_2::IExecutionCallback>& cb) -> Return<V1_0::ErrorStatus> {
cb->notify_1_2(returnStatus, outputShapes, timing);
return launchStatus;
};
}
auto makeExecute_1_3Return(V1_3::ErrorStatus launchStatus, V1_3::ErrorStatus returnStatus,
const std::vector<OutputShape>& outputShapes, const Timing& timing) {
return [launchStatus, returnStatus, outputShapes, timing](
const V1_3::Request& /*request*/, MeasureTiming /*measureTiming*/,
const OptionalTimePoint& /*deadline*/,
const OptionalTimeoutDuration& /*loopTimeoutDuration*/,
const sp<V1_3::IExecutionCallback>& cb) -> Return<V1_3::ErrorStatus> {
cb->notify_1_3(returnStatus, outputShapes, timing);
return launchStatus;
};
}
auto makeExecuteSynchronouslyReturn(V1_0::ErrorStatus status,
const std::vector<OutputShape>& outputShapes,
const Timing& timing) {
return [status, outputShapes, timing](const V1_0::Request& /*request*/,
MeasureTiming /*measureTiming*/,
const V1_2::IPreparedModel::executeSynchronously_cb& cb) {
cb(status, outputShapes, timing);
return Void();
};
}
auto makeExecuteSynchronously_1_3Return(V1_3::ErrorStatus status,
const std::vector<OutputShape>& outputShapes,
const Timing& timing) {
return [status, outputShapes, timing](
const V1_3::Request& /*request*/, MeasureTiming /*measureTiming*/,
const OptionalTimePoint& /*deadline*/,
const OptionalTimeoutDuration& /*loopTimeoutDuration*/,
const V1_3::IPreparedModel::executeSynchronously_1_3_cb& cb) {
cb(status, outputShapes, timing);
return Void();
};
}
auto makeConfigureExecutionBurst(V1_0::ErrorStatus status,
const sp<MockBurstContext>& burstContext) {
return [status, burstContext](
const sp<V1_2::IBurstCallback>& /*callback*/,
const hardware::MQDescriptorSync<V1_2::FmqRequestDatum>& /*requestChannel*/,
const hardware::MQDescriptorSync<V1_2::FmqResultDatum>& /*resultChannel*/,
V1_2::IPreparedModel::configureExecutionBurst_cb cb) {
cb(status, burstContext);
return Void();
};
}
auto makeExecuteFencedReturn(V1_3::ErrorStatus status, const hidl_handle& syncFence,
const sp<IFencedExecutionCallback>& dispatchCallback) {
return [status, syncFence, dispatchCallback](
const V1_3::Request& /*request*/, const hidl_vec<hidl_handle>& /*waitFor*/,
MeasureTiming /*measure*/, const OptionalTimePoint& /*deadline*/,
const OptionalTimeoutDuration& /*loopTimeoutDuration*/,
const OptionalTimeoutDuration& /*duration*/,
V1_3::IPreparedModel::executeFenced_cb cb) {
cb(status, syncFence, dispatchCallback);
return Void();
};
}
// TODO: The "setupInitializationExpectation*" calls below re-specify the
// number of expected times each initialization method is called. Because
// this was originally set to `testing::AnyNumber()` when the object was
// created, do these calls act as no-ops, do they override the previous
// expectations, or are both expectations still active?
void setupInitializationExpectationsV1_0(const sp<MockDevice>& mockDevice) {
EXPECT_CALL(*mockDevice, getCapabilities_1_1(_)).Times(0);
EXPECT_CALL(*mockDevice, getCapabilities_1_2(_)).Times(0);
EXPECT_CALL(*mockDevice, getCapabilities_1_3(_)).Times(0);
EXPECT_CALL(*mockDevice, getVersionString(_)).Times(0);
EXPECT_CALL(*mockDevice, getType(_)).Times(0);
EXPECT_CALL(*mockDevice, getSupportedExtensions(_)).Times(0);
EXPECT_CALL(*mockDevice, getNumberOfCacheFilesNeeded(_)).Times(0);
}
void setupInitializationExpectationsV1_1(const sp<MockDevice>& mockDevice) {
EXPECT_CALL(*mockDevice, getCapabilities(_)).Times(0);
EXPECT_CALL(*mockDevice, getCapabilities_1_2(_)).Times(0);
EXPECT_CALL(*mockDevice, getCapabilities_1_3(_)).Times(0);
EXPECT_CALL(*mockDevice, getVersionString(_)).Times(0);
EXPECT_CALL(*mockDevice, getType(_)).Times(0);
EXPECT_CALL(*mockDevice, getSupportedExtensions(_)).Times(0);
EXPECT_CALL(*mockDevice, getNumberOfCacheFilesNeeded(_)).Times(0);
}
void setupInitializationExpectationsV1_2(const sp<MockDevice>& mockDevice) {
EXPECT_CALL(*mockDevice, getCapabilities(_)).Times(0);
EXPECT_CALL(*mockDevice, getCapabilities_1_1(_)).Times(0);
EXPECT_CALL(*mockDevice, getCapabilities_1_3(_)).Times(0);
}
void setupInitializationExpectationsV1_3(const sp<MockDevice>& mockDevice) {
EXPECT_CALL(*mockDevice, getCapabilities(_)).Times(0);
EXPECT_CALL(*mockDevice, getCapabilities_1_1(_)).Times(0);
EXPECT_CALL(*mockDevice, getCapabilities_1_2(_)).Times(0);
}
void setupInitializationExpectations(const sp<MockDevice>& mockDevice, Version version) {
switch (version) {
case Version::V1_0:
setupInitializationExpectationsV1_0(mockDevice);
return;
case Version::V1_1:
setupInitializationExpectationsV1_1(mockDevice);
return;
case Version::V1_2:
setupInitializationExpectationsV1_2(mockDevice);
return;
case Version::V1_3:
setupInitializationExpectationsV1_3(mockDevice);
return;
case Version::MOCK:
setupInitializationExpectationsV1_3(mockDevice);
return;
}
LOG(FATAL) << "unrecognized version: " << static_cast<int>(version);
}
void setupSuccessfulInitializationExpectations(const sp<MockDevice>& mockDevice, Version version) {
EXPECT_CALL(*mockDevice, linkToDeathRet()).Times(testing::AnyNumber());
const int numCallsForV1_0 = (version == Version::V1_0 ? 1 : 0);
EXPECT_CALL(*mockDevice, getCapabilities(_)).Times(numCallsForV1_0);
const int numCallsForV1_1 = (version == Version::V1_1 ? 1 : 0);
EXPECT_CALL(*mockDevice, getCapabilities_1_1(_)).Times(numCallsForV1_1);
const int numCallsForV1_2 = (version == Version::V1_2 ? 1 : 0);
EXPECT_CALL(*mockDevice, getCapabilities_1_2(_)).Times(numCallsForV1_2);
const int numCallsForAtLeastV1_3 = (version >= Version::V1_3 ? 1 : 0);
EXPECT_CALL(*mockDevice, getCapabilities_1_3(_)).Times(numCallsForAtLeastV1_3);
const int numCallsForAtLeastV1_2 = (version >= Version::V1_2 ? 1 : 0);
EXPECT_CALL(*mockDevice, getVersionString(_)).Times(numCallsForAtLeastV1_2);
EXPECT_CALL(*mockDevice, getType(_)).Times(numCallsForAtLeastV1_2);
EXPECT_CALL(*mockDevice, getSupportedExtensions(_)).Times(numCallsForAtLeastV1_2);
EXPECT_CALL(*mockDevice, getNumberOfCacheFilesNeeded(_)).Times(numCallsForAtLeastV1_2);
}
std::shared_ptr<VersionedIDevice> makeVersionedIDeviceFrom(const sp<MockDevice>& mockDevice,
MockDeviceFactory* mockDeviceFactory,
Version version) {
setupInitializationExpectations(mockDevice, version);
const auto device = adaptAs(mockDevice, version);
ON_CALL(*mockDeviceFactory, Call(_)).WillByDefault(testing::Return(device));
EXPECT_CALL(*mockDeviceFactory, Call(/*blocking=*/true)).Times(testing::AtLeast(1));
const DeviceFactory makeDevice = mockDeviceFactory->AsStdFunction();
return VersionedIDevice::create("MockDevice", makeDevice);
}
std::shared_ptr<VersionedIDevice> makeVersionedIDeviceSuccessfulInitializationFrom(
const sp<MockDevice>& device, MockDeviceFactory* mockDeviceFactory, Version version) {
setupSuccessfulInitializationExpectations(device, version);
return makeVersionedIDeviceFrom(device, mockDeviceFactory, version);
}
std::function<hardware::Status()> makeTransportFailure(status_t status) {
return [status] { return hardware::Status::fromStatusT(status); };
}
const auto makeGeneralTransportFailure = makeTransportFailure(NO_MEMORY);
const auto makeDeadObjectFailure = makeTransportFailure(DEAD_OBJECT);
class VersionedIDeviceTest : public testing::Test {
protected:
const sp<MockDevice> kMockDevice = MockDevice::create();
const std::unique_ptr<MockDeviceFactory> kMockMakeDevice =
std::make_unique<MockDeviceFactory>();
};
class VersionedIDeviceInitializationTest : public VersionedIDeviceTest {};
template <Version version>
class VersionedIDeviceInitializedTest : public VersionedIDeviceTest {
protected:
void SetUp() override {
VersionedIDeviceTest::SetUp();
ASSERT_NE(nullptr, kDevice.get());
}
const std::shared_ptr<VersionedIDevice> kDevice =
makeVersionedIDeviceSuccessfulInitializationFrom(kMockDevice, kMockMakeDevice.get(),
version);
};
class VersionedIDeviceV1_0Test : public VersionedIDeviceInitializedTest<Version::V1_0> {};
class VersionedIDeviceV1_1Test : public VersionedIDeviceInitializedTest<Version::V1_1> {};
class VersionedIDeviceV1_2Test : public VersionedIDeviceInitializedTest<Version::V1_2> {};
class VersionedIDeviceV1_3Test : public VersionedIDeviceInitializedTest<Version::V1_3> {};
class VersionedIDeviceMockTest : public VersionedIDeviceInitializedTest<Version::MOCK> {};
// Simulate initialization/link error
TEST_F(VersionedIDeviceInitializationTest, creationFailure) {
// setup failure
EXPECT_CALL(*kMockMakeDevice, Call(_)).Times(1).WillOnce(testing::Return(nullptr));
const DeviceFactory makeDevice = kMockMakeDevice->AsStdFunction();
// run test
const auto device = VersionedIDevice::create("MockDevice", makeDevice);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, linkToDeathTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, linkToDeathRet())
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
EXPECT_CALL(*kMockMakeDevice, Call(_)).Times(1).WillOnce(testing::Return(kMockDevice));
const DeviceFactory makeDevice = kMockMakeDevice->AsStdFunction();
// run test
const auto device = VersionedIDevice::create("MockDevice", makeDevice);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, linkToDeathReturnError) {
// setup failure
const auto ret = []() -> Return<bool> { return false; };
EXPECT_CALL(*kMockMakeDevice, Call(_)).Times(1).WillOnce(testing::Return(kMockDevice));
EXPECT_CALL(*kMockDevice, linkToDeathRet()).Times(1).WillOnce(InvokeWithoutArgs(ret));
const DeviceFactory makeDevice = kMockMakeDevice->AsStdFunction();
// run test
const auto device = VersionedIDevice::create("MockDevice", makeDevice);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getCapabilitiesFailure) {
// setup failure
const auto ret = makeCallbackReturn(V1_0::ErrorStatus::GENERAL_FAILURE, V1_0::Capabilities{});
EXPECT_CALL(*kMockDevice, getCapabilities(_)).Times(1).WillOnce(Invoke(ret));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_0);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getCapabilities_1_1Failure) {
// setup failure
const auto ret = makeCallbackReturn(V1_0::ErrorStatus::GENERAL_FAILURE, V1_1::Capabilities{});
EXPECT_CALL(*kMockDevice, getCapabilities_1_1(_)).Times(1).WillOnce(Invoke(ret));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_1);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getCapabilities_1_2Failure) {
// setup failure
const auto ret = makeCallbackReturn(V1_0::ErrorStatus::GENERAL_FAILURE, V1_2::Capabilities{});
EXPECT_CALL(*kMockDevice, getCapabilities_1_2(_)).Times(1).WillOnce(Invoke(ret));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_2);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getCapabilities_1_3Failure) {
// setup failure
const auto ret = makeCallbackReturn(V1_3::ErrorStatus::GENERAL_FAILURE, V1_3::Capabilities{});
EXPECT_CALL(*kMockDevice, getCapabilities_1_3(_)).Times(1).WillOnce(Invoke(ret));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_3);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getVersionStringFailure) {
// setup failure
const auto ret = makeCallbackReturn(V1_0::ErrorStatus::GENERAL_FAILURE, "");
EXPECT_CALL(*kMockDevice, getVersionString(_)).Times(1).WillOnce(Invoke(ret));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_2);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getTypeFailure) {
// setup failure
const auto ret = makeCallbackReturn(V1_0::ErrorStatus::GENERAL_FAILURE, DeviceType::OTHER);
EXPECT_CALL(*kMockDevice, getType(_)).Times(1).WillOnce(Invoke(ret));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_2);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getSupportedExtensionsFailure) {
// setup failure
const auto ret = makeCallbackReturn(V1_0::ErrorStatus::GENERAL_FAILURE, hidl_vec<Extension>{});
EXPECT_CALL(*kMockDevice, getSupportedExtensions(_)).Times(1).WillOnce(Invoke(ret));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_2);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getNumberOfCacheFilesNeededFailure) {
// setup failure
const auto ret = makeCallbackReturn(V1_0::ErrorStatus::GENERAL_FAILURE, kMaxNumberOfCacheFiles,
kMaxNumberOfCacheFiles);
EXPECT_CALL(*kMockDevice, getNumberOfCacheFilesNeeded(_)).Times(1).WillOnce(Invoke(ret));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_2);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, dataCacheFilesExceedsSpecifiedMax) {
// setup failure
const auto ret = makeCallbackReturn(V1_0::ErrorStatus::NONE, kMaxNumberOfCacheFiles + 1,
kMaxNumberOfCacheFiles);
EXPECT_CALL(*kMockDevice, getNumberOfCacheFilesNeeded(_)).Times(1).WillOnce(Invoke(ret));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_2);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, modelCacheFilesExceedsSpecifiedMax) {
// setup failure
const auto ret = makeCallbackReturn(V1_0::ErrorStatus::NONE, kMaxNumberOfCacheFiles,
kMaxNumberOfCacheFiles + 1);
EXPECT_CALL(*kMockDevice, getNumberOfCacheFilesNeeded(_)).Times(1).WillOnce(Invoke(ret));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_2);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getCapabilitiesTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, getCapabilities(_))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_0);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getCapabilities_1_1TransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, getCapabilities_1_1(_))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_1);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getCapabilities_1_2TransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, getCapabilities_1_2(_))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_2);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getCapabilities_1_3TransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, getCapabilities_1_3(_))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_3);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getVersionStringTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, getVersionString(_))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_2);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getTypeTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, getType(_))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_2);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getSupportedExtensionsTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, getSupportedExtensions(_))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_2);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
TEST_F(VersionedIDeviceInitializationTest, getNumberOfCacheFilesNeededTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, getNumberOfCacheFilesNeeded(_))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto device = makeVersionedIDeviceFrom(kMockDevice, kMockMakeDevice.get(), Version::V1_2);
// verify failure
EXPECT_EQ(nullptr, device.get());
}
// Ensure device has cached metadata
TEST_F(VersionedIDeviceV1_0Test, getCapabilities) {
// run test
const auto capabilities = kDevice->getCapabilities();
const auto cached = kDevice->getCapabilities();
// verify success
EXPECT_EQ(PerformanceInfo{}, capabilities.relaxedFloat32toFloat16PerformanceScalar);
EXPECT_EQ(PerformanceInfo{}, capabilities.relaxedFloat32toFloat16PerformanceTensor);
EXPECT_LT(0u, capabilities.operandPerformance.size());
EXPECT_EQ(cached, capabilities);
}
TEST_F(VersionedIDeviceV1_1Test, getCapabilities) {
// run test
const auto capabilities = kDevice->getCapabilities();
const auto cached = kDevice->getCapabilities();
// verify success
EXPECT_EQ(PerformanceInfo{}, capabilities.relaxedFloat32toFloat16PerformanceScalar);
EXPECT_EQ(PerformanceInfo{}, capabilities.relaxedFloat32toFloat16PerformanceTensor);
EXPECT_LT(0u, capabilities.operandPerformance.size());
EXPECT_EQ(cached, capabilities);
}
TEST_F(VersionedIDeviceV1_2Test, getCapabilities) {
// run test
const auto capabilities = kDevice->getCapabilities();
const auto cached = kDevice->getCapabilities();
// verify success
EXPECT_EQ(PerformanceInfo{}, capabilities.relaxedFloat32toFloat16PerformanceScalar);
EXPECT_EQ(PerformanceInfo{}, capabilities.relaxedFloat32toFloat16PerformanceTensor);
EXPECT_EQ(0u, capabilities.operandPerformance.size());
EXPECT_EQ(cached, capabilities);
}
TEST_F(VersionedIDeviceV1_3Test, getCapabilities) {
// run test
const auto capabilities = kDevice->getCapabilities();
const auto cached = kDevice->getCapabilities();
// verify success
EXPECT_EQ(PerformanceInfo{}, capabilities.relaxedFloat32toFloat16PerformanceScalar);
EXPECT_EQ(PerformanceInfo{}, capabilities.relaxedFloat32toFloat16PerformanceTensor);
EXPECT_EQ(0u, capabilities.operandPerformance.size());
EXPECT_EQ(cached, capabilities);
}
TEST_F(VersionedIDeviceV1_0Test, getVersionString) {
// run test
const auto versionString = kDevice->getVersionString();
const auto cached = kDevice->getVersionString();
// verify success
EXPECT_EQ("UNKNOWN", versionString);
EXPECT_EQ(cached, versionString);
}
TEST_F(VersionedIDeviceV1_1Test, getVersionString) {
// run test
const auto versionString = kDevice->getVersionString();
const auto cached = kDevice->getVersionString();
// verify success
EXPECT_EQ("UNKNOWN", versionString);
EXPECT_EQ(cached, versionString);
}
TEST_F(VersionedIDeviceV1_2Test, getVersionString) {
// run test
const auto versionString = kDevice->getVersionString();
const auto cached = kDevice->getVersionString();
// verify success
EXPECT_EQ("Google-MockV1", versionString);
EXPECT_EQ(cached, versionString);
}
TEST_F(VersionedIDeviceV1_3Test, getVersionString) {
// run test
const auto versionString = kDevice->getVersionString();
const auto cached = kDevice->getVersionString();
// verify success
EXPECT_EQ("Google-MockV1", versionString);
EXPECT_EQ(cached, versionString);
}
TEST_F(VersionedIDeviceV1_0Test, getType) {
// run test
const auto type = kDevice->getType();
const auto cached = kDevice->getType();
// verify success
EXPECT_EQ(ANEURALNETWORKS_DEVICE_UNKNOWN, type);
EXPECT_EQ(cached, type);
}
TEST_F(VersionedIDeviceV1_1Test, getType) {
// run test
const auto type = kDevice->getType();
const auto cached = kDevice->getType();
// verify success
EXPECT_EQ(ANEURALNETWORKS_DEVICE_UNKNOWN, type);
EXPECT_EQ(cached, type);
}
TEST_F(VersionedIDeviceV1_2Test, getType) {
// run test
const auto type = kDevice->getType();
const auto cached = kDevice->getType();
// verify success
EXPECT_EQ(ANEURALNETWORKS_DEVICE_OTHER, type);
EXPECT_EQ(cached, type);
}
TEST_F(VersionedIDeviceV1_3Test, getType) {
// run test
const auto type = kDevice->getType();
const auto cached = kDevice->getType();
// verify success
EXPECT_EQ(ANEURALNETWORKS_DEVICE_OTHER, type);
EXPECT_EQ(cached, type);
}
TEST_F(VersionedIDeviceV1_0Test, getSupportedExtensions) {
// run test
const auto supportedExtensions = kDevice->getSupportedExtensions();
const auto cached = kDevice->getSupportedExtensions();
// verify success
EXPECT_EQ(0u, supportedExtensions.size());
EXPECT_EQ(cached, supportedExtensions);
}
TEST_F(VersionedIDeviceV1_1Test, getSupportedExtensions) {
// run test
const auto supportedExtensions = kDevice->getSupportedExtensions();
const auto cached = kDevice->getSupportedExtensions();
// verify success
EXPECT_EQ(0u, supportedExtensions.size());
EXPECT_EQ(cached, supportedExtensions);
}
TEST_F(VersionedIDeviceV1_2Test, getSupportedExtensions) {
// run test
const auto supportedExtensions = kDevice->getSupportedExtensions();
const auto cached = kDevice->getSupportedExtensions();
// verify success
EXPECT_EQ(0u, supportedExtensions.size());
EXPECT_EQ(cached, supportedExtensions);
}
TEST_F(VersionedIDeviceV1_3Test, getSupportedExtensions) {
// run test
const auto supportedExtensions = kDevice->getSupportedExtensions();
const auto cached = kDevice->getSupportedExtensions();
// verify success
EXPECT_EQ(0u, supportedExtensions.size());
EXPECT_EQ(cached, supportedExtensions);
}
TEST_F(VersionedIDeviceV1_0Test, getNumberOfCacheFilesNeeded) {
// run test
const auto [dataCacheFilesNeeded, modelCacheFilesNeeded] =
kDevice->getNumberOfCacheFilesNeeded();
const auto [cachedDataCacheFilesNeeded, cachedModelCacheFilesNeeded] =
kDevice->getNumberOfCacheFilesNeeded();
// verify success
EXPECT_EQ(kNoCacheFilesNeeded, dataCacheFilesNeeded);
EXPECT_EQ(kNoCacheFilesNeeded, modelCacheFilesNeeded);
EXPECT_EQ(cachedDataCacheFilesNeeded, dataCacheFilesNeeded);
EXPECT_EQ(cachedModelCacheFilesNeeded, modelCacheFilesNeeded);
}
TEST_F(VersionedIDeviceV1_1Test, getNumberOfCacheFilesNeeded) {
// run test
const auto [dataCacheFilesNeeded, modelCacheFilesNeeded] =
kDevice->getNumberOfCacheFilesNeeded();
const auto [cachedDataCacheFilesNeeded, cachedModelCacheFilesNeeded] =
kDevice->getNumberOfCacheFilesNeeded();
// verify success
EXPECT_EQ(kNoCacheFilesNeeded, dataCacheFilesNeeded);
EXPECT_EQ(kNoCacheFilesNeeded, modelCacheFilesNeeded);
EXPECT_EQ(cachedDataCacheFilesNeeded, dataCacheFilesNeeded);
EXPECT_EQ(cachedModelCacheFilesNeeded, modelCacheFilesNeeded);
}
TEST_F(VersionedIDeviceV1_2Test, getNumberOfCacheFilesNeeded) {
// run test
const auto [dataCacheFilesNeeded, modelCacheFilesNeeded] =
kDevice->getNumberOfCacheFilesNeeded();
const auto [cachedDataCacheFilesNeeded, cachedModelCacheFilesNeeded] =
kDevice->getNumberOfCacheFilesNeeded();
// verify success
EXPECT_EQ(kMaxNumberOfCacheFiles, dataCacheFilesNeeded);
EXPECT_EQ(kMaxNumberOfCacheFiles, modelCacheFilesNeeded);
EXPECT_EQ(cachedDataCacheFilesNeeded, dataCacheFilesNeeded);
EXPECT_EQ(cachedModelCacheFilesNeeded, modelCacheFilesNeeded);
}
TEST_F(VersionedIDeviceV1_3Test, getNumberOfCacheFilesNeeded) {
// run test
const auto [dataCacheFilesNeeded, modelCacheFilesNeeded] =
kDevice->getNumberOfCacheFilesNeeded();
const auto [cachedDataCacheFilesNeeded, cachedModelCacheFilesNeeded] =
kDevice->getNumberOfCacheFilesNeeded();
// verify success
EXPECT_EQ(kMaxNumberOfCacheFiles, dataCacheFilesNeeded);
EXPECT_EQ(kMaxNumberOfCacheFiles, modelCacheFilesNeeded);
EXPECT_EQ(cachedDataCacheFilesNeeded, dataCacheFilesNeeded);
EXPECT_EQ(cachedModelCacheFilesNeeded, modelCacheFilesNeeded);
}
TEST_F(VersionedIDeviceV1_0Test, getFeatureLevel) {
// run test
const auto featureLevel = kDevice->getFeatureLevel();
const auto cached = kDevice->getFeatureLevel();
// verify success
constexpr int64_t expectedFeatureLevel = __ANDROID_API_O_MR1__;
EXPECT_EQ(expectedFeatureLevel, featureLevel);
EXPECT_EQ(cached, featureLevel);
}
TEST_F(VersionedIDeviceV1_1Test, getFeatureLevel) {
// run test
const auto featureLevel = kDevice->getFeatureLevel();
const auto cached = kDevice->getFeatureLevel();
// verify success
constexpr int64_t expectedFeatureLevel = __ANDROID_API_P__;
EXPECT_EQ(expectedFeatureLevel, featureLevel);
EXPECT_EQ(cached, featureLevel);
}
TEST_F(VersionedIDeviceV1_2Test, getFeatureLevel) {
// run test
const auto featureLevel = kDevice->getFeatureLevel();
const auto cached = kDevice->getFeatureLevel();
// verify success
constexpr int64_t expectedFeatureLevel = __ANDROID_API_Q__;
EXPECT_EQ(expectedFeatureLevel, featureLevel);
EXPECT_EQ(cached, featureLevel);
}
TEST_F(VersionedIDeviceV1_3Test, getFeatureLevel) {
// run test
const auto featureLevel = kDevice->getFeatureLevel();
const auto cached = kDevice->getFeatureLevel();
// verify success
constexpr int64_t expectedFeatureLevel = __ANDROID_API_R__;
EXPECT_EQ(expectedFeatureLevel, featureLevel);
EXPECT_EQ(cached, featureLevel);
}
// Simulate successful test
TEST_F(VersionedIDeviceV1_0Test, getSupportedOperations) {
// setup call
const auto ret = [](const auto& /*model*/, const auto cb) {
cb(V1_0::ErrorStatus::NONE, {});
return Void();
};
EXPECT_CALL(*kMockDevice, getSupportedOperations(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto metaModel = MetaModel({}, /*strictSlicing=*/true);
const auto [resultCode, supportedOperations] = kDevice->getSupportedOperations(metaModel);
// verify success
EXPECT_EQ(V1_3::ErrorStatus::NONE, resultCode);
EXPECT_EQ(0u, supportedOperations.size());
}
TEST_F(VersionedIDeviceV1_1Test, getSupportedOperations) {
// setup call
const auto ret = [](const auto& /*model*/, const auto cb) {
cb(V1_0::ErrorStatus::NONE, {});
return Void();
};
EXPECT_CALL(*kMockDevice, getSupportedOperations_1_1(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto metaModel = MetaModel({}, /*strictSlicing=*/true);
const auto [resultCode, supportedOperations] = kDevice->getSupportedOperations(metaModel);
// verify success
EXPECT_EQ(V1_3::ErrorStatus::NONE, resultCode);
EXPECT_EQ(0u, supportedOperations.size());
}
TEST_F(VersionedIDeviceV1_2Test, getSupportedOperations) {
// setup call
const auto ret = [](const auto& /*model*/, const auto cb) {
cb(V1_0::ErrorStatus::NONE, {});
return Void();
};
EXPECT_CALL(*kMockDevice, getSupportedOperations_1_2(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto metaModel = MetaModel({}, /*strictSlicing=*/true);
const auto [resultCode, supportedOperations] = kDevice->getSupportedOperations(metaModel);
// verify success
EXPECT_EQ(V1_3::ErrorStatus::NONE, resultCode);
EXPECT_EQ(0u, supportedOperations.size());
}
TEST_F(VersionedIDeviceV1_3Test, getSupportedOperations) {
// setup call
const auto ret = [](const auto& /*model*/, const auto cb) {
cb(V1_3::ErrorStatus::NONE, {});
return Void();
};
EXPECT_CALL(*kMockDevice, getSupportedOperations_1_3(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto metaModel = MetaModel({}, /*strictSlicing=*/true);
const auto [resultCode, supportedOperations] = kDevice->getSupportedOperations(metaModel);
// verify success
EXPECT_EQ(V1_3::ErrorStatus::NONE, resultCode);
EXPECT_EQ(0u, supportedOperations.size());
}
TEST_F(VersionedIDeviceV1_0Test, prepareModel) {
// setup call
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModelReturn(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE,
mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_NE(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_1Test, prepareModel) {
// setup call
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModel_1_1Return(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE,
mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_1(_, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_NE(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_2Test, prepareModel) {
// setup call
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModel_1_2Return(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE,
mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_2(_, _, _, _, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_NE(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_3Test, prepareModel) {
// setup call
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModel_1_3Return(V1_3::ErrorStatus::NONE, V1_3::ErrorStatus::NONE,
mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_NE(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_0Test, allocate) {
// run test
const auto [status, buffer, token] = kDevice->allocate({}, {}, {}, {});
// verify success
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, status);
EXPECT_EQ(nullptr, buffer.get());
EXPECT_EQ(0u, token);
}
TEST_F(VersionedIDeviceV1_1Test, allocate) {
// run test
const auto [status, buffer, token] = kDevice->allocate({}, {}, {}, {});
// verify success
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, status);
EXPECT_EQ(nullptr, buffer.get());
EXPECT_EQ(0u, token);
}
TEST_F(VersionedIDeviceV1_2Test, allocate) {
// run test
const auto [status, buffer, token] = kDevice->allocate({}, {}, {}, {});
// verify success
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, status);
EXPECT_EQ(nullptr, buffer.get());
EXPECT_EQ(0u, token);
}
TEST_F(VersionedIDeviceV1_3Test, allocate) {
// setup call
const sp<MockBuffer> mockBuffer = new MockBuffer();
constexpr uint32_t mockToken = 1;
const auto ret = [mockBuffer](const BufferDesc& /*desc*/,
const hidl_vec<sp<V1_3::IPreparedModel>>& /*preparedModels*/,
const hidl_vec<BufferRole>& /*inputRoles*/,
const hidl_vec<BufferRole>& /*outputRoles*/,
V1_3::IDevice::allocate_cb cb) -> Return<void> {
cb(V1_3::ErrorStatus::NONE, mockBuffer, mockToken);
return Void();
};
EXPECT_CALL(*kMockDevice, allocate(_, _, _, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [status, buffer, token] = kDevice->allocate({}, {}, {}, {});
// verify success
EXPECT_EQ(V1_3::ErrorStatus::NONE, status);
EXPECT_NE(nullptr, buffer.get());
EXPECT_NE(0u, token);
}
TEST_F(VersionedIDeviceMockTest, wait) {
// setup call
const auto ret = []() -> Return<void> { return {}; };
EXPECT_CALL(*kMockDevice, ping()).Times(1).WillOnce(Invoke(ret));
// run test
const auto resultCode = kDevice->wait();
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
}
// Simulate general failure
TEST_F(VersionedIDeviceV1_0Test, getSupportedOperationsFailure) {
// setup failure
const auto ret = [](const auto& /*model*/, const auto cb) {
cb(V1_0::ErrorStatus::GENERAL_FAILURE, {});
return Void();
};
EXPECT_CALL(*kMockDevice, getSupportedOperations(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto metaModel = MetaModel({}, /*strictSlicing=*/true);
const auto [resultCode, supportedOperations] = kDevice->getSupportedOperations(metaModel);
// verify failure
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, resultCode);
EXPECT_EQ(0u, supportedOperations.size());
}
TEST_F(VersionedIDeviceV1_1Test, getSupportedOperationsFailure) {
// setup failure
const auto ret = [](const auto& /*model*/, const auto cb) {
cb(V1_0::ErrorStatus::GENERAL_FAILURE, {});
return Void();
};
EXPECT_CALL(*kMockDevice, getSupportedOperations_1_1(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto metaModel = MetaModel({}, /*strictSlicing=*/true);
const auto [resultCode, supportedOperations] = kDevice->getSupportedOperations(metaModel);
// verify failure
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, resultCode);
EXPECT_EQ(0u, supportedOperations.size());
}
TEST_F(VersionedIDeviceV1_2Test, getSupportedOperationsFailure) {
// setup failure
const auto ret = [](const auto& /*model*/, const auto cb) {
cb(V1_0::ErrorStatus::GENERAL_FAILURE, {});
return Void();
};
EXPECT_CALL(*kMockDevice, getSupportedOperations_1_2(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto metaModel = MetaModel({}, /*strictSlicing=*/true);
const auto [resultCode, supportedOperations] = kDevice->getSupportedOperations(metaModel);
// verify failure
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, resultCode);
EXPECT_EQ(0u, supportedOperations.size());
}
TEST_F(VersionedIDeviceV1_3Test, getSupportedOperationsFailure) {
// setup failure
const auto ret = [](const auto& /*model*/, const auto cb) {
cb(V1_3::ErrorStatus::GENERAL_FAILURE, {});
return Void();
};
EXPECT_CALL(*kMockDevice, getSupportedOperations_1_3(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto metaModel = MetaModel({}, /*strictSlicing=*/true);
const auto [resultCode, supportedOperations] = kDevice->getSupportedOperations(metaModel);
// verify failure
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, resultCode);
EXPECT_EQ(0u, supportedOperations.size());
}
TEST_F(VersionedIDeviceV1_0Test, prepareModelLaunchFailure) {
// setup failure
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModelReturn(V1_0::ErrorStatus::GENERAL_FAILURE,
V1_0::ErrorStatus::NONE, mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_1Test, prepareModelLaunchFailure) {
// setup failure
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModel_1_1Return(V1_0::ErrorStatus::GENERAL_FAILURE,
V1_0::ErrorStatus::NONE, mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_1(_, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_2Test, prepareModelLaunchFailure) {
// setup failure
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModel_1_2Return(V1_0::ErrorStatus::GENERAL_FAILURE,
V1_0::ErrorStatus::NONE, mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_2(_, _, _, _, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_3Test, prepareModelLaunchFailure) {
// setup failure
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModel_1_3Return(V1_3::ErrorStatus::GENERAL_FAILURE,
V1_3::ErrorStatus::NONE, mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_0Test, prepareModelReturnFailure) {
// setup failure
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModelReturn(V1_0::ErrorStatus::NONE,
V1_0::ErrorStatus::GENERAL_FAILURE, mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_1Test, prepareModelReturnFailure) {
// setup failure
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModel_1_1Return(
V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::GENERAL_FAILURE, mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_1(_, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_2Test, prepareModelReturnFailure) {
// setup failure
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModel_1_2Return(
V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::GENERAL_FAILURE, mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_2(_, _, _, _, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_3Test, prepareModelReturnFailure) {
// setup failure
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModel_1_3Return(
V1_3::ErrorStatus::NONE, V1_3::ErrorStatus::GENERAL_FAILURE, mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_0Test, prepareModelNullptrError) {
// setup failure
const sp<MockPreparedModel> mockPreparedModel = nullptr;
const auto ret = makePreparedModelReturn(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE,
mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_1Test, prepareModelNullptrError) {
// setup failure
const sp<MockPreparedModel> mockPreparedModel = nullptr;
const auto ret = makePreparedModel_1_1Return(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE,
mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_1(_, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_2Test, prepareModelNullptrError) {
// setup failure
const sp<MockPreparedModel> mockPreparedModel = nullptr;
const auto ret = makePreparedModel_1_2Return(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE,
mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_2(_, _, _, _, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_3Test, prepareModelNullptrError) {
// setup failure
const sp<MockPreparedModel> mockPreparedModel = nullptr;
const auto ret = makePreparedModel_1_3Return(V1_3::ErrorStatus::NONE, V1_3::ErrorStatus::NONE,
mockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_3Test, allocateFailure) {
// setup failure
const auto ret = [](const BufferDesc& /*desc*/,
const hidl_vec<sp<V1_3::IPreparedModel>>& /*preparedModels*/,
const hidl_vec<BufferRole>& /*inputRoles*/,
const hidl_vec<BufferRole>& /*outputRoles*/,
V1_3::IDevice::allocate_cb cb) -> Return<void> {
cb(V1_3::ErrorStatus::GENERAL_FAILURE, nullptr, 0);
return Void();
};
EXPECT_CALL(*kMockDevice, allocate(_, _, _, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [status, buffer, token] = kDevice->allocate({}, {}, {}, {});
// verify failure
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, status);
EXPECT_EQ(nullptr, buffer.get());
EXPECT_EQ(0u, token);
}
// Simulate transport failure
TEST_F(VersionedIDeviceV1_0Test, getSupportedOperationsTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, getSupportedOperations(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto metaModel = MetaModel({}, /*strictSlicing=*/true);
const auto [resultCode, supportedOperations] = kDevice->getSupportedOperations(metaModel);
// verify failure
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, resultCode);
EXPECT_EQ(0u, supportedOperations.size());
}
TEST_F(VersionedIDeviceV1_1Test, getSupportedOperationsTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, getSupportedOperations_1_1(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto metaModel = MetaModel({}, /*strictSlicing=*/true);
const auto [resultCode, supportedOperations] = kDevice->getSupportedOperations(metaModel);
// verify failure
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, resultCode);
EXPECT_EQ(0u, supportedOperations.size());
}
TEST_F(VersionedIDeviceV1_2Test, getSupportedOperationsTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, getSupportedOperations_1_2(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto metaModel = MetaModel({}, /*strictSlicing=*/true);
const auto [resultCode, supportedOperations] = kDevice->getSupportedOperations(metaModel);
// verify failure
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, resultCode);
EXPECT_EQ(0u, supportedOperations.size());
}
TEST_F(VersionedIDeviceV1_3Test, getSupportedOperationsTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, getSupportedOperations_1_3(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto metaModel = MetaModel({}, /*strictSlicing=*/true);
const auto [resultCode, supportedOperations] = kDevice->getSupportedOperations(metaModel);
// verify failure
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, resultCode);
EXPECT_EQ(0u, supportedOperations.size());
}
TEST_F(VersionedIDeviceV1_0Test, prepareModelTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, prepareModel(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_1Test, prepareModelTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, prepareModel_1_1(_, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_2Test, prepareModelTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, prepareModel_1_2(_, _, _, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_3Test, prepareModelTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceV1_3Test, allocateTransportFailure) {
// setup failure
EXPECT_CALL(*kMockDevice, allocate(_, _, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [status, buffer, token] = kDevice->allocate({}, {}, {}, {});
// verify failure
EXPECT_EQ(V1_3::ErrorStatus::GENERAL_FAILURE, status);
EXPECT_EQ(nullptr, buffer.get());
EXPECT_EQ(0u, token);
}
TEST_F(VersionedIDeviceMockTest, waitTransportFailure) {
// setup call
EXPECT_CALL(*kMockDevice, ping())
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto resultCode = kDevice->wait();
// verify success
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
}
// Simulate service crash
// TODO: enable this test once b/154183300 is fixed.
TEST_F(VersionedIDeviceMockTest, DISABLED_prepareModelRecoverCrash) {
// setup original device calls
EXPECT_CALL(*kMockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeDeadObjectFailure));
EXPECT_CALL(*kMockDevice, ping()).Times(1).WillOnce(InvokeWithoutArgs(makeDeadObjectFailure));
// setup recovery call
const sp<MockDevice> mockRecoveredDevice = MockDevice::create();
EXPECT_CALL(*kMockMakeDevice, Call(/*blocking=*/false))
.Times(1)
.WillOnce(testing::Return(mockRecoveredDevice));
// setup recovered device calls
const sp<MockPreparedModel> mockPreparedModel = MockPreparedModel::create();
const auto ret = makePreparedModel_1_3Return(V1_3::ErrorStatus::NONE, V1_3::ErrorStatus::NONE,
mockPreparedModel);
EXPECT_CALL(*mockRecoveredDevice, linkToDeathRet()).Times(1);
EXPECT_CALL(*mockRecoveredDevice, prepareModel_1_3(_, _, _, _, _, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_NE(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceMockTest, prepareModelFullCrash) {
// setup failure
EXPECT_CALL(*kMockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _))
.Times(1)
.WillRepeatedly(InvokeWithoutArgs(makeDeadObjectFailure));
EXPECT_CALL(*kMockDevice, ping())
.Times(1)
.WillRepeatedly(InvokeWithoutArgs(makeDeadObjectFailure));
EXPECT_CALL(*kMockMakeDevice, Call(/*blocking=*/false))
.Times(1)
.WillOnce(testing::Return(nullptr));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_DEAD_OBJECT, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceMockTest, prepareModelAsyncCrash) {
// setup failure
const auto ret = [this]() -> Return<V1_3::ErrorStatus> {
kMockDevice->simulateCrash();
return V1_3::ErrorStatus::NONE;
};
EXPECT_CALL(*kMockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_DEAD_OBJECT, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIDeviceMockTest, waitCrash) {
// setup failure
EXPECT_CALL(*kMockDevice, ping())
.Times(1)
.WillRepeatedly(InvokeWithoutArgs(makeDeadObjectFailure));
EXPECT_CALL(*kMockMakeDevice, Call(/*blocking=*/true))
.Times(1)
.WillOnce(testing::Return(nullptr));
// run test
const auto resultCode = kDevice->wait();
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
}
TEST_F(VersionedIDeviceMockTest, waitRecoverCrash) {
// setup original device calls
EXPECT_CALL(*kMockDevice, ping()).Times(1).WillOnce(InvokeWithoutArgs(makeDeadObjectFailure));
// setup recovery call
const sp<MockDevice> mockRecoveredDevice = MockDevice::create();
EXPECT_CALL(*kMockMakeDevice, Call(/*blocking=*/true))
.Times(1)
.WillOnce(testing::Return(mockRecoveredDevice));
// setup recovered device calls
const auto ret = []() -> Return<bool> { return true; };
EXPECT_CALL(*mockRecoveredDevice, linkToDeathRet()).Times(1).WillOnce(Invoke(ret));
// run test
const auto resultCode = kDevice->wait();
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
}
TEST_F(VersionedIDeviceMockTest, waitFailedRecoverCrash) {
// setup original device calls
EXPECT_CALL(*kMockDevice, ping()).Times(1).WillOnce(InvokeWithoutArgs(makeDeadObjectFailure));
// setup recovery call
const sp<MockDevice> mockRecoveredDevice = MockDevice::create();
EXPECT_CALL(*kMockMakeDevice, Call(/*blocking=*/true))
.Times(1)
.WillOnce(testing::Return(mockRecoveredDevice));
// setup recovered device calls
EXPECT_CALL(*mockRecoveredDevice, linkToDeathRet())
.Times(1)
.WillOnce(makeGeneralTransportFailure);
// run test
const auto resultCode = kDevice->wait();
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
}
// Harness for VersionedIPreparedModel failures.
class VersionedIPreparedModelInitializationTest : public VersionedIDeviceMockTest {
protected:
const sp<MockPreparedModel> kMockPreparedModel = MockPreparedModel::create();
};
std::shared_ptr<VersionedIPreparedModel> makeVersionedIPreparedModelSuccessfulInitializationFrom(
const sp<MockDevice>& mockDevice, const sp<MockPreparedModel>& mockPreparedModel,
const VersionedIDevice& device) {
const auto retV1_0 = makePreparedModelReturn(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE,
mockPreparedModel);
const auto retV1_1 = makePreparedModel_1_1Return(V1_0::ErrorStatus::NONE,
V1_0::ErrorStatus::NONE, mockPreparedModel);
const auto retV1_2 = makePreparedModel_1_2Return(V1_0::ErrorStatus::NONE,
V1_0::ErrorStatus::NONE, mockPreparedModel);
const auto retV1_3 = makePreparedModel_1_3Return(V1_3::ErrorStatus::NONE,
V1_3::ErrorStatus::NONE, mockPreparedModel);
ON_CALL(*mockDevice, prepareModel(_, _)).WillByDefault(Invoke(retV1_0));
ON_CALL(*mockDevice, prepareModel_1_1(_, _, _)).WillByDefault(Invoke(retV1_1));
ON_CALL(*mockDevice, prepareModel_1_2(_, _, _, _, _, _)).WillByDefault(Invoke(retV1_2));
ON_CALL(*mockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _)).WillByDefault(Invoke(retV1_3));
EXPECT_CALL(*mockDevice, prepareModel(_, _)).Times(testing::AnyNumber());
EXPECT_CALL(*mockDevice, prepareModel_1_1(_, _, _)).Times(testing::AnyNumber());
EXPECT_CALL(*mockDevice, prepareModel_1_2(_, _, _, _, _, _)).Times(testing::AnyNumber());
EXPECT_CALL(*mockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _)).Times(testing::AnyNumber());
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = device.prepareModel(makeModel, {}, {}, {}, {}, {});
CHECK_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
CHECK(preparedModel != nullptr);
return preparedModel;
}
template <Version version>
class VersionedIPreparedModelTest : public VersionedIDeviceInitializedTest<version> {
using Base = VersionedIDeviceInitializedTest<version>;
protected:
void SetUp() override {
VersionedIDeviceInitializedTest<version>::SetUp();
ASSERT_NE(nullptr, kPreparedModel.get());
}
const sp<MockPreparedModel> kMockPreparedModel = MockPreparedModel::create();
const std::shared_ptr<VersionedIPreparedModel> kPreparedModel =
makeVersionedIPreparedModelSuccessfulInitializationFrom(
Base::kMockDevice, kMockPreparedModel, *Base::kDevice);
};
class VersionedIPreparedModelV1_0Test : public VersionedIPreparedModelTest<Version::V1_0> {};
class VersionedIPreparedModelV1_1Test : public VersionedIPreparedModelTest<Version::V1_1> {};
class VersionedIPreparedModelV1_2Test : public VersionedIPreparedModelTest<Version::V1_2> {};
class VersionedIPreparedModelV1_3Test : public VersionedIPreparedModelTest<Version::V1_3> {};
class VersionedIPreparedModelMockTest : public VersionedIPreparedModelTest<Version::MOCK> {};
// Simulate initialization/link error
TEST_F(VersionedIPreparedModelInitializationTest, linkToDeathTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, linkToDeathRet())
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
const auto ret = makePreparedModel_1_3Return(V1_3::ErrorStatus::NONE, V1_3::ErrorStatus::NONE,
kMockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIPreparedModelInitializationTest, linkToDeathDeadObject) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, linkToDeathRet())
.Times(1)
.WillOnce(InvokeWithoutArgs(makeDeadObjectFailure));
const auto ret = makePreparedModel_1_3Return(V1_3::ErrorStatus::NONE, V1_3::ErrorStatus::NONE,
kMockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_DEAD_OBJECT, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
TEST_F(VersionedIPreparedModelInitializationTest, linkToDeathReturnError) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, linkToDeathRet())
.Times(1)
.WillOnce(InvokeWithoutArgs([]() -> Return<bool> { return false; }));
const auto ret = makePreparedModel_1_3Return(V1_3::ErrorStatus::NONE, V1_3::ErrorStatus::NONE,
kMockPreparedModel);
EXPECT_CALL(*kMockDevice, prepareModel_1_3(_, _, _, _, _, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const ModelFactory makeModel = [] { return V1_3::Model{}; };
const auto [resultCode, preparedModel] = kDevice->prepareModel(makeModel, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, preparedModel.get());
}
// Simulate successful test
TEST_F(VersionedIPreparedModelV1_0Test, executeAsync) {
// setup call
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_1Test, executeAsync) {
// setup call
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, executeAsync) {
// setup call
const auto ret =
makeExecute_1_2Return(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE, {}, kNoTiming);
EXPECT_CALL(*kMockPreparedModel, execute_1_2(_, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_3Test, executeAsync) {
// setup call
const auto ret =
makeExecute_1_3Return(V1_3::ErrorStatus::NONE, V1_3::ErrorStatus::NONE, {}, kNoTiming);
EXPECT_CALL(*kMockPreparedModel, execute_1_3(_, _, _, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_0Test, executePreferSync) {
// setup call
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_1Test, executePreferSync) {
// setup call
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, executePreferSync) {
// setup call
const auto ret = makeExecuteSynchronouslyReturn(V1_0::ErrorStatus::NONE, {}, kNoTiming);
EXPECT_CALL(*kMockPreparedModel, executeSynchronously(_, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_3Test, executePreferSync) {
// setup call
const auto ret = makeExecuteSynchronously_1_3Return(V1_3::ErrorStatus::NONE, {}, kNoTiming);
EXPECT_CALL(*kMockPreparedModel, executeSynchronously_1_3(_, _, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_0Test, executeFenced) {
// setup call
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, syncFence, dispatchCallback, timing] =
kPreparedModel->executeFenced({}, {}, {}, {}, {}, {});
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_EQ(nullptr, syncFence.getNativeHandle());
EXPECT_EQ(nullptr, dispatchCallback.get());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_1Test, executeFenced) {
// setup call
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::NONE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, syncFence, dispatchCallback, timing] =
kPreparedModel->executeFenced({}, {}, {}, {}, {}, {});
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_EQ(nullptr, syncFence.getNativeHandle());
EXPECT_EQ(nullptr, dispatchCallback.get());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, executeFenced) {
// setup call
const auto ret = makeExecuteSynchronouslyReturn(V1_0::ErrorStatus::NONE, {}, kNoTiming);
EXPECT_CALL(*kMockPreparedModel, executeSynchronously(_, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, syncFence, dispatchCallback, timing] =
kPreparedModel->executeFenced({}, {}, {}, {}, {}, {});
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_EQ(nullptr, syncFence.getNativeHandle());
EXPECT_EQ(nullptr, dispatchCallback.get());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_3Test, executeFenced) {
// setup call
auto memory = allocateSharedMemory(4);
hidl_handle fakeSyncFence(memory.handle());
const sp<IFencedExecutionCallback> callback = new MockFencedExecutionCallback();
const auto ret = makeExecuteFencedReturn(V1_3::ErrorStatus::NONE, fakeSyncFence, callback);
EXPECT_CALL(*kMockPreparedModel, executeFenced(_, _, _, _, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const auto [resultCode, syncFence, dispatchCallback, timing] =
kPreparedModel->executeFenced({}, {}, {}, {}, {}, {});
// verify success
EXPECT_EQ(ANEURALNETWORKS_NO_ERROR, resultCode);
EXPECT_NE(nullptr, syncFence.getNativeHandle());
EXPECT_NE(nullptr, dispatchCallback.get());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_0Test, configureExecutionBurst) {
// run test
const auto executionBurstController =
kPreparedModel->configureExecutionBurst(/*preferPowerOverLatency=*/false);
// verify success
EXPECT_EQ(nullptr, executionBurstController);
}
TEST_F(VersionedIPreparedModelV1_1Test, configureExecutionBurst) {
// run test
const auto executionBurstController =
kPreparedModel->configureExecutionBurst(/*preferPowerOverLatency=*/false);
// verify success
EXPECT_EQ(nullptr, executionBurstController);
}
TEST_F(VersionedIPreparedModelV1_2Test, configureExecutionBurst) {
// setup call
const sp<MockBurstContext> burstContext = new MockBurstContext();
const auto ret = makeConfigureExecutionBurst(V1_0::ErrorStatus::NONE, burstContext);
EXPECT_CALL(*kMockPreparedModel, configureExecutionBurst(_, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const auto executionBurstController =
kPreparedModel->configureExecutionBurst(/*preferPowerOverLatency=*/false);
// verify success
EXPECT_NE(nullptr, executionBurstController);
}
TEST_F(VersionedIPreparedModelV1_3Test, configureExecutionBurst) {
// setup call
const sp<MockBurstContext> burstContext = new MockBurstContext();
const auto ret = makeConfigureExecutionBurst(V1_0::ErrorStatus::NONE, burstContext);
EXPECT_CALL(*kMockPreparedModel, configureExecutionBurst(_, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const auto executionBurstController =
kPreparedModel->configureExecutionBurst(/*preferPowerOverLatency=*/false);
// verify success
EXPECT_NE(nullptr, executionBurstController);
}
// Simulate general failure
TEST_F(VersionedIPreparedModelV1_0Test, executeAsyncLaunchFailure) {
// setup failure
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::GENERAL_FAILURE, V1_0::ErrorStatus::NONE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_1Test, executeAsyncLaunchFailure) {
// setup failure
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::GENERAL_FAILURE, V1_0::ErrorStatus::NONE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, executeAsyncLaunchFailure) {
// setup failure
const auto ret = makeExecute_1_2Return(V1_0::ErrorStatus::GENERAL_FAILURE,
V1_0::ErrorStatus::NONE, {}, kNoTiming);
EXPECT_CALL(*kMockPreparedModel, execute_1_2(_, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_3Test, executeAsyncLaunchFailure) {
// setup failure
const auto ret = makeExecute_1_3Return(V1_3::ErrorStatus::GENERAL_FAILURE,
V1_3::ErrorStatus::NONE, {}, kNoTiming);
EXPECT_CALL(*kMockPreparedModel, execute_1_3(_, _, _, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_0Test, executeAsyncReturnFailure) {
// setup failure
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::GENERAL_FAILURE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_1Test, executeAsyncReturnFailure) {
// setup failure
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::NONE, V1_0::ErrorStatus::GENERAL_FAILURE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, executeAsyncReturnFailure) {
// setup failure
const auto ret = makeExecute_1_2Return(V1_0::ErrorStatus::NONE,
V1_0::ErrorStatus::GENERAL_FAILURE, {}, kNoTiming);
EXPECT_CALL(*kMockPreparedModel, execute_1_2(_, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_3Test, executeAsyncReturnFailure) {
// setup failure
const auto ret = makeExecute_1_3Return(V1_3::ErrorStatus::NONE,
V1_3::ErrorStatus::GENERAL_FAILURE, {}, kNoTiming);
EXPECT_CALL(*kMockPreparedModel, execute_1_3(_, _, _, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_0Test, executePreferSyncFailure) {
// setup failure
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::GENERAL_FAILURE,
V1_0::ErrorStatus::GENERAL_FAILURE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_1Test, executePreferSyncFailure) {
// setup failure
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::GENERAL_FAILURE,
V1_0::ErrorStatus::GENERAL_FAILURE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, executePreferSyncFailure) {
// setup failure
const auto ret =
makeExecuteSynchronouslyReturn(V1_0::ErrorStatus::GENERAL_FAILURE, {}, kNoTiming);
EXPECT_CALL(*kMockPreparedModel, executeSynchronously(_, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_3Test, executePreferSyncFailure) {
// setup failure
const auto ret =
makeExecuteSynchronously_1_3Return(V1_3::ErrorStatus::GENERAL_FAILURE, {}, kNoTiming);
EXPECT_CALL(*kMockPreparedModel, executeSynchronously_1_3(_, _, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_0Test, executeFencedFailure) {
// setup failure
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::GENERAL_FAILURE,
V1_0::ErrorStatus::GENERAL_FAILURE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, syncFence, dispatchCallback, timing] =
kPreparedModel->executeFenced({}, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, syncFence.getNativeHandle());
EXPECT_EQ(nullptr, dispatchCallback.get());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_1Test, executeFencedFailure) {
// setup failure
const auto ret = makeExecuteReturn(V1_0::ErrorStatus::GENERAL_FAILURE,
V1_0::ErrorStatus::GENERAL_FAILURE);
EXPECT_CALL(*kMockPreparedModel, execute(_, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, syncFence, dispatchCallback, timing] =
kPreparedModel->executeFenced({}, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, syncFence.getNativeHandle());
EXPECT_EQ(nullptr, dispatchCallback.get());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, executeFencedFailure) {
// setup failure
const auto ret =
makeExecuteSynchronouslyReturn(V1_0::ErrorStatus::GENERAL_FAILURE, {}, kNoTiming);
EXPECT_CALL(*kMockPreparedModel, executeSynchronously(_, _, _)).Times(1).WillOnce(Invoke(ret));
// run test
const auto [resultCode, syncFence, dispatchCallback, timing] =
kPreparedModel->executeFenced({}, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, syncFence.getNativeHandle());
EXPECT_EQ(nullptr, dispatchCallback.get());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_3Test, executeFencedFailure) {
// setup failure
auto memory = allocateSharedMemory(4);
hidl_handle fakeSyncFence(memory.handle());
const sp<IFencedExecutionCallback> callback = new MockFencedExecutionCallback();
const auto ret =
makeExecuteFencedReturn(V1_3::ErrorStatus::GENERAL_FAILURE, fakeSyncFence, callback);
EXPECT_CALL(*kMockPreparedModel, executeFenced(_, _, _, _, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const auto [resultCode, syncFence, dispatchCallback, timing] =
kPreparedModel->executeFenced({}, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, syncFence.getNativeHandle());
EXPECT_EQ(nullptr, dispatchCallback.get());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, configureExecutionBurstFailure) {
// setup failure
const sp<MockBurstContext> burstContext = new MockBurstContext();
const auto ret = makeConfigureExecutionBurst(V1_0::ErrorStatus::GENERAL_FAILURE, burstContext);
EXPECT_CALL(*kMockPreparedModel, configureExecutionBurst(_, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const auto executionBurstController =
kPreparedModel->configureExecutionBurst(/*preferPowerOverLatency=*/false);
// verify failure
EXPECT_EQ(nullptr, executionBurstController);
}
TEST_F(VersionedIPreparedModelV1_3Test, configureExecutionBurstFailure) {
// setup failure
const sp<MockBurstContext> burstContext = new MockBurstContext();
const auto ret = makeConfigureExecutionBurst(V1_0::ErrorStatus::GENERAL_FAILURE, burstContext);
EXPECT_CALL(*kMockPreparedModel, configureExecutionBurst(_, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const auto executionBurstController =
kPreparedModel->configureExecutionBurst(/*preferPowerOverLatency=*/false);
// verify failure
EXPECT_EQ(nullptr, executionBurstController);
}
TEST_F(VersionedIPreparedModelV1_2Test, configureExecutionBurstNullptrError) {
// setup failure
const auto ret = makeConfigureExecutionBurst(V1_0::ErrorStatus::NONE, nullptr);
EXPECT_CALL(*kMockPreparedModel, configureExecutionBurst(_, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const auto executionBurstController =
kPreparedModel->configureExecutionBurst(/*preferPowerOverLatency=*/false);
// verify failure
EXPECT_EQ(nullptr, executionBurstController);
}
TEST_F(VersionedIPreparedModelV1_3Test, configureExecutionBurstNullptrError) {
// setup failure
const auto ret = makeConfigureExecutionBurst(V1_0::ErrorStatus::NONE, nullptr);
EXPECT_CALL(*kMockPreparedModel, configureExecutionBurst(_, _, _, _))
.Times(1)
.WillOnce(Invoke(ret));
// run test
const auto executionBurstController =
kPreparedModel->configureExecutionBurst(/*preferPowerOverLatency=*/false);
// verify failure
EXPECT_EQ(nullptr, executionBurstController);
}
// Simulate transport failure
TEST_F(VersionedIPreparedModelV1_0Test, executeAsyncTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, execute(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_1Test, executeAsyncTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, execute(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, executeAsyncTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, execute_1_2(_, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_3Test, executeAsyncTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, execute_1_3(_, _, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_0Test, executePreferSyncTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, execute(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_1Test, executePreferSyncTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, execute(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, executePreferSyncTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, executeSynchronously(_, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_3Test, executePreferSyncTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, executeSynchronously_1_3(_, _, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_0Test, executeFencedTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, execute(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [resultCode, syncFence, dispatchCallback, timing] =
kPreparedModel->executeFenced({}, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, syncFence.getNativeHandle());
EXPECT_EQ(nullptr, dispatchCallback.get());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_1Test, executeFencedTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, execute(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [resultCode, syncFence, dispatchCallback, timing] =
kPreparedModel->executeFenced({}, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, syncFence.getNativeHandle());
EXPECT_EQ(nullptr, dispatchCallback.get());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, executeFencedTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, executeSynchronously(_, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [resultCode, syncFence, dispatchCallback, timing] =
kPreparedModel->executeFenced({}, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, syncFence.getNativeHandle());
EXPECT_EQ(nullptr, dispatchCallback.get());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_3Test, executeFencedTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, executeFenced(_, _, _, _, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto [resultCode, syncFence, dispatchCallback, timing] =
kPreparedModel->executeFenced({}, {}, {}, {}, {}, {});
// verify failure
EXPECT_EQ(ANEURALNETWORKS_OP_FAILED, resultCode);
EXPECT_EQ(nullptr, syncFence.getNativeHandle());
EXPECT_EQ(nullptr, dispatchCallback.get());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, configureExecutionBurstTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, configureExecutionBurst(_, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto executionBurstController =
kPreparedModel->configureExecutionBurst(/*preferPowerOverLatency=*/false);
// verify failure
EXPECT_EQ(nullptr, executionBurstController);
}
TEST_F(VersionedIPreparedModelV1_3Test, configureExecutionBurstTransportFailure) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, configureExecutionBurst(_, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeGeneralTransportFailure));
// run test
const auto executionBurstController =
kPreparedModel->configureExecutionBurst(/*preferPowerOverLatency=*/false);
// verify failure
EXPECT_EQ(nullptr, executionBurstController);
}
// Simulate service crash
TEST_F(VersionedIPreparedModelV1_0Test, executeAsyncLaunchCrash) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, execute(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeDeadObjectFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_DEAD_OBJECT, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_1Test, executeAsyncLaunchCrash) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, execute(_, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeDeadObjectFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_DEAD_OBJECT, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, executeAsyncLaunchCrash) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, execute_1_2(_, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeDeadObjectFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_DEAD_OBJECT, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_3Test, executeAsyncLaunchCrash) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, execute_1_3(_, _, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeDeadObjectFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_DEAD_OBJECT, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_2Test, executePreferSyncCrash) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, executeSynchronously(_, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeDeadObjectFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_DEAD_OBJECT, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelV1_3Test, executePreferSyncCrash) {
// setup failure
EXPECT_CALL(*kMockPreparedModel, executeSynchronously_1_3(_, _, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(makeDeadObjectFailure));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/true);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_DEAD_OBJECT, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
TEST_F(VersionedIPreparedModelMockTest, executeAsyncReturnCrash) {
// setup failure
const auto ret = [this]() -> Return<V1_3::ErrorStatus> {
kMockPreparedModel->simulateCrash();
return V1_3::ErrorStatus::NONE;
};
EXPECT_CALL(*kMockPreparedModel, execute_1_3(_, _, _, _, _))
.Times(1)
.WillOnce(InvokeWithoutArgs(ret));
// run test
const auto [resultCode, outputShapes, timing] =
kPreparedModel->execute({}, {}, {}, {}, /*preferSynchronous=*/false);
// verify failure
EXPECT_EQ(ANEURALNETWORKS_DEAD_OBJECT, resultCode);
EXPECT_EQ(0u, outputShapes.size());
EXPECT_EQ(kNoTiming, timing);
}
} // namespace
} // namespace android::nn