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 "interfaces/kits/c/neural_network_runtime/neural_network_runtime_type.h"
24 #include "common/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 };
73
74 /**
75 * @tc.name: nncompiledcachetest_save_001
76 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
77 * @tc.type: FUNC
78 */
79 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_save_001, TestSize.Level0)
80 {
81 LOGE("Save nncompiledcachetest_save_001");
82 NNCompiledCache nncompiledCache;
83
84 std::vector<Buffer> caches;
85 std::string m_cachePath = "a";
86 uint32_t m_cacheVersion = 1;
87
88 OH_NN_ReturnCode ret = nncompiledCache.Save(caches, m_cachePath, m_cacheVersion);
89 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
90 }
91
92 /**
93 * @tc.name: nncompiledcachetest_save_002
94 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
95 * @tc.type: FUNC
96 */
97 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_save_002, TestSize.Level0)
98 {
99 LOGE("Save nncompiledcachetest_save_002");
100 NNCompiledCache nncompiledCache;
101
102 Buffer buffer;
103 float dataArry[9] {0, 1, 2, 3, 4, 5, 6, 7, 8};
104 void* data = dataArry;
105 buffer.data = data;
106 buffer.length = 1;
107 std::vector<Buffer> caches;
108 caches.emplace_back(buffer);
109 std::string m_cachePath = "a";
110 uint32_t m_cacheVersion = 1;
111
112 OH_NN_ReturnCode ret = nncompiledCache.Save(caches, m_cachePath, m_cacheVersion);
113 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
114 }
115
Creator()116 std::shared_ptr<Backend> Creator()
117 {
118 size_t backendID = 1;
119 std::shared_ptr<MockIDevice> device = std::make_shared<MockIDevice>();
120
121 EXPECT_CALL(*((MockIDevice *) device.get()), GetDeviceStatus(::testing::_))
122 .WillOnce(Invoke([](DeviceStatus& status) {
123 // 这里直接修改传入的引用参数
124 status = AVAILABLE;
125 return OH_NN_SUCCESS; // 假设成功的状态码
126 }));
127
128 std::string backendName = "mock";
129 EXPECT_CALL(*((MockIDevice *) device.get()), GetDeviceName(::testing::_))
130 .WillRepeatedly(::testing::DoAll(::testing::SetArgReferee<0>(backendName), ::testing::Return(OH_NN_SUCCESS)));
131
132 EXPECT_CALL(*((MockIDevice *) device.get()), GetVendorName(::testing::_))
133 .WillRepeatedly(::testing::DoAll(::testing::SetArgReferee<0>(backendName), ::testing::Return(OH_NN_SUCCESS)));
134
135 EXPECT_CALL(*((MockIDevice *) device.get()), GetVersion(::testing::_))
136 .WillRepeatedly(::testing::DoAll(::testing::SetArgReferee<0>(backendName), ::testing::Return(OH_NN_SUCCESS)));
137
138 EXPECT_CALL(*((MockIDevice *) device.get()), AllocateBuffer(::testing::_, ::testing::_))
139 .WillRepeatedly(::testing::Return(OH_NN_SUCCESS));
140
141 std::shared_ptr<Backend> backend = std::make_unique<NNBackend>(device, backendID);
142 return backend;
143 }
144
145 /**
146 * @tc.name: nncompiledcachetest_save_003
147 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
148 * @tc.type: FUNC
149 */
150 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_save_003, TestSize.Level0)
151 {
152 LOGE("Save nncompiledcachetest_save_003");
153 NNCompiledCache nncompiledCache;
154
155 size_t backendID = 1;
156 BackendManager& backendManager = BackendManager::GetInstance();
157
158 std::string backendName = "mock";
159 std::function<std::shared_ptr<Backend>()> creator = Creator;
160
161 backendManager.RegisterBackend(backendName, creator);
162
163 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
164 EXPECT_EQ(OH_NN_SUCCESS, ret);
165
166 Buffer buffer;
167 float dataArry[9] {0, 1, 2, 3, 4, 5, 6, 7, 8};
168 void* data = dataArry;
169 buffer.data = data;
170 buffer.length = 1;
171 std::vector<Buffer> caches;
172 caches.emplace_back(buffer);
173 std::string m_cachePath = "a";
174 uint32_t m_cacheVersion = 1;
175
176 OH_NN_ReturnCode retSave = nncompiledCache.Save(caches, m_cachePath, m_cacheVersion);
177 EXPECT_EQ(OH_NN_INVALID_PARAMETER, retSave);
178 }
179
Creator2()180 std::shared_ptr<Backend> Creator2()
181 {
182 size_t backendID = 2;
183 std::shared_ptr<MockIDevice> device = std::make_shared<MockIDevice>();
184
185 EXPECT_CALL(*((MockIDevice *) device.get()), GetDeviceStatus(::testing::_))
186 .WillOnce(Invoke([](DeviceStatus& status) {
187 // 这里直接修改传入的引用参数
188 status = AVAILABLE;
189 return OH_NN_SUCCESS; // 假设成功的状态码
190 }));
191
192 std::string backendName = "mock";
193 EXPECT_CALL(*((MockIDevice *) device.get()), GetDeviceName(::testing::_))
194 .WillRepeatedly(::testing::DoAll(::testing::SetArgReferee<0>(backendName), ::testing::Return(OH_NN_SUCCESS)));
195
196 EXPECT_CALL(*((MockIDevice *) device.get()), GetVendorName(::testing::_))
197 .WillRepeatedly(::testing::DoAll(::testing::SetArgReferee<0>(backendName), ::testing::Return(OH_NN_SUCCESS)));
198
199 EXPECT_CALL(*((MockIDevice *) device.get()), GetVersion(::testing::_))
200 .WillRepeatedly(::testing::DoAll(::testing::SetArgReferee<0>(backendName), ::testing::Return(OH_NN_SUCCESS)));
201
202 EXPECT_CALL(*((MockIDevice *) device.get()), AllocateBuffer(::testing::_, ::testing::_))
203 .WillRepeatedly(::testing::Return(OH_NN_SUCCESS));
204
205 char ptr = 'a';
206 EXPECT_CALL(*((MockIDevice *) device.get()), AllocateBuffer(::testing::_))
207 .WillRepeatedly(::testing::Return(&ptr));
208
209 std::shared_ptr<Backend> backend = std::make_unique<NNBackend>(device, backendID);
210 return backend;
211 }
212
213 /**
214 * @tc.name: nncompiledcachetest_save_004
215 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
216 * @tc.type: FUNC
217 */
218 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_save_004, TestSize.Level0)
219 {
220 LOGE("Save nncompiledcachetest_save_004");
221 NNCompiledCache nncompiledCache;
222
223 size_t backendID = 1;
224 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
225 EXPECT_EQ(OH_NN_SUCCESS, ret);
226
227 Buffer buffer;
228 float dataArry[9] {0, 1, 2, 3, 4, 5, 6, 7, 8};
229 void* data = dataArry;
230 buffer.data = data;
231 buffer.length = 1;
232 std::vector<Buffer> caches;
233 caches.emplace_back(buffer);
234 std::string m_cachePath = "/data/data";
235 uint32_t m_cacheVersion = 1;
236
237 OH_NN_ReturnCode retSave = nncompiledCache.Save(caches, m_cachePath, m_cacheVersion);
238 EXPECT_EQ(OH_NN_SUCCESS, retSave);
239
240 size_t backendID2 = 2;
241 BackendManager& backendManager = BackendManager::GetInstance();
242
243 std::string backendName = "mock";
244 std::function<std::shared_ptr<Backend>()> creator = Creator2;
245
246 backendManager.RegisterBackend(backendName, creator);
247
248 OH_NN_ReturnCode retSetBackend = nncompiledCache.SetBackend(backendID2);
249 EXPECT_EQ(OH_NN_SUCCESS, retSetBackend);
250
251 std::string m_modelName = "test";
252 nncompiledCache.SetModelName(m_modelName);
253
254 OH_NN_ReturnCode retSave2 = nncompiledCache.Save(caches, m_cachePath, m_cacheVersion);
255 EXPECT_EQ(OH_NN_SUCCESS, retSave2);
256 }
257
258 /**
259 * @tc.name: nncompiledcachetest_restore_001
260 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
261 * @tc.type: FUNC
262 */
263 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_001, TestSize.Level0)
264 {
265 LOGE("Restore nncompiledcachetest_restore_001");
266 NNCompiledCache nncompiledCache;
267
268 std::string m_cachePath = "a";
269 uint32_t m_cacheVersion = 1;
270 std::vector<Buffer> caches;
271
272 OH_NN_ReturnCode ret = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
273 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
274 }
275
276 /**
277 * @tc.name: nncompiledcachetest_restore_002
278 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
279 * @tc.type: FUNC
280 */
281 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_002, TestSize.Level0)
282 {
283 LOGE("Restore nncompiledcachetest_restore_002");
284 NNCompiledCache nncompiledCache;
285
286 std::string m_cachePath;
287 uint32_t m_cacheVersion = 1;
288 std::vector<Buffer> caches;
289
290 OH_NN_ReturnCode ret = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
291 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
292 }
293
294 /**
295 * @tc.name: nncompiledcachetest_restore_003
296 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
297 * @tc.type: FUNC
298 */
299 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_003, TestSize.Level0)
300 {
301 LOGE("Restore nncompiledcachetest_restore_003");
302 NNCompiledCache nncompiledCache;
303
304 std::string m_cachePath = "a";
305 uint32_t m_cacheVersion = 1;
306 Buffer buffer;
307 float dataArry[9] {0, 1, 2, 3, 4, 5, 6, 7, 8};
308 void* data = dataArry;
309 buffer.data = data;
310 buffer.length = 1;
311 std::vector<Buffer> caches;
312 caches.emplace_back(buffer);
313
314 OH_NN_ReturnCode ret = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
315 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
316 }
317
318 /**
319 * @tc.name: nncompiledcachetest_restore_004
320 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
321 * @tc.type: FUNC
322 */
323 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_004, TestSize.Level0)
324 {
325 LOGE("Restore nncompiledcachetest_restore_004");
326 NNCompiledCache nncompiledCache;
327
328 size_t backendID = 1;
329 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
330 EXPECT_EQ(OH_NN_SUCCESS, ret);
331
332 std::string m_cachePath = "a";
333 uint32_t m_cacheVersion = 1;
334 std::vector<Buffer> caches;
335
336 OH_NN_ReturnCode retRestore = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
337 EXPECT_EQ(OH_NN_INVALID_PARAMETER, retRestore);
338 }
339
340 /**
341 * @tc.name: nncompiledcachetest_restore_005
342 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
343 * @tc.type: FUNC
344 */
345 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_005, TestSize.Level0)
346 {
347 LOGE("Restore nncompiledcachetest_restore_005");
348 NNCompiledCache nncompiledCache;
349
350 size_t backendID = 1;
351 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
352 EXPECT_EQ(OH_NN_SUCCESS, ret);
353
354 std::string m_modelName = "test";
355 nncompiledCache.SetModelName(m_modelName);
356
357 std::string m_cachePath = "/data";
358 uint32_t m_cacheVersion = 1;
359 std::vector<Buffer> caches;
360
361 OH_NN_ReturnCode retRestore = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
362 EXPECT_EQ(OH_NN_INVALID_PARAMETER, retRestore);
363 }
364
365 /**
366 * @tc.name: nncompiledcachetest_restore_006
367 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
368 * @tc.type: FUNC
369 */
370 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_006, TestSize.Level0)
371 {
372 LOGE("Restore nncompiledcachetest_restore_006");
373 NNCompiledCache nncompiledCache;
374
375 size_t backendID = 1;
376 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
377 EXPECT_EQ(OH_NN_SUCCESS, ret);
378
379 std::string m_cachePath = "/data/data";
380 uint32_t m_cacheVersion = 1;
381 std::vector<Buffer> caches;
382
383 OH_NN_ReturnCode retRestore = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
384 EXPECT_EQ(OH_NN_MEMORY_ERROR, retRestore);
385 }
386
387 /**
388 * @tc.name: nncompiledcachetest_restore_007
389 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
390 * @tc.type: FUNC
391 */
392 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_007, TestSize.Level0)
393 {
394 LOGE("Restore nncompiledcachetest_restore_007");
395 NNCompiledCache nncompiledCache;
396
397 size_t backendID = 1;
398 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
399 EXPECT_EQ(OH_NN_SUCCESS, ret);
400
401 std::string m_cachePath = "/data/data";
402 uint32_t m_cacheVersion = 1;
403 std::vector<Buffer> caches;
404
405 OH_NN_ReturnCode retRestore = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
406 EXPECT_EQ(OH_NN_MEMORY_ERROR, retRestore);
407 }
408
409 /**
410 * @tc.name: nncompiledcachetest_restore_008
411 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
412 * @tc.type: FUNC
413 */
414 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_restore_008, TestSize.Level0)
415 {
416 LOGE("Restore nncompiledcachetest_restore_008");
417 NNCompiledCache nncompiledCache;
418
419 size_t backendID = 2;
420 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
421 EXPECT_EQ(OH_NN_SUCCESS, ret);
422
423 std::string m_cachePath = "/data/data";
424 uint32_t m_cacheVersion = 1;
425 std::vector<Buffer> caches;
426
427 OH_NN_ReturnCode retRestore = nncompiledCache.Restore(m_cachePath, m_cacheVersion, caches);
428 EXPECT_EQ(OH_NN_INVALID_PARAMETER, retRestore);
429 }
430
431 /**
432 * @tc.name: nncompiledcachetest_setbackend_001
433 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
434 * @tc.type: FUNC
435 */
436 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_setbackend_001, TestSize.Level0)
437 {
438 LOGE("SetBackend nncompiledcachetest_setbackend_001");
439 NNCompiledCache nncompiledCache;
440
441 size_t backendID = 3;
442
443 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
444 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
445 }
446
447 /**
448 * @tc.name: nncompiledcachetest_setbackend_002
449 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
450 * @tc.type: FUNC
451 */
452 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_setbackend_002, TestSize.Level0)
453 {
454 LOGE("SetBackend nncompiledcachetest_setbackend_002");
455 NNCompiledCache nncompiledCache;
456
457 size_t backendID = 1;
458 BackendManager& backendManager = BackendManager::GetInstance();
459
460 std::string backendName = "mock";
461 std::function<std::shared_ptr<Backend>()> creator = Creator;
462
463 backendManager.RegisterBackend(backendName, creator);
464
465 OH_NN_ReturnCode ret = nncompiledCache.SetBackend(backendID);
466 EXPECT_EQ(OH_NN_SUCCESS, ret);
467 }
468
469 /**
470 * @tc.name: nncompiledcachetest_setmodelname_001
471 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
472 * @tc.type: FUNC
473 */
474 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_setmodelname_001, TestSize.Level0)
475 {
476 LOGE("SetModelName nncompiledcachetest_setmodelname_001");
477 NNCompiledCache nncompiledCache;
478 std::string m_modelName;
479 nncompiledCache.SetModelName(m_modelName);
480 }
481
482 /**
483 * @tc.name: nncompiledcachetest_writecacheinfo_001
484 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
485 * @tc.type: FUNC
486 */
487 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_writecacheinfo_001, TestSize.Level0)
488 {
489 LOGE("WriteCacheInfo nncompiledcachetest_writecacheinfo_001");
490 NNCompiledCache nncompiledCache;
491
492 uint32_t cacheSize = 1;
493 std::unique_ptr<int64_t[]> cacheInfo = std::make_unique<int64_t[]>(cacheSize);
494 std::string cacheDir = "mock";
495
496 OH_NN_ReturnCode ret = nncompiledCache.WriteCacheInfo(cacheSize, cacheInfo, cacheDir);
497 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
498 }
499
500 /**
501 * @tc.name: nncompiledcachetest_writecacheinfo_002
502 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
503 * @tc.type: FUNC
504 */
505 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_writecacheinfo_002, TestSize.Level0)
506 {
507 LOGE("WriteCacheInfo nncompiledcachetest_writecacheinfo_002");
508 NNCompiledCache nncompiledCache;
509
510 uint32_t cacheSize = 1;
511 std::unique_ptr<int64_t[]> cacheInfo = std::make_unique<int64_t[]>(cacheSize);
512 std::string cacheDir = "/data/data";
513
514 OH_NN_ReturnCode ret = nncompiledCache.WriteCacheInfo(cacheSize, cacheInfo, cacheDir);
515 EXPECT_EQ(OH_NN_SUCCESS, ret);
516 }
517
518 /**
519 * @tc.name: nncompiledcachetest_checkcacheinfo_001
520 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
521 * @tc.type: FUNC
522 */
523 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_checkcacheinfo_001, TestSize.Level0)
524 {
525 LOGE("CheckCacheInfo nncompiledcachetest_checkcacheinfo_001");
526 NNCompiledCache nncompiledCache;
527
528 NNCompiledCacheInfo modelCacheInfo;
529 std::string cacheInfoPath = "MOCK";
530
531 OH_NN_ReturnCode ret = nncompiledCache.CheckCacheInfo(modelCacheInfo, cacheInfoPath);
532 EXPECT_EQ(OH_NN_INVALID_FILE, ret);
533 }
534
535 /**
536 * @tc.name: nncompiledcachetest_checkcacheinfo_002
537 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
538 * @tc.type: FUNC
539 */
540 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_checkcacheinfo_002, TestSize.Level0)
541 {
542 LOGE("CheckCacheInfo nncompiledcachetest_checkcacheinfo_002");
543 NNCompiledCache nncompiledCache;
544
545 NNCompiledCacheInfo modelCacheInfo;
546 std::string cacheInfoPath = "/data/data/0.nncache";
547
548 OH_NN_ReturnCode ret = nncompiledCache.CheckCacheInfo(modelCacheInfo, cacheInfoPath);
549 EXPECT_EQ(OH_NN_INVALID_FILE, ret);
550 }
551
552 /**
553 * @tc.name: nncompiledcachetest_checkcacheinfo_003
554 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
555 * @tc.type: FUNC
556 */
557 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_checkcacheinfo_003, TestSize.Level0)
558 {
559 LOGE("CheckCacheInfo nncompiledcachetest_checkcacheinfo_003");
560 NNCompiledCache nncompiledCache;
561
562 NNCompiledCacheInfo modelCacheInfo;
563 std::string cacheInfoPath = "/data/data/testcache_info.nncache";
564
565 OH_NN_ReturnCode ret = nncompiledCache.CheckCacheInfo(modelCacheInfo, cacheInfoPath);
566 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
567 }
568
569 /**
570 * @tc.name: nncompiledcachetest_checkcacheinfo_004
571 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
572 * @tc.type: FUNC
573 */
574 HWTEST_F(NNCompiledCacheTest, nncompiledcachetest_checkcacheinfo_004, TestSize.Level0)
575 {
576 LOGE("CheckCacheInfo nncompiledcachetest_checkcacheinfo_004");
577 NNCompiledCache nncompiledCache;
578
579 size_t backendID = 2;
580 OH_NN_ReturnCode retSetBackend = nncompiledCache.SetBackend(backendID);
581 EXPECT_EQ(OH_NN_SUCCESS, retSetBackend);
582
583 std::string m_modelName = "test";
584 nncompiledCache.SetModelName(m_modelName);
585
586 NNCompiledCacheInfo modelCacheInfo;
587 std::string cacheInfoPath = "/data/data/testcache_info.nncache";
588
589 OH_NN_ReturnCode ret = nncompiledCache.CheckCacheInfo(modelCacheInfo, cacheInfoPath);
590 EXPECT_EQ(OH_NN_SUCCESS, ret);
591 }
592 } // namespace UnitTest
593 } // namespace NeuralNetworkRuntime
594 } // namespace OHOS