2917 lines
113 KiB
C++
2917 lines
113 KiB
C++
/*
|
|
* 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
|