1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <gmock/gmock.h>
18
19 #include "nncompiled_cache.h"
20 #include "device.h"
21 #include "nnbackend.h"
22 #include "backend_manager.h"
23 #include "neural_network_runtime/neural_network_runtime_type.h"
24 #include "utils.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace OHOS::NeuralNetworkRuntime;
29
30 namespace OHOS {
31 namespace NeuralNetworkRuntime {
32 namespace UnitTest {
33 class NNCompiledCacheTest : public testing::Test {
34 public:
35 NNCompiledCacheTest() = default;
36 ~NNCompiledCacheTest() = default;
37 };
38
39 class MockIDevice : public Device {
40 public:
41 MOCK_METHOD1(GetDeviceName, OH_NN_ReturnCode(std::string&));
42 MOCK_METHOD1(GetVendorName, OH_NN_ReturnCode(std::string&));
43 MOCK_METHOD1(GetVersion, OH_NN_ReturnCode(std::string&));
44 MOCK_METHOD1(GetDeviceType, OH_NN_ReturnCode(OH_NN_DeviceType&));
45 MOCK_METHOD1(GetDeviceStatus, OH_NN_ReturnCode(DeviceStatus&));
46 MOCK_METHOD2(GetSupportedOperation, OH_NN_ReturnCode(std::shared_ptr<const mindspore::lite::LiteGraph>,
47 std::vector<bool>&));
48 MOCK_METHOD1(IsFloat16PrecisionSupported, OH_NN_ReturnCode(bool&));
49 MOCK_METHOD1(IsPerformanceModeSupported, OH_NN_ReturnCode(bool&));
50 MOCK_METHOD1(IsPrioritySupported, OH_NN_ReturnCode(bool&));
51 MOCK_METHOD1(IsDynamicInputSupported, OH_NN_ReturnCode(bool&));
52 MOCK_METHOD1(IsModelCacheSupported, OH_NN_ReturnCode(bool&));
53 MOCK_METHOD3(PrepareModel, OH_NN_ReturnCode(std::shared_ptr<const mindspore::lite::LiteGraph>,
54 const ModelConfig&,
55 std::shared_ptr<PreparedModel>&));
56 MOCK_METHOD3(PrepareModel, OH_NN_ReturnCode(const void*,
57 const ModelConfig&,
58 std::shared_ptr<PreparedModel>&));
59 MOCK_METHOD4(PrepareModelFromModelCache, OH_NN_ReturnCode(const std::vector<Buffer>&,
60 const ModelConfig&,
61 std::shared_ptr<PreparedModel>&,
62 bool&));
63 MOCK_METHOD3(PrepareOfflineModel, OH_NN_ReturnCode(std::shared_ptr<const mindspore::lite::LiteGraph>,
64 const ModelConfig&,
65 std::shared_ptr<PreparedModel>&));
66 MOCK_METHOD1(AllocateBuffer, void*(size_t));
67 MOCK_METHOD2(AllocateTensorBuffer, void*(size_t, std::shared_ptr<TensorDesc>));
68 MOCK_METHOD2(AllocateTensorBuffer, void*(size_t, std::shared_ptr<NNTensor>));
69 MOCK_METHOD1(ReleaseBuffer, OH_NN_ReturnCode(const void*));
70 MOCK_METHOD2(AllocateBuffer, OH_NN_ReturnCode(size_t, int&));
71 MOCK_METHOD2(ReleaseBuffer, OH_NN_ReturnCode(int, size_t));
72 MOCK_METHOD1(ReadOpVersion, OH_NN_ReturnCode(int&));
73 };
74
75 /**
76 * @tc.name: nncompiledcachetest_save_001
77 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
78 * @tc.type: FUNC
79 */
80 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_save_001, TestSize.Level0)
81 {
82 LOGE("Save nncompiledcachetest_save_001");
83 NNCompiledCache nncompiledCache;
84
85 std::vector<Buffer> caches;
86 std::string m_cachePath = "a";
87 uint32_t m_cacheVersion = 1;
88
89 OH_NN_ReturnCode ret = nncompiledCache.Save(caches, m_cachePath, m_cacheVersion);
90 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
91 }
92
93 /**
94 * @tc.name: nncompiledcachetest_save_002
95 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
96 * @tc.type: FUNC
97 */
98 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_save_002, TestSize.Level0)
99 {
100 LOGE("Save nncompiledcachetest_save_002");
101 NNCompiledCache nncompiledCache;
102
103 Buffer buffer;
104 float dataArry[9] {0, 1, 2, 3, 4, 5, 6, 7, 8};
105 void* data = dataArry;
106 buffer.data = data;
107 buffer.length = 1;
108 std::vector<Buffer> caches;
109 caches.emplace_back(buffer);
110 std::string m_cachePath = "a";
111 uint32_t m_cacheVersion = 1;
112
113 OH_NN_ReturnCode ret = nncompiledCache.Save(caches, m_cachePath, m_cacheVersion);
114 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
115 }
116
Creator()117 std::shared_ptr<Backend> Creator()
118 {
119 size_t backendID = 1;
120 std::shared_ptr<MockIDevice> device = std::make_shared<MockIDevice>();
121
122 EXPECT_CALL(*((MockIDevice *) device.get()), GetDeviceStatus(::testing::_))
123 .WillOnce(Invoke([](DeviceStatus& status) {
124 // 这里直接修改传入的引用参数
125 status = AVAILABLE;
126 return OH_NN_SUCCESS; // 假设成功的状态码
127 }));
128
129 std::string backendName = "mock";
130 EXPECT_CALL(*((MockIDevice *) device.get()), GetDeviceName(::testing::_))
131 .WillRepeatedly(::testing::DoAll(::testing::SetArgReferee<0>(backendName), ::testing::Return(OH_NN_SUCCESS)));
132
133 EXPECT_CALL(*((MockIDevice *) device.get()), GetVendorName(::testing::_))
134 .WillRepeatedly(::testing::DoAll(::testing::SetArgReferee<0>(backendName), ::testing::Return(OH_NN_SUCCESS)));
135
136 EXPECT_CALL(*((MockIDevice *) device.get()), GetVersion(::testing::_))
137 .WillRepeatedly(::testing::DoAll(::testing::SetArgReferee<0>(backendName), ::testing::Return(OH_NN_SUCCESS)));
138
139 EXPECT_CALL(*((MockIDevice *) device.get()), AllocateBuffer(::testing::_, ::testing::_))
140 .WillRepeatedly(::testing::Return(OH_NN_SUCCESS));
141
142 std::shared_ptr<Backend> backend = std::make_unique<NNBackend>(device, backendID);
143 return backend;
144 }
145
146 /**
147 * @tc.name: nncompiledcachetest_save_003
148 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
149 * @tc.type: FUNC
150 */
151 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_save_003, TestSize.Level0)
152 {
153 LOGE("Save nncompiledcachetest_save_003");
154 NNCompiledCache nncompiledCache;
155
156 size_t backendID = 1;
157 BackendManager& backendManager = BackendManager::GetInstance();
158
159 std::string backendName = "mock";
160 std::function<std::shared_ptr<Backend>()> creator = Creator;
161
162 backendManager.RegisterBackend(backendName, creator);
163
164 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
165 EXPECT_EQ(OH_NN_SUCCESS, ret);
166
167 Buffer buffer;
168 float dataArry[9] {0, 1, 2, 3, 4, 5, 6, 7, 8};
169 void* data = dataArry;
170 buffer.data = data;
171 buffer.length = 1;
172 std::vector<Buffer> caches;
173 caches.emplace_back(buffer);
174 std::string m_cachePath = "a";
175 uint32_t m_cacheVersion = 1;
176
177 OH_NN_ReturnCode retSave = nncompiledCache.Save(caches, m_cachePath, m_cacheVersion);
178 EXPECT_EQ(OH_NN_INVALID_PARAMETER, retSave);
179 }
180
Creator2()181 std::shared_ptr<Backend> Creator2()
182 {
183 size_t backendID = 2;
184 std::shared_ptr<MockIDevice> device = std::make_shared<MockIDevice>();
185
186 EXPECT_CALL(*((MockIDevice *) device.get()), GetDeviceStatus(::testing::_))
187 .WillOnce(Invoke([](DeviceStatus& status) {
188 // 这里直接修改传入的引用参数
189 status = AVAILABLE;
190 return OH_NN_SUCCESS; // 假设成功的状态码
191 }));
192
193 std::string backendName = "mock";
194 EXPECT_CALL(*((MockIDevice *) device.get()), GetDeviceName(::testing::_))
195 .WillRepeatedly(::testing::DoAll(::testing::SetArgReferee<0>(backendName), ::testing::Return(OH_NN_SUCCESS)));
196
197 EXPECT_CALL(*((MockIDevice *) device.get()), GetVendorName(::testing::_))
198 .WillRepeatedly(::testing::DoAll(::testing::SetArgReferee<0>(backendName), ::testing::Return(OH_NN_SUCCESS)));
199
200 EXPECT_CALL(*((MockIDevice *) device.get()), GetVersion(::testing::_))
201 .WillRepeatedly(::testing::DoAll(::testing::SetArgReferee<0>(backendName), ::testing::Return(OH_NN_SUCCESS)));
202
203 EXPECT_CALL(*((MockIDevice *) device.get()), AllocateBuffer(::testing::_, ::testing::_))
204 .WillRepeatedly(::testing::Return(OH_NN_SUCCESS));
205
206 char ptr = 'a';
207 EXPECT_CALL(*((MockIDevice *) device.get()), AllocateBuffer(::testing::_))
208 .WillRepeatedly(::testing::Return(&ptr));
209
210 std::shared_ptr<Backend> backend = std::make_unique<NNBackend>(device, backendID);
211 return backend;
212 }
213
214 /**
215 * @tc.name: nncompiledcachetest_save_004
216 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
217 * @tc.type: FUNC
218 */
219 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_save_004, TestSize.Level0)
220 {
221 LOGE("Save nncompiledcachetest_save_004");
222 NNCompiledCache nncompiledCache;
223
224 size_t backendID = 1;
225 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
226 EXPECT_EQ(OH_NN_SUCCESS, ret);
227
228 Buffer buffer;
229 float dataArry[9] {0, 1, 2, 3, 4, 5, 6, 7, 8};
230 void* data = dataArry;
231 buffer.data = data;
232 buffer.length = 1;
233 std::vector<Buffer> caches;
234 caches.emplace_back(buffer);
235 std::string m_cachePath = "/data/data";
236 uint32_t m_cacheVersion = 1;
237
238 OH_NN_ReturnCode retSave = nncompiledCache.Save(caches, m_cachePath, m_cacheVersion);
239 EXPECT_EQ(OH_NN_SUCCESS, retSave);
240
241 size_t backendID2 = 2;
242 BackendManager& backendManager = BackendManager::GetInstance();
243
244 std::string backendName = "mock";
245 std::function<std::shared_ptr<Backend>()> creator = Creator2;
246
247 backendManager.RegisterBackend(backendName, creator);
248
249 OH_NN_ReturnCode retSetBackend = nncompiledCache.SetBackend(backendID2);
250 EXPECT_EQ(OH_NN_SUCCESS, retSetBackend);
251
252 std::string m_modelName = "test";
253 nncompiledCache.SetModelName(m_modelName);
254
255 OH_NN_ReturnCode retSave2 = nncompiledCache.Save(caches, m_cachePath, m_cacheVersion);
256 EXPECT_EQ(OH_NN_SUCCESS, retSave2);
257 }
258
259 /**
260 * @tc.name: nncompiledcachetest_restore_001
261 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
262 * @tc.type: FUNC
263 */
264 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_001, TestSize.Level0)
265 {
266 LOGE("Restore nncompiledcachetest_restore_001");
267 NNCompiledCache nncompiledCache;
268
269 std::string m_cachePath = "a";
270 uint32_t m_cacheVersion = 1;
271 std::vector<Buffer> caches;
272
273 OH_NN_ReturnCode ret = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
274 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
275 }
276
277 /**
278 * @tc.name: nncompiledcachetest_restore_002
279 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
280 * @tc.type: FUNC
281 */
282 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_002, TestSize.Level0)
283 {
284 LOGE("Restore nncompiledcachetest_restore_002");
285 NNCompiledCache nncompiledCache;
286
287 std::string m_cachePath;
288 uint32_t m_cacheVersion = 1;
289 std::vector<Buffer> caches;
290
291 OH_NN_ReturnCode ret = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
292 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
293 }
294
295 /**
296 * @tc.name: nncompiledcachetest_restore_003
297 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
298 * @tc.type: FUNC
299 */
300 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_003, TestSize.Level0)
301 {
302 LOGE("Restore nncompiledcachetest_restore_003");
303 NNCompiledCache nncompiledCache;
304
305 std::string m_cachePath = "a";
306 uint32_t m_cacheVersion = 1;
307 Buffer buffer;
308 float dataArry[9] {0, 1, 2, 3, 4, 5, 6, 7, 8};
309 void* data = dataArry;
310 buffer.data = data;
311 buffer.length = 1;
312 std::vector<Buffer> caches;
313 caches.emplace_back(buffer);
314
315 OH_NN_ReturnCode ret = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
316 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
317 }
318
319 /**
320 * @tc.name: nncompiledcachetest_restore_004
321 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
322 * @tc.type: FUNC
323 */
324 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_004, TestSize.Level0)
325 {
326 LOGE("Restore nncompiledcachetest_restore_004");
327 NNCompiledCache nncompiledCache;
328
329 size_t backendID = 1;
330 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
331 EXPECT_EQ(OH_NN_SUCCESS, ret);
332
333 std::string m_cachePath = "a";
334 uint32_t m_cacheVersion = 1;
335 std::vector<Buffer> caches;
336
337 OH_NN_ReturnCode retRestore = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
338 EXPECT_EQ(OH_NN_INVALID_PARAMETER, retRestore);
339 }
340
341 /**
342 * @tc.name: nncompiledcachetest_restore_005
343 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
344 * @tc.type: FUNC
345 */
346 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_005, TestSize.Level0)
347 {
348 LOGE("Restore nncompiledcachetest_restore_005");
349 NNCompiledCache nncompiledCache;
350
351 size_t backendID = 1;
352 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
353 EXPECT_EQ(OH_NN_SUCCESS, ret);
354
355 std::string m_modelName = "test";
356 nncompiledCache.SetModelName(m_modelName);
357
358 std::string m_cachePath = "/data";
359 uint32_t m_cacheVersion = 1;
360 std::vector<Buffer> caches;
361
362 OH_NN_ReturnCode retRestore = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
363 EXPECT_EQ(OH_NN_INVALID_PARAMETER, retRestore);
364 }
365
366 /**
367 * @tc.name: nncompiledcachetest_restore_006
368 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
369 * @tc.type: FUNC
370 */
371 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_006, TestSize.Level0)
372 {
373 LOGE("Restore nncompiledcachetest_restore_006");
374 NNCompiledCache nncompiledCache;
375
376 size_t backendID = 1;
377 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
378 EXPECT_EQ(OH_NN_SUCCESS, ret);
379
380 std::string m_cachePath = "/data/local/tmp";
381 uint32_t m_cacheVersion = 1;
382 std::vector<Buffer> caches;
383
384 OH_NN_ReturnCode retRestore = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
385 EXPECT_EQ(OH_NN_INVALID_PARAMETER, retRestore);
386 }
387
388 /**
389 * @tc.name: nncompiledcachetest_restore_007
390 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
391 * @tc.type: FUNC
392 */
393 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_007, TestSize.Level0)
394 {
395 LOGE("Restore nncompiledcachetest_restore_007");
396 NNCompiledCache nncompiledCache;
397
398 size_t backendID = 1;
399 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
400 EXPECT_EQ(OH_NN_SUCCESS, ret);
401
402 std::string m_cachePath = "/data/local/tmp";
403 uint32_t m_cacheVersion = 1;
404 std::vector<Buffer> caches;
405
406 OH_NN_ReturnCode retRestore = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
407 EXPECT_EQ(OH_NN_INVALID_PARAMETER, retRestore);
408 }
409
410 /**
411 * @tc.name: nncompiledcachetest_restore_008
412 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
413 * @tc.type: FUNC
414 */
415 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_008, TestSize.Level0)
416 {
417 LOGE("Restore nncompiledcachetest_restore_008");
418 NNCompiledCache nncompiledCache;
419
420 size_t backendID = 2;
421 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
422 EXPECT_EQ(OH_NN_SUCCESS, ret);
423
424 std::string m_cachePath = "/data/data";
425 uint32_t m_cacheVersion = 1;
426 std::vector<Buffer> caches;
427
428 OH_NN_ReturnCode retRestore = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
429 EXPECT_EQ(OH_NN_INVALID_FILE, retRestore);
430 }
431
432 /**
433 * @tc.name: nncompiledcachetest_setbackend_001
434 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
435 * @tc.type: FUNC
436 */
437 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_setbackend_001, TestSize.Level0)
438 {
439 LOGE("SetBackend nncompiledcachetest_setbackend_001");
440 NNCompiledCache nncompiledCache;
441
442 size_t backendID = 3;
443
444 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
445 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
446 }
447
448 /**
449 * @tc.name: nncompiledcachetest_setbackend_002
450 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
451 * @tc.type: FUNC
452 */
453 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_setbackend_002, TestSize.Level0)
454 {
455 LOGE("SetBackend nncompiledcachetest_setbackend_002");
456 NNCompiledCache nncompiledCache;
457
458 size_t backendID = 1;
459 BackendManager& backendManager = BackendManager::GetInstance();
460
461 std::string backendName = "mock";
462 std::function<std::shared_ptr<Backend>()> creator = Creator;
463
464 backendManager.RegisterBackend(backendName, creator);
465
466 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
467 EXPECT_EQ(OH_NN_SUCCESS, ret);
468 }
469
470 /**
471 * @tc.name: nncompiledcachetest_writecacheinfo_001
472 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
473 * @tc.type: FUNC
474 */
475 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_writecacheinfo_001, TestSize.Level0)
476 {
477 LOGE("WriteCacheInfo nncompiledcachetest_writecacheinfo_001");
478 NNCompiledCache nncompiledCache;
479
480 uint32_t cacheSize = 1;
481 nlohmann::json cacheInfo;
482 std::string cacheDir = "mock";
483
484 OH_NN_ReturnCode ret = nncompiledCache.WriteCacheInfo(cacheSize, cacheInfo, cacheDir);
485 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
486 }
487
488 /**
489 * @tc.name: nncompiledcachetest_writecacheinfo_002
490 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
491 * @tc.type: FUNC
492 */
493 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_writecacheinfo_002, TestSize.Level0)
494 {
495 LOGE("WriteCacheInfo nncompiledcachetest_writecacheinfo_002");
496 NNCompiledCache nncompiledCache;
497
498 uint32_t cacheSize = 1;
499 nlohmann::json cacheInfo;
500 std::string cacheDir = "/data/data";
501
502 OH_NN_ReturnCode ret = nncompiledCache.WriteCacheInfo(cacheSize, cacheInfo, cacheDir);
503 EXPECT_EQ(OH_NN_SUCCESS, ret);
504 }
505
506 /**
507 * @tc.name: nncompiledcachetest_checkcacheinfo_001
508 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
509 * @tc.type: FUNC
510 */
511 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_checkcacheinfo_001, TestSize.Level0)
512 {
513 LOGE("CheckCacheInfo nncompiledcachetest_checkcacheinfo_001");
514 NNCompiledCache nncompiledCache;
515
516 NNCompiledCacheInfo modelCacheInfo;
517 std::string cacheInfoPath = "MOCK";
518
519 OH_NN_ReturnCode ret = nncompiledCache.CheckCacheInfo(modelCacheInfo, cacheInfoPath);
520 EXPECT_EQ(OH_NN_INVALID_FILE, ret);
521 }
522
523 /**
524 * @tc.name: nncompiledcachetest_checkcacheinfo_002
525 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
526 * @tc.type: FUNC
527 */
528 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_checkcacheinfo_002, TestSize.Level0)
529 {
530 LOGE("CheckCacheInfo nncompiledcachetest_checkcacheinfo_002");
531 NNCompiledCache nncompiledCache;
532
533 NNCompiledCacheInfo modelCacheInfo;
534 std::string cacheInfoPath = "/data/data/0.nncache";
535
536 OH_NN_ReturnCode ret = nncompiledCache.CheckCacheInfo(modelCacheInfo, cacheInfoPath);
537 EXPECT_EQ(OH_NN_INVALID_FILE, ret);
538 }
539
540 /**
541 * @tc.name: nncompiledcachetest_checkcacheinfo_003
542 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
543 * @tc.type: FUNC
544 */
545 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_checkcacheinfo_003, TestSize.Level0)
546 {
547 LOGE("CheckCacheInfo nncompiledcachetest_checkcacheinfo_003");
548 NNCompiledCache nncompiledCache;
549
550 NNCompiledCacheInfo modelCacheInfo;
551 std::string cacheInfoPath = "/data/data/testcache_info.nncache";
552
553 OH_NN_ReturnCode ret = nncompiledCache.CheckCacheInfo(modelCacheInfo, cacheInfoPath);
554 EXPECT_EQ(OH_NN_INVALID_FILE, ret);
555 }
556
557 /**
558 * @tc.name: nncompiledcachetest_checkcacheinfo_004
559 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
560 * @tc.type: FUNC
561 */
562 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_checkcacheinfo_004, TestSize.Level0)
563 {
564 LOGE("CheckCacheInfo nncompiledcachetest_checkcacheinfo_004");
565 NNCompiledCache nncompiledCache;
566
567 size_t backendID = 2;
568 OH_NN_ReturnCode retSetBackend = nncompiledCache.SetBackend(backendID);
569 EXPECT_EQ(OH_NN_SUCCESS, retSetBackend);
570
571 std::string m_modelName = "test";
572 nncompiledCache.SetModelName(m_modelName);
573
574 NNCompiledCacheInfo modelCacheInfo;
575 std::string cacheInfoPath = "/data/data/testcache_info.nncache";
576
577 OH_NN_ReturnCode ret = nncompiledCache.CheckCacheInfo(modelCacheInfo, cacheInfoPath);
578 EXPECT_EQ(OH_NN_SUCCESS, ret);
579 }
580 } // namespace UnitTest
581 } // namespace NeuralNetworkRuntime
582 } // namespace OHOS