blob: 8f95b96c52b5bb66030efbe5d906e13b8897b852 [file] [log] [blame]
Slava Shklyaevfeb87a92018-09-12 14:52:02 +01001/*
2 * Copyright (C) 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "neuralnetworks_hidl_hal_test"
18
19#include "VtsHalNeuralnetworks.h"
20
Michael Butler62749b92019-08-26 23:55:47 -070021namespace android::hardware::neuralnetworks::V1_2::vts::functional {
Slava Shklyaevfeb87a92018-09-12 14:52:02 +010022
Michael Butler62749b92019-08-26 23:55:47 -070023using V1_0::DeviceStatus;
24using V1_0::ErrorStatus;
David Gross2d47c802019-03-15 17:26:32 -070025using V1_0::PerformanceInfo;
Slava Shklyaevfeb87a92018-09-12 14:52:02 +010026
27// create device test
28TEST_F(NeuralnetworksHidlTest, CreateDevice) {}
29
30// status test
31TEST_F(NeuralnetworksHidlTest, StatusTest) {
Michael Butler13b05162019-08-29 22:17:24 -070032 Return<DeviceStatus> status = kDevice->getStatus();
Slava Shklyaevfeb87a92018-09-12 14:52:02 +010033 ASSERT_TRUE(status.isOk());
34 EXPECT_EQ(DeviceStatus::AVAILABLE, static_cast<DeviceStatus>(status));
35}
36
David Gross2d47c802019-03-15 17:26:32 -070037// initialization
38TEST_F(NeuralnetworksHidlTest, GetCapabilitiesTest) {
39 using OperandPerformance = Capabilities::OperandPerformance;
Michael Butler13b05162019-08-29 22:17:24 -070040 Return<void> ret = kDevice->getCapabilities_1_2([](ErrorStatus status,
41 const Capabilities& capabilities) {
David Gross2d47c802019-03-15 17:26:32 -070042 EXPECT_EQ(ErrorStatus::NONE, status);
43
44 auto isPositive = [](const PerformanceInfo& perf) {
45 return perf.execTime > 0.0f && perf.powerUsage > 0.0f;
46 };
47
48 EXPECT_TRUE(isPositive(capabilities.relaxedFloat32toFloat16PerformanceScalar));
49 EXPECT_TRUE(isPositive(capabilities.relaxedFloat32toFloat16PerformanceTensor));
50 const auto& opPerf = capabilities.operandPerformance;
51 EXPECT_TRUE(std::all_of(
52 opPerf.begin(), opPerf.end(),
53 [isPositive](const OperandPerformance& a) { return isPositive(a.info); }));
54 EXPECT_TRUE(std::is_sorted(opPerf.begin(), opPerf.end(),
55 [](const OperandPerformance& a, const OperandPerformance& b) {
56 return a.type < b.type;
57 }));
58 });
59 EXPECT_TRUE(ret.isOk());
60}
61
Miao Wang618028b2018-09-20 11:35:42 -070062// device version test
63TEST_F(NeuralnetworksHidlTest, GetDeviceVersionStringTest) {
Michael Butler13b05162019-08-29 22:17:24 -070064 Return<void> ret =
65 kDevice->getVersionString([](ErrorStatus status, const hidl_string& version) {
66 EXPECT_EQ(ErrorStatus::NONE, status);
67 EXPECT_LT(0, version.size());
68 });
Miao Wang618028b2018-09-20 11:35:42 -070069 EXPECT_TRUE(ret.isOk());
70}
Miao Wang7176fe72018-09-20 13:30:31 -070071
72// device type test
73TEST_F(NeuralnetworksHidlTest, GetDeviceTypeTest) {
Michael Butler13b05162019-08-29 22:17:24 -070074 Return<void> ret = kDevice->getType([](ErrorStatus status, DeviceType type) {
Miao Wang7176fe72018-09-20 13:30:31 -070075 EXPECT_EQ(ErrorStatus::NONE, status);
76 EXPECT_TRUE(type == DeviceType::OTHER || type == DeviceType::CPU ||
77 type == DeviceType::GPU || type == DeviceType::ACCELERATOR);
78 });
79 EXPECT_TRUE(ret.isOk());
80}
Slava Shklyaevc9ff0992018-11-20 15:29:01 +000081
82// device supported extensions test
83TEST_F(NeuralnetworksHidlTest, GetDeviceSupportedExtensionsTest) {
Michael Butler13b05162019-08-29 22:17:24 -070084 Return<void> ret = kDevice->getSupportedExtensions(
Slava Shklyaevc9ff0992018-11-20 15:29:01 +000085 [](ErrorStatus status, const hidl_vec<Extension>& extensions) {
86 EXPECT_EQ(ErrorStatus::NONE, status);
87 for (auto& extension : extensions) {
88 std::string extensionName = extension.name;
89 EXPECT_FALSE(extensionName.empty());
Slava Shklyaev1d2cd432019-02-25 18:23:03 +000090 for (char c : extensionName) {
91 EXPECT_TRUE(('a' <= c && c <= 'z') || ('0' <= c && c <= '9') || c == '_' ||
92 c == '.')
93 << "Extension name contains an illegal character: " << c;
94 }
95 EXPECT_NE(extensionName.find('.'), std::string::npos)
Slava Shklyaevc9ff0992018-11-20 15:29:01 +000096 << "Extension name must start with the reverse domain name of the "
97 "vendor";
98 }
99 });
100 EXPECT_TRUE(ret.isOk());
101}
102
Xusong Wanged0822b2019-02-25 16:58:58 -0800103// getNumberOfCacheFilesNeeded test
104TEST_F(NeuralnetworksHidlTest, getNumberOfCacheFilesNeeded) {
Michael Butler13b05162019-08-29 22:17:24 -0700105 Return<void> ret = kDevice->getNumberOfCacheFilesNeeded(
Xusong Wanged0822b2019-02-25 16:58:58 -0800106 [](ErrorStatus status, uint32_t numModelCache, uint32_t numDataCache) {
107 EXPECT_EQ(ErrorStatus::NONE, status);
108 EXPECT_LE(numModelCache,
109 static_cast<uint32_t>(Constant::MAX_NUMBER_OF_CACHE_FILES));
110 EXPECT_LE(numDataCache, static_cast<uint32_t>(Constant::MAX_NUMBER_OF_CACHE_FILES));
111 });
Xusong Wang96e68dc2019-01-18 17:28:26 -0800112 EXPECT_TRUE(ret.isOk());
113}
Michael Butler62749b92019-08-26 23:55:47 -0700114} // namespace android::hardware::neuralnetworks::V1_2::vts::functional