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 <sys/mman.h>
17 #include <gtest/gtest.h>
18 #include <gmock/gmock.h>
19
20 #include "common/log.h"
21 #include "hdi_device_v1_0.h"
22 #include "test/unittest/common/v1_0/mock_idevice.h"
23
24 #include "lite_graph_to_hdi_model_v1_0.h"
25 #include "device.h"
26 #include "interfaces/kits/c/neural_network_runtime/neural_network_runtime_type.h"
27 #include "nnbackend.h"
28 #include "ops_registry.h"
29 #include "transform.h"
30
31 using namespace testing;
32 using namespace testing::ext;
33 using namespace OHOS::NeuralNetworkRuntime;
34 using LiteGraphPrimitvePtr = std::unique_ptr<void, void(*)(void*)>;
35
36 namespace MSLITE = mindspore::lite;
37 namespace OHOS {
38 namespace NeuralNetworkRuntime {
39 namespace V1 {
40 namespace UnitTest {
41 class LiteGraphToHDIModelTest : public testing::Test {
42 public:
43 LiteGraphToHDIModelTest() = default;
44 ~LiteGraphToHDIModelTest() = default;
45 public:
46 std::vector<uint32_t> m_inputs{0, 1};
47 std::vector<uint32_t> m_outputs{2};
48 std::vector<uint32_t> m_param{3};
49 std::vector<int32_t> m_input_dim{3, 3};
50 std::vector<int32_t> m_output_dim{3, 3};
51 std::vector<int32_t> m_param_dim{};
52 };
53
getNode(void * primitive)54 MSLITE::LiteGraph::Node* getNode(void* primitive)
55 {
56 MSLITE::LiteGraph::Node* node = new(std::nothrow) MSLITE::LiteGraph::Node();
57 node->name_ = "NNRt_SubGraph";
58 node->quant_type_ = 1;
59 node->primitive_ = primitive;
60 node->input_indices_ = {1, 1, 1, 1};
61 node->output_indices_ = {1, 1, 1, 1};
62 return node;
63 }
64
65 /**
66 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_001
67 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
68 * @tc.type: FUNC
69 */
70 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_001, TestSize.Level0)
71 {
72 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_001");
73 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
74 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(nullptr, tensorBuffer);
75 EXPECT_EQ(nullptr, model);
76 }
77
78 /**
79 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_002
80 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
81 * @tc.type: FUNC
82 */
83 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_002, TestSize.Level0)
84 {
85 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_002");
86 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
87 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {0, 0, 0, 0};
88 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
89 EXPECT_EQ(nullptr, model);
90
91 uint8_t *mmapPtr = static_cast<uint8_t *>(mmap(nullptr,
92 tensorBuffer.bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, tensorBuffer.fd, 0));
93 EXPECT_EQ(MAP_FAILED, mmapPtr);
94 }
95
96 /**
97 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_003
98 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
99 * @tc.type: FUNC
100 */
101 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_003, TestSize.Level0)
102 {
103 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_003");
104 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
105 MSLITE::LiteGraph::SubGraph* subGraph = new (std::nothrow) MSLITE::LiteGraph::SubGraph();
106 subGraph->name_ = "NNRt_SubGraph";
107 subGraph->input_indices_ = {1, 1, 1, 1};
108 subGraph->output_indices_ = {1, 1, 1, 1};
109 subGraph->node_indices_ = {1, 1, 1, 1};
110
111 void* tp = MSLITE::MindIR_Tensor_Create();
112
113 liteGraph.get()->all_tensors_.emplace_back(tp);
114 liteGraph.get()->sub_graphs_.emplace_back(subGraph);
115
116 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 1, 1, 1};
117
118 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
119 EXPECT_NE(nullptr, model);
120
121 uint8_t *mmapPtr = static_cast<uint8_t *>(mmap(nullptr,
122 tensorBuffer.bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, tensorBuffer.fd, 0));
123 EXPECT_EQ(MAP_FAILED, mmapPtr);
124 }
125
126 /**
127 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_004
128 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
129 * @tc.type: FUNC
130 */
131 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_004, TestSize.Level0)
132 {
133 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_004");
134 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
135 liteGraph.get()->all_nodes_.emplace_back(nullptr);
136 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
137 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
138 EXPECT_EQ(nullptr, model);
139 }
140
141 /**
142 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_005
143 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
144 * @tc.type: FUNC
145 */
146 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_005, TestSize.Level0)
147 {
148 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_005");
149 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
150 MSLITE::LiteGraph::Node* node = new(std::nothrow) MSLITE::LiteGraph::Node();
151 liteGraph.get()->all_nodes_.emplace_back(node);
152 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
153 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
154 EXPECT_EQ(nullptr, model);
155 }
156
157 /**
158 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_006
159 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
160 * @tc.type: FUNC
161 */
162 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_006, TestSize.Level0)
163 {
164 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_006");
165 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
166
167 float alpha {0.0f};
168 float minVal {0.0f};
169 float maxVal {0.0f};
170 bool approximate {false};
171 mindspore::lite::ActivationType activationType {mindspore::lite::ACTIVATION_TYPE_ABS};
172
173 void* primitive = mindspore::lite::MindIR_Activation_CreatePrimitive(activationType, alpha,
174 minVal, maxVal, approximate);
175
176 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
177 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
178 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
179 EXPECT_NE(nullptr, model);
180 }
181
182 /**
183 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_007
184 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
185 * @tc.type: FUNC
186 */
187 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_007, TestSize.Level0)
188 {
189 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_007");
190 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
191
192 int8_t num = 1;
193 int8_t* fuseData = #
194 mindspore::lite::ActivationType type = NNToMS::TransfromFusionType(static_cast<OH_NN_FuseType>(*fuseData));
195 void* primitive = mindspore::lite::MindIR_AddFusion_CreatePrimitive(type);
196
197 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
198 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
199 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
200 EXPECT_NE(nullptr, model);
201 }
202
203 /**
204 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_008
205 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
206 * @tc.type: FUNC
207 */
208 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_008, TestSize.Level0)
209 {
210 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_008");
211 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
212
213 int64_t keepDims {0};
214 void* primitive = mindspore::lite::MindIR_All_CreatePrimitive(keepDims);
215
216 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
217 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
218 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
219 EXPECT_NE(nullptr, model);
220 }
221
222 /**
223 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_009
224 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
225 * @tc.type: FUNC
226 */
227 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_009, TestSize.Level0)
228 {
229 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_009");
230 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
231
232 int64_t axis {-1};
233 int64_t topK {1};
234 bool keepDims {false};
235 bool outMaxValue {false};
236 void* primitive = mindspore::lite::MindIR_ArgMaxFusion_CreatePrimitive(axis, topK, keepDims, outMaxValue);
237
238 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
239 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
240 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
241 EXPECT_NE(nullptr, model);
242 }
243
244 /**
245 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_010
246 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
247 * @tc.type: FUNC
248 */
249 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_010, TestSize.Level0)
250 {
251 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_010");
252 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
253
254 int64_t summarize {0};
255 void* primitive = mindspore::lite::MindIR_Assert_CreatePrimitive(summarize);
256
257 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
258 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
259 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
260 EXPECT_NE(nullptr, model);
261 }
262
263 /**
264 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_011
265 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
266 * @tc.type: FUNC
267 */
268 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_011, TestSize.Level0)
269 {
270 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_011");
271 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
272
273 std::vector<int64_t> kernelSize;
274 std::vector<int64_t> pad;
275 std::vector<int64_t> strides;
276 mindspore::lite::PadMode padMode {mindspore::lite::PAD_MODE_PAD};
277 mindspore::lite::ActivationType activationType {mindspore::lite::ACTIVATION_TYPE_NO_ACTIVATION};
278 mindspore::lite::RoundMode roundMode {mindspore::lite::ROUND_MODE_FLOOR};
279 mindspore::lite::Format format {mindspore::lite::FORMAT_NCHW};
280 bool global {false};
281 void* primitive = mindspore::lite::MindIR_AvgPoolFusion_CreatePrimitive(kernelSize, strides, pad,
282 padMode, roundMode, format, global, activationType);
283
284 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
285 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
286 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
287 EXPECT_NE(nullptr, model);
288 }
289
290 /**
291 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_012
292 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
293 * @tc.type: FUNC
294 */
295 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_012, TestSize.Level0)
296 {
297 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_012");
298 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
299
300 std::vector<int64_t> blockSize;
301 std::vector<std::vector<int64_t>> crops;
302 void* primitive = mindspore::lite::MindIR_BatchToSpaceND_CreatePrimitive(blockSize, crops);
303
304 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
305 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
306 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
307 EXPECT_NE(nullptr, model);
308 }
309
310 /**
311 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_013
312 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
313 * @tc.type: FUNC
314 */
315 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_013, TestSize.Level0)
316 {
317 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_013");
318 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
319
320 float epsilon {0.0001f};
321 void* primitive = mindspore::lite::MindIR_FusedBatchNorm_CreatePrimitive(epsilon);
322
323 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
324 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
325 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
326 EXPECT_NE(nullptr, model);
327 }
328
329 /**
330 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_014
331 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
332 * @tc.type: FUNC
333 */
334 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_014, TestSize.Level0)
335 {
336 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_014");
337 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
338
339 float epsilon {0.0001f};
340 void* primitive = mindspore::lite::MindIR_FusedBatchNorm_CreatePrimitive(epsilon);
341
342 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
343 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
344 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
345 EXPECT_NE(nullptr, model);
346 }
347
348 /**
349 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_015
350 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
351 * @tc.type: FUNC
352 */
353 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_015, TestSize.Level0)
354 {
355 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_015");
356 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
357
358 void* primitive = mindspore::lite::MindIR_BiasAdd_CreatePrimitive();
359
360 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
361 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
362 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
363 EXPECT_NE(nullptr, model);
364 }
365
366 /**
367 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_016
368 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
369 * @tc.type: FUNC
370 */
371 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_016, TestSize.Level0)
372 {
373 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_016");
374 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
375
376 std::vector<int64_t> shape;
377 void* primitive = mindspore::lite::MindIR_BroadcastTo_CreatePrimitive(shape);
378
379 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
380 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
381 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
382 EXPECT_NE(nullptr, model);
383 }
384
385 /**
386 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_017
387 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
388 * @tc.type: FUNC
389 */
390 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_017, TestSize.Level0)
391 {
392 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_017");
393 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
394
395 void* primitive = mindspore::lite::MindIR_Cast_CreatePrimitive();
396
397 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
398 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
399 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
400 EXPECT_NE(nullptr, model);
401 }
402
403 /**
404 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_018
405 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
406 * @tc.type: FUNC
407 */
408 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_018, TestSize.Level0)
409 {
410 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_018");
411 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
412
413 void* primitive = mindspore::lite::MindIR_Ceil_CreatePrimitive();
414
415 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
416 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
417 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
418 EXPECT_NE(nullptr, model);
419 }
420
421 /**
422 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_019
423 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
424 * @tc.type: FUNC
425 */
426 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_019, TestSize.Level0)
427 {
428 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_019");
429 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
430
431 float max {0.0f};
432 float min {0.0f};
433 void* primitive = mindspore::lite::MindIR_Clip_CreatePrimitive(max, min);
434
435 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
436 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
437 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
438 EXPECT_NE(nullptr, model);
439 }
440
441 /**
442 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_020
443 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
444 * @tc.type: FUNC
445 */
446 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_020, TestSize.Level0)
447 {
448 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_020");
449 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
450
451 int64_t axis{0};
452 void* primitive = mindspore::lite::MindIR_Concat_CreatePrimitive(axis);
453
454 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
455 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
456 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
457 EXPECT_NE(nullptr, model);
458 }
459
460 /**
461 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_021
462 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
463 * @tc.type: FUNC
464 */
465 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_021, TestSize.Level0)
466 {
467 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_021");
468 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
469
470 int64_t dataType {0};
471 std::vector<float> value;
472 void* primitive = mindspore::lite::MindIR_ConstantOfShape_CreatePrimitive(dataType, value);
473
474 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
475 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
476 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
477 EXPECT_NE(nullptr, model);
478 }
479
480 /**
481 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_022
482 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
483 * @tc.type: FUNC
484 */
485 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_022, TestSize.Level0)
486 {
487 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_022");
488 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
489
490 int64_t group {1};
491 int64_t inChannel {0};
492 int64_t outChannel {0};
493 std::vector<int64_t> kernelSize;
494 std::vector<int64_t> strides;
495 std::vector<int64_t> padList;
496 std::vector<int64_t> dilation;
497 std::vector<int64_t> outputPaddings;
498 mindspore::lite::PadMode padMode{mindspore::lite::PAD_MODE_PAD};
499 mindspore::lite::ActivationType activationType{mindspore::lite::ACTIVATION_TYPE_NO_ACTIVATION};
500 void* primitive = MindIR_Conv2dTransposeFusion_CreatePrimitive(kernelSize,
501 strides, dilation, padMode, padList, group, inChannel, outChannel,
502 activationType, outputPaddings);
503
504 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
505 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
506 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
507 EXPECT_NE(nullptr, model);
508 }
509
510 /**
511 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_023
512 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
513 * @tc.type: FUNC
514 */
515 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_023, TestSize.Level0)
516 {
517 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_023");
518 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
519
520 void* primitive = mindspore::lite::MindIR_Cos_CreatePrimitive();
521
522 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
523 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
524 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
525 EXPECT_NE(nullptr, model);
526 }
527
528 /**
529 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_024
530 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
531 * @tc.type: FUNC
532 */
533 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_024, TestSize.Level0)
534 {
535 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_024");
536 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
537
538 int64_t axis {0};
539 std::vector<int64_t> offset;
540 void* primitive = mindspore::lite::MindIR_Crop_CreatePrimitive(axis, offset);
541
542 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
543 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
544 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
545 EXPECT_NE(nullptr, model);
546 }
547
548 /**
549 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_025
550 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
551 * @tc.type: FUNC
552 */
553 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_025, TestSize.Level0)
554 {
555 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_025");
556 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
557
558 int64_t blockSize {0};
559 std::string mode;
560 mindspore::lite::Format format {mindspore::lite::FORMAT_NCHW};
561 void* primitive = mindspore::lite::MindIR_DepthToSpace_CreatePrimitive(blockSize, format, mode);
562
563 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
564 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
565 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
566 EXPECT_NE(nullptr, model);
567 }
568
569 /**
570 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_026
571 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
572 * @tc.type: FUNC
573 */
574 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_026, TestSize.Level0)
575 {
576 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_026");
577 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
578
579 int64_t inputSize {0};
580 std::vector<float> scale;
581 float nmsIoUThreshold {0.0f};
582 float nmsScoreThreshold {0.0f};
583 int64_t maxDetections {0};
584 int64_t detectionsPerClass {0};
585 int64_t maxClassesPerDetection {0};
586 int64_t numClasses {0};
587 bool useRegularNms {false};
588 bool outQuantized {false};
589 mindspore::lite::Format format {mindspore::lite::FORMAT_NCHW};
590 void* primitive = mindspore::lite::MindIR_DetectionPostProcess_CreatePrimitive(format, inputSize, scale,
591 nmsIoUThreshold, nmsScoreThreshold, maxDetections, detectionsPerClass, maxClassesPerDetection,
592 numClasses, useRegularNms, outQuantized);
593
594 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
595 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
596 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
597 EXPECT_NE(nullptr, model);
598 }
599
600 /**
601 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_027
602 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
603 * @tc.type: FUNC
604 */
605 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_027, TestSize.Level0)
606 {
607 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_027");
608 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
609
610 mindspore::lite::EltwiseMode mode {mindspore::lite::ELTWISE_MODE_PROD};
611 void* primitive = mindspore::lite::MindIR_Eltwise_CreatePrimitive(mode);
612
613 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
614 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
615 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
616 EXPECT_NE(nullptr, model);
617 }
618
619 /**
620 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_028
621 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
622 * @tc.type: FUNC
623 */
624 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_028, TestSize.Level0)
625 {
626 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_028");
627 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
628
629 void* primitive = mindspore::lite::MindIR_Equal_CreatePrimitive();
630
631 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
632 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
633 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
634 EXPECT_NE(nullptr, model);
635 }
636
637 /**
638 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_029
639 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
640 * @tc.type: FUNC
641 */
642 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_029, TestSize.Level0)
643 {
644 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_029");
645 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
646
647 void* primitive = mindspore::lite::MindIR_Erf_CreatePrimitive();
648
649 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
650 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
651 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
652 EXPECT_NE(nullptr, model);
653 }
654
655 /**
656 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_030
657 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
658 * @tc.type: FUNC
659 */
660 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_030, TestSize.Level0)
661 {
662 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_030");
663 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
664
665 float base {-1.0f};
666 float scale {1.0f};
667 float shift {0.0f};
668 void* primitive = mindspore::lite::MindIR_ExpFusion_CreatePrimitive(base, scale, shift);
669
670 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
671 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
672 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
673 EXPECT_NE(nullptr, model);
674 }
675
676 /**
677 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_031
678 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
679 * @tc.type: FUNC
680 */
681 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_031, TestSize.Level0)
682 {
683 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_031");
684 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
685
686 void* primitive = mindspore::lite::MindIR_ExpandDims_CreatePrimitive();
687
688 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
689 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
690 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
691 EXPECT_NE(nullptr, model);
692 }
693
694 /**
695 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_032
696 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
697 * @tc.type: FUNC
698 */
699 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_032, TestSize.Level0)
700 {
701 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_032");
702 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
703
704 void* primitive = mindspore::lite::MindIR_Fill_CreatePrimitive();
705
706 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
707 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
708 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
709 EXPECT_NE(nullptr, model);
710 }
711
712 /**
713 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_033
714 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
715 * @tc.type: FUNC
716 */
717 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_033, TestSize.Level0)
718 {
719 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_033");
720 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
721
722 int64_t axis {1};
723 void* primitive = mindspore::lite::MindIR_Flatten_CreatePrimitive(axis);
724
725 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
726 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
727 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
728 EXPECT_NE(nullptr, model);
729 }
730
731 /**
732 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_034
733 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
734 * @tc.type: FUNC
735 */
736 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_034, TestSize.Level0)
737 {
738 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_034");
739 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
740
741 void* primitive = mindspore::lite::MindIR_Floor_CreatePrimitive();
742
743 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
744 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
745 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
746 EXPECT_NE(nullptr, model);
747 }
748
749 /**
750 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_035
751 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
752 * @tc.type: FUNC
753 */
754 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_035, TestSize.Level0)
755 {
756 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_035");
757 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
758
759 bool hasBias {false};
760 bool useAxis {false};
761 int64_t axis {0};
762 mindspore::lite::ActivationType activationType {mindspore::lite::ACTIVATION_TYPE_NO_ACTIVATION};
763 void* primitive = mindspore::lite::MindIR_FullConnection_CreatePrimitive(hasBias, useAxis,
764 axis, activationType);
765
766 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
767 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
768 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
769 EXPECT_NE(nullptr, model);
770 }
771
772 /**
773 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_036
774 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
775 * @tc.type: FUNC
776 */
777 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_036, TestSize.Level0)
778 {
779 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_036");
780 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
781
782 void* primitive = mindspore::lite::MindIR_Gather_CreatePrimitive();
783
784 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
785 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
786 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
787 EXPECT_NE(nullptr, model);
788 }
789
790 /**
791 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_037
792 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
793 * @tc.type: FUNC
794 */
795 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_037, TestSize.Level0)
796 {
797 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_037");
798 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
799
800 void* primitive = mindspore::lite::MindIR_GatherNd_CreatePrimitive();
801
802 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
803 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
804 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
805 EXPECT_NE(nullptr, model);
806 }
807
808 /**
809 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_038
810 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
811 * @tc.type: FUNC
812 */
813 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_038, TestSize.Level0)
814 {
815 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_038");
816 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
817
818 mindspore::lite::ActivationType activationType = mindspore::lite::ACTIVATION_TYPE_GELU;
819 float alpha = 0.0f;
820 float minVal = 0.0f;
821 float maxVal = 0.0f;
822 bool approximate = false;
823 void* primitive = mindspore::lite::MindIR_Activation_CreatePrimitive(activationType,
824 alpha, minVal, maxVal, approximate);
825
826 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
827 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
828 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
829 EXPECT_NE(nullptr, model);
830 }
831
832 /**
833 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_039
834 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
835 * @tc.type: FUNC
836 */
837 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_039, TestSize.Level0)
838 {
839 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_039");
840 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
841
842 void* primitive = mindspore::lite::MindIR_Greater_CreatePrimitive();
843
844 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
845 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
846 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
847 EXPECT_NE(nullptr, model);
848 }
849
850 /**
851 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_040
852 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
853 * @tc.type: FUNC
854 */
855 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_040, TestSize.Level0)
856 {
857 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_040");
858 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
859
860 void* primitive = mindspore::lite::MindIR_GreaterEqual_CreatePrimitive();
861
862 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
863 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
864 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
865 EXPECT_NE(nullptr, model);
866 }
867
868 /**
869 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_041
870 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
871 * @tc.type: FUNC
872 */
873 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_041, TestSize.Level0)
874 {
875 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_041");
876 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
877
878 mindspore::lite::ActivationType activationType = mindspore::lite::ACTIVATION_TYPE_HSIGMOID;
879 float alpha = 0.0f;
880 float minVal = 0.0f;
881 float maxVal = 0.0f;
882 bool approximate = false;
883 void* primitive = mindspore::lite::MindIR_Activation_CreatePrimitive(activationType,
884 alpha, minVal, maxVal, approximate);
885
886 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
887 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
888 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
889 EXPECT_NE(nullptr, model);
890 }
891
892 /**
893 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_042
894 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
895 * @tc.type: FUNC
896 */
897 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_042, TestSize.Level0)
898 {
899 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_042");
900 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
901
902 float epsilon {0.0f};
903 void* primitive = mindspore::lite::MindIR_InstanceNorm_CreatePrimitive(epsilon);
904
905 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
906 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
907 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
908 EXPECT_NE(nullptr, model);
909 }
910
911 /**
912 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_043
913 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
914 * @tc.type: FUNC
915 */
916 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_043, TestSize.Level0)
917 {
918 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_043");
919 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
920
921 float epsilon {0.0f};
922 void* primitive = mindspore::lite::MindIR_InstanceNorm_CreatePrimitive(epsilon);
923
924 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
925 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
926 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
927 EXPECT_NE(nullptr, model);
928 }
929
930 /**
931 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_044
932 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
933 * @tc.type: FUNC
934 */
935 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_044, TestSize.Level0)
936 {
937 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_044");
938 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
939
940 std::vector<int64_t> axis;
941 float epsilon {1e-6};
942 mindspore::lite::ActivationType activationType {mindspore::lite::ACTIVATION_TYPE_NO_ACTIVATION};
943 void* primitive = mindspore::lite::MindIR_L2NormalizeFusion_CreatePrimitive(axis, epsilon, activationType);
944
945 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
946 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
947 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
948 EXPECT_NE(nullptr, model);
949 }
950
951 /**
952 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_045
953 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
954 * @tc.type: FUNC
955 */
956 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_045, TestSize.Level0)
957 {
958 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_045");
959 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
960
961 int64_t beginNormAxis {1};
962 float epsilon {1e-7};
963 bool elementwiseAffine {true};
964 int64_t beginParamsAxis {1};
965 void* primitive = mindspore::lite::MindIR_LayerNormFusion_CreatePrimitive(beginNormAxis,
966 epsilon, elementwiseAffine, beginParamsAxis);
967
968 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
969 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
970 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
971 EXPECT_NE(nullptr, model);
972 }
973
974 /**
975 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_046
976 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
977 * @tc.type: FUNC
978 */
979 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_046, TestSize.Level0)
980 {
981 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_046");
982 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
983
984 float alpha {0.0f};
985 float minVal {0.0f};
986 float maxVal {0.0f};
987 bool approximate {false};
988 mindspore::lite::ActivationType activationType {mindspore::lite::ACTIVATION_TYPE_LEAKY_RELU};
989 void* primitive = mindspore::lite::MindIR_Activation_CreatePrimitive(activationType, alpha,
990 minVal, maxVal, approximate);
991
992 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
993 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
994 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
995 EXPECT_NE(nullptr, model);
996 }
997
998 /**
999 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_047
1000 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1001 * @tc.type: FUNC
1002 */
1003 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_047, TestSize.Level0)
1004 {
1005 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_047");
1006 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1007
1008 void* primitive = mindspore::lite::MindIR_Less_CreatePrimitive();
1009
1010 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1011 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1012 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1013 EXPECT_NE(nullptr, model);
1014 }
1015
1016 /**
1017 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_048
1018 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1019 * @tc.type: FUNC
1020 */
1021 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_048, TestSize.Level0)
1022 {
1023 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_048");
1024 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1025
1026 void* primitive = mindspore::lite::MindIR_LessEqual_CreatePrimitive();
1027
1028 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1029 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1030 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1031 EXPECT_NE(nullptr, model);
1032 }
1033
1034 /**
1035 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_049
1036 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1037 * @tc.type: FUNC
1038 */
1039 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_049, TestSize.Level0)
1040 {
1041 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_049");
1042 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1043
1044 void* primitive = mindspore::lite::MindIR_Log_CreatePrimitive();
1045
1046 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1047 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1048 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1049 EXPECT_NE(nullptr, model);
1050 }
1051
1052 /**
1053 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_050
1054 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1055 * @tc.type: FUNC
1056 */
1057 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_050, TestSize.Level0)
1058 {
1059 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_050");
1060 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1061
1062 int64_t axis {0};
1063 void* primitive = mindspore::lite::MindIR_LogSoftmax_CreatePrimitive(axis);
1064
1065 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1066 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1067 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1068 EXPECT_NE(nullptr, model);
1069 }
1070
1071 /**
1072 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_051
1073 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1074 * @tc.type: FUNC
1075 */
1076 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_051, TestSize.Level0)
1077 {
1078 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_051");
1079 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1080
1081 void* primitive = mindspore::lite::MindIR_LogicalAnd_CreatePrimitive();
1082
1083 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1084 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1085 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1086 EXPECT_NE(nullptr, model);
1087 }
1088
1089 /**
1090 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_052
1091 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1092 * @tc.type: FUNC
1093 */
1094 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_052, TestSize.Level0)
1095 {
1096 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_052");
1097 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1098
1099 void* primitive = mindspore::lite::MindIR_LogicalNot_CreatePrimitive();
1100
1101 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1102 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1103 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1104 EXPECT_NE(nullptr, model);
1105 }
1106
1107 /**
1108 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_053
1109 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1110 * @tc.type: FUNC
1111 */
1112 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_053, TestSize.Level0)
1113 {
1114 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_053");
1115 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1116
1117 void* primitive = mindspore::lite::MindIR_LogicalOr_CreatePrimitive();
1118
1119 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1120 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1121 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1122 EXPECT_NE(nullptr, model);
1123 }
1124
1125 /**
1126 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_054
1127 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1128 * @tc.type: FUNC
1129 */
1130 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_054, TestSize.Level0)
1131 {
1132 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_054");
1133 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1134
1135 int64_t depthRadius {0};
1136 float bias {0.0f};
1137 float alpha {0.0f};
1138 float beta {0.0f};
1139 std::string normRegion {"ACROSS_CHANNELS"};
1140 void* primitive = mindspore::lite::MindIR_LRN_CreatePrimitive(depthRadius, bias, alpha,
1141 beta, normRegion);
1142
1143 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1144 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1145 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1146 EXPECT_NE(nullptr, model);
1147 }
1148
1149 /**
1150 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_055
1151 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1152 * @tc.type: FUNC
1153 */
1154 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_055, TestSize.Level0)
1155 {
1156 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_055");
1157 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1158
1159 bool bidirectional {false};
1160 bool hasBias {false};
1161 int64_t inputSize {0};
1162 int64_t hiddenSize {0};
1163 int64_t numLayers {0};
1164 int64_t numDirections {0};
1165 float dropout {0.0f};
1166 float zoneoutCell {0.0f};
1167 float zoneoutHidden {0.0f};
1168 int64_t projSize {0};
1169 void* primitive = mindspore::lite::MindIR_LSTM_CreatePrimitive(bidirectional, hasBias, inputSize,
1170 hiddenSize, numLayers, numDirections, dropout, zoneoutCell, zoneoutHidden, projSize);
1171
1172 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1173 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1174 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1175 EXPECT_NE(nullptr, model);
1176 }
1177
1178 /**
1179 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_056
1180 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1181 * @tc.type: FUNC
1182 */
1183 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_056, TestSize.Level0)
1184 {
1185 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_056");
1186 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1187
1188 void* primitive = mindspore::lite::MindIR_Maximum_CreatePrimitive();
1189
1190 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1191 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1192 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1193 EXPECT_NE(nullptr, model);
1194 }
1195
1196 /**
1197 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_057
1198 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1199 * @tc.type: FUNC
1200 */
1201 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_057, TestSize.Level0)
1202 {
1203 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_057");
1204 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1205
1206 std::vector<int64_t> kernelSize;
1207 std::vector<int64_t> pad;
1208 std::vector<int64_t> strides;
1209 mindspore::lite::PadMode padMode {mindspore::lite::PAD_MODE_PAD};
1210 mindspore::lite::ActivationType activationType {mindspore::lite::ACTIVATION_TYPE_NO_ACTIVATION};
1211 mindspore::lite::Format format {mindspore::lite::FORMAT_NCHW};
1212 bool global {false};
1213 void* primitive = MindIR_MaxPoolFusion_CreatePrimitive(kernelSize, strides, pad,
1214 padMode, format, global, activationType);
1215
1216 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1217 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1218 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1219 EXPECT_NE(nullptr, model);
1220 }
1221
1222 /**
1223 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_058
1224 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1225 * @tc.type: FUNC
1226 */
1227 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_058, TestSize.Level0)
1228 {
1229 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_058");
1230 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1231
1232 void* primitive = mindspore::lite::MindIR_Minimum_CreatePrimitive();
1233
1234 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1235 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1236 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1237 EXPECT_NE(nullptr, model);
1238 }
1239
1240 /**
1241 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_059
1242 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1243 * @tc.type: FUNC
1244 */
1245 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_059, TestSize.Level0)
1246 {
1247 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_059");
1248 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1249
1250 void* primitive = mindspore::lite::MindIR_Mod_CreatePrimitive();
1251
1252 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1253 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1254 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1255 EXPECT_NE(nullptr, model);
1256 }
1257
1258 /**
1259 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_060
1260 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1261 * @tc.type: FUNC
1262 */
1263 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_060, TestSize.Level0)
1264 {
1265 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_060");
1266 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1267
1268 mindspore::lite::ActivationType activationType {mindspore::lite::ACTIVATION_TYPE_NO_ACTIVATION};
1269 void* primitive = mindspore::lite::MindIR_MulFusion_CreatePrimitive(activationType);
1270
1271 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1272 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1273 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1274 EXPECT_NE(nullptr, model);
1275 }
1276
1277 /**
1278 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_061
1279 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1280 * @tc.type: FUNC
1281 */
1282 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_061, TestSize.Level0)
1283 {
1284 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_061");
1285 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1286
1287 void* primitive = mindspore::lite::MindIR_Neg_CreatePrimitive();
1288
1289 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1290 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1291 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1292 EXPECT_NE(nullptr, model);
1293 }
1294
1295 /**
1296 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_062
1297 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1298 * @tc.type: FUNC
1299 */
1300 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_062, TestSize.Level0)
1301 {
1302 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_062");
1303 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1304
1305 void* primitive = mindspore::lite::MindIR_NotEqual_CreatePrimitive();
1306
1307 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1308 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1309 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1310 EXPECT_NE(nullptr, model);
1311 }
1312
1313 /**
1314 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_063
1315 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1316 * @tc.type: FUNC
1317 */
1318 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_063, TestSize.Level0)
1319 {
1320 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_063");
1321 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1322
1323 int64_t axis {-1};
1324 void* primitive = mindspore::lite::MindIR_OneHot_CreatePrimitive(axis);
1325
1326 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1327 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1328 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1329 EXPECT_NE(nullptr, model);
1330 }
1331
1332 /**
1333 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_064
1334 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1335 * @tc.type: FUNC
1336 */
1337 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_064, TestSize.Level0)
1338 {
1339 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_064");
1340 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1341
1342 std::vector<std::vector<int64_t>> paddings;
1343 float constantValue {0.0f};
1344 mindspore::lite::PaddingMode paddingMode {mindspore::lite::PADDING_MODE_CONSTANT};
1345 void* primitive = MindIR_PadFusion_CreatePrimitive(paddings, paddingMode, constantValue);
1346
1347 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1348 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1349 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1350 EXPECT_NE(nullptr, model);
1351 }
1352
1353 /**
1354 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_065
1355 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1356 * @tc.type: FUNC
1357 */
1358 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_065, TestSize.Level0)
1359 {
1360 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_065");
1361 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1362
1363 float scale {1.0f};
1364 float shift {0.0f};
1365 void* primitive = mindspore::lite::MindIR_PowFusion_CreatePrimitive(scale, shift);
1366
1367 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1368 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1369 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1370 EXPECT_NE(nullptr, model);
1371 }
1372
1373 /**
1374 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_066
1375 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1376 * @tc.type: FUNC
1377 */
1378 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_066, TestSize.Level0)
1379 {
1380 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_066");
1381 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1382
1383 bool channelShared{false};
1384 void* primitive = mindspore::lite::MindIR_PReLUFusion_CreatePrimitive(channelShared);
1385
1386 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1387 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1388 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1389 EXPECT_NE(nullptr, model);
1390 }
1391
1392 /**
1393 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_067
1394 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1395 * @tc.type: FUNC
1396 */
1397 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_067, TestSize.Level0)
1398 {
1399 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_067");
1400 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1401
1402 const uint64_t* srcT{nullptr};
1403 const uint64_t* dstT{nullptr};
1404 int64_t axis {0};
1405 void* primitive = mindspore::lite::MindIR_QuantDTypeCast_CreatePrimitive(*srcT, *dstT, axis);
1406
1407 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1408 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1409 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1410 EXPECT_NE(nullptr, model);
1411 }
1412
1413 /**
1414 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_068
1415 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1416 * @tc.type: FUNC
1417 */
1418 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_068, TestSize.Level0)
1419 {
1420 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_068");
1421 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1422
1423 int64_t dType {0.0f};
1424 int64_t start {0};
1425 int64_t limit {0};
1426 int64_t delta {1};
1427 void* primitive = mindspore::lite::MindIR_Range_CreatePrimitive(dType, start, limit, delta);
1428
1429 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1430 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1431 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1432 EXPECT_NE(nullptr, model);
1433 }
1434
1435 /**
1436 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_069
1437 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1438 * @tc.type: FUNC
1439 */
1440 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_069, TestSize.Level0)
1441 {
1442 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_069");
1443 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1444
1445 void* primitive = mindspore::lite::MindIR_Rank_CreatePrimitive();
1446
1447 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1448 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1449 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1450 EXPECT_NE(nullptr, model);
1451 }
1452
1453 /**
1454 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_070
1455 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1456 * @tc.type: FUNC
1457 */
1458 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_070, TestSize.Level0)
1459 {
1460 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_070");
1461 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1462
1463 void* primitive = mindspore::lite::MindIR_Reciprocal_CreatePrimitive();
1464
1465 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1466 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1467 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1468 EXPECT_NE(nullptr, model);
1469 }
1470
1471 /**
1472 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_071
1473 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1474 * @tc.type: FUNC
1475 */
1476 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_071, TestSize.Level0)
1477 {
1478 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_071");
1479 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1480
1481 mindspore::lite::ReduceMode mode {mindspore::lite::REDUCE_MODE_ALL};
1482 float coeff {0.0f};
1483 bool reduceToEnd {false};
1484 bool keepDims {false};
1485 void* primitive = mindspore::lite::MindIR_ReduceFusion_CreatePrimitive(keepDims, mode, reduceToEnd, coeff);
1486
1487 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1488 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1489 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1490 EXPECT_NE(nullptr, model);
1491 }
1492
1493 /**
1494 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_072
1495 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1496 * @tc.type: FUNC
1497 */
1498 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_072, TestSize.Level0)
1499 {
1500 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_072");
1501 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1502
1503 float alpha{0.0f};
1504 float minVal{0.0f};
1505 float maxVal{0.0f};
1506 bool approximate{false};
1507 mindspore::lite::ActivationType activationType{mindspore::lite::ACTIVATION_TYPE_RELU6};
1508 void* primitive = mindspore::lite::MindIR_Activation_CreatePrimitive(activationType, alpha,
1509 minVal, maxVal, approximate);
1510
1511 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1512 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1513 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1514 EXPECT_NE(nullptr, model);
1515 }
1516
1517 /**
1518 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_073
1519 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1520 * @tc.type: FUNC
1521 */
1522 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_073, TestSize.Level0)
1523 {
1524 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_073");
1525 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1526
1527 void* primitive = mindspore::lite::MindIR_Reshape_CreatePrimitive();
1528
1529 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1530 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1531 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1532 EXPECT_NE(nullptr, model);
1533 }
1534
1535 /**
1536 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_074
1537 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1538 * @tc.type: FUNC
1539 */
1540 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_074, TestSize.Level0)
1541 {
1542 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_074");
1543 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1544
1545 float cubicCoeff{0.0f};
1546 float extrapolationValue{0.0f};
1547 mindspore::lite::NearestMode nearestMode{mindspore::lite::NEAREST_MODE_NORMAL};
1548 mindspore::lite::ResizeMethod method {mindspore::lite::RESIZE_METHOD_LINEAR};
1549 uint64_t newHeight{0};
1550 uint64_t newWidth{0};
1551 bool preserveAspectRatio{false};
1552 mindspore::lite::CoordinateTransformMode coordinateTransformMode {
1553 mindspore::lite::COORDINATE_TRANSFORM_MODE_ASYMMETRIC};
1554 uint64_t excludeOutside{0};
1555 void* primitive = mindspore::lite::MindIR_Resize_CreatePrimitive(method, newHeight, newWidth,
1556 preserveAspectRatio, coordinateTransformMode, cubicCoeff, excludeOutside,
1557 extrapolationValue, nearestMode);
1558
1559 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1560 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1561 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1562 EXPECT_NE(nullptr, model);
1563 }
1564
1565 /**
1566 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_075
1567 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1568 * @tc.type: FUNC
1569 */
1570 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_075, TestSize.Level0)
1571 {
1572 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_075");
1573 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1574
1575 void* primitive = mindspore::lite::MindIR_Round_CreatePrimitive();
1576
1577 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1578 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1579 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1580 EXPECT_NE(nullptr, model);
1581 }
1582
1583 /**
1584 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_076
1585 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1586 * @tc.type: FUNC
1587 */
1588 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_076, TestSize.Level0)
1589 {
1590 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_076");
1591 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1592
1593 void* primitive = mindspore::lite::MindIR_Rsqrt_CreatePrimitive();
1594
1595 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1596 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1597 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1598 EXPECT_NE(nullptr, model);
1599 }
1600
1601 /**
1602 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_077
1603 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1604 * @tc.type: FUNC
1605 */
1606 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_077, TestSize.Level0)
1607 {
1608 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_077");
1609 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1610
1611 mindspore::lite::ActivationType activationType{mindspore::lite::ACTIVATION_TYPE_NO_ACTIVATION};
1612 const uint64_t* axis{nullptr};
1613 void* primitive = mindspore::lite::MindIR_ScaleFusion_CreatePrimitive(*axis, activationType);
1614
1615 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1616 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1617 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1618 EXPECT_NE(nullptr, model);
1619 }
1620
1621 /**
1622 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_078
1623 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1624 * @tc.type: FUNC
1625 */
1626 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_078, TestSize.Level0)
1627 {
1628 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_078");
1629 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1630
1631 void* primitive = mindspore::lite::MindIR_ScatterNd_CreatePrimitive();
1632
1633 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1634 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1635 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1636 EXPECT_NE(nullptr, model);
1637 }
1638
1639 /**
1640 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_079
1641 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1642 * @tc.type: FUNC
1643 */
1644 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_079, TestSize.Level0)
1645 {
1646 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_079");
1647 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1648
1649 void* primitive = mindspore::lite::MindIR_Select_CreatePrimitive();
1650
1651 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1652 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1653 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1654 EXPECT_NE(nullptr, model);
1655 }
1656
1657 /**
1658 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_080
1659 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1660 * @tc.type: FUNC
1661 */
1662 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_080, TestSize.Level0)
1663 {
1664 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_080");
1665 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1666
1667 float alpha{0.0f};
1668 float minVal{0.0f};
1669 float maxVal{0.0f};
1670 bool approximate{false};
1671 mindspore::lite::ActivationType activationType{mindspore::lite::ACTIVATION_TYPE_SIGMOID};
1672 void* primitive = mindspore::lite::MindIR_Activation_CreatePrimitive(activationType, alpha, minVal,
1673 maxVal, approximate);
1674
1675 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1676 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1677 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1678 EXPECT_NE(nullptr, model);
1679 }
1680
1681 /**
1682 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_081
1683 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1684 * @tc.type: FUNC
1685 */
1686 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_081, TestSize.Level0)
1687 {
1688 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_081");
1689 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1690
1691 void* primitive = mindspore::lite::MindIR_Sin_CreatePrimitive();
1692
1693 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1694 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1695 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1696 EXPECT_NE(nullptr, model);
1697 }
1698
1699 /**
1700 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_082
1701 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1702 * @tc.type: FUNC
1703 */
1704 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_082, TestSize.Level0)
1705 {
1706 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_082");
1707 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1708
1709 mindspore::lite::Format format {mindspore::lite::FORMAT_NCHW};
1710 int64_t blockSize {0};
1711 void* primitive = mindspore::lite::MindIR_SpaceToDepth_CreatePrimitive(blockSize, format);
1712
1713 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1714 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1715 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1716 EXPECT_NE(nullptr, model);
1717 }
1718
1719 /**
1720 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_083
1721 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1722 * @tc.type: FUNC
1723 */
1724 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_083, TestSize.Level0)
1725 {
1726 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_083");
1727 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1728
1729 void* primitive = mindspore::lite::MindIR_SparseToDense_CreatePrimitive();
1730
1731 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1732 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1733 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1734 EXPECT_NE(nullptr, model);
1735 }
1736
1737 /**
1738 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_084
1739 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1740 * @tc.type: FUNC
1741 */
1742 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_084, TestSize.Level0)
1743 {
1744 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_084");
1745 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1746
1747 void* primitive = mindspore::lite::MindIR_Square_CreatePrimitive();
1748
1749 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1750 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1751 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1752 EXPECT_NE(nullptr, model);
1753 }
1754
1755 /**
1756 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_085
1757 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1758 * @tc.type: FUNC
1759 */
1760 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_085, TestSize.Level0)
1761 {
1762 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_085");
1763 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1764
1765 float alpha {0.0f};
1766 float minVal {0.0f};
1767 float maxVal {0.0f};
1768 bool approximate {false};
1769 mindspore::lite::ActivationType activationType {mindspore::lite::ACTIVATION_TYPE_SWISH};
1770 void* primitive = mindspore::lite::MindIR_Activation_CreatePrimitive(activationType, alpha,
1771 minVal, maxVal, approximate);
1772
1773 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1774 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1775 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1776 EXPECT_NE(nullptr, model);
1777 }
1778
1779 /**
1780 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_086
1781 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1782 * @tc.type: FUNC
1783 */
1784 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_086, TestSize.Level0)
1785 {
1786 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_086");
1787 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1788
1789 int64_t axis {0};
1790 void* primitive = mindspore::lite::MindIR_Unstack_CreatePrimitive(axis);
1791
1792 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1793 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1794 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1795 EXPECT_NE(nullptr, model);
1796 }
1797
1798 /**
1799 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_087
1800 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1801 * @tc.type: FUNC
1802 */
1803 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_087, TestSize.Level0)
1804 {
1805 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_087");
1806 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1807
1808 void* primitive = mindspore::lite::MindIR_Where_CreatePrimitive();
1809
1810 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1811 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1812 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1813 EXPECT_NE(nullptr, model);
1814 }
1815
1816 /**
1817 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_088
1818 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1819 * @tc.type: FUNC
1820 */
1821 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_088, TestSize.Level0)
1822 {
1823 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_088");
1824 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1825
1826 void* primitive = mindspore::lite::MindIR_Shape_CreatePrimitive();
1827
1828 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1829 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1830 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1831 EXPECT_NE(nullptr, model);
1832 }
1833
1834 /**
1835 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_089
1836 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1837 * @tc.type: FUNC
1838 */
1839 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_089, TestSize.Level0)
1840 {
1841 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_089");
1842 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1843
1844 std::vector<int64_t> axis;
1845 void* primitive = mindspore::lite::MindIR_Unsqueeze_CreatePrimitive(axis);
1846
1847 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1848 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1849 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1850 EXPECT_NE(nullptr, model);
1851 }
1852
1853 /**
1854 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_090
1855 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1856 * @tc.type: FUNC
1857 */
1858 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_090, TestSize.Level0)
1859 {
1860 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_090");
1861 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1862
1863 int64_t inChannel{0};
1864 int64_t outChannel{0};
1865 std::vector<int64_t> kernelSize;
1866 std::vector<int64_t> strides;
1867 std::vector<int64_t> pad;
1868 std::vector<int64_t> dilation;
1869 mindspore::lite::PadMode padMode{mindspore::lite::PAD_MODE_PAD};
1870 mindspore::lite::ActivationType activationType{mindspore::lite::ACTIVATION_TYPE_NO_ACTIVATION};
1871 void* primitive = mindspore::lite::MindIR_Conv2DFusion_CreatePrimitive(kernelSize, strides,
1872 dilation, padMode, pad, inChannel, inChannel, outChannel, activationType);
1873
1874 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1875 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1876 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1877 EXPECT_NE(nullptr, model);
1878 }
1879
1880 /**
1881 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_091
1882 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1883 * @tc.type: FUNC
1884 */
1885 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_091, TestSize.Level0)
1886 {
1887 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_091");
1888 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1889
1890 mindspore::lite::ActivationType activationType {mindspore::lite::ACTIVATION_TYPE_NO_ACTIVATION};
1891 void* primitive = mindspore::lite::MindIR_DivFusion_CreatePrimitive(activationType);
1892
1893 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1894 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1895 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1896 EXPECT_NE(nullptr, model);
1897 }
1898
1899 /**
1900 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_092
1901 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1902 * @tc.type: FUNC
1903 */
1904 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_092, TestSize.Level0)
1905 {
1906 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_092");
1907 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1908
1909 mindspore::lite::ActivationType activationType{mindspore::lite::ACTIVATION_TYPE_NO_ACTIVATION};
1910 bool transposeA{false};
1911 bool transposeB{false};
1912 void* primitive = mindspore::lite::MindIR_MatMulFusion_CreatePrimitive(transposeA, transposeB, activationType);
1913
1914 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1915 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1916 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1917 EXPECT_NE(nullptr, model);
1918 }
1919
1920 /**
1921 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_093
1922 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1923 * @tc.type: FUNC
1924 */
1925 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_093, TestSize.Level0)
1926 {
1927 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_093");
1928 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1929
1930 std::vector<int64_t> axes;
1931 void* primitive = mindspore::lite::MindIR_SliceFusion_CreatePrimitive(axes);
1932
1933 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1934 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1935 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1936 EXPECT_NE(nullptr, model);
1937 }
1938
1939 /**
1940 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_094
1941 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1942 * @tc.type: FUNC
1943 */
1944 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_094, TestSize.Level0)
1945 {
1946 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_094");
1947 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1948
1949 std::vector<int64_t> axis;
1950 void* primitive = mindspore::lite::MindIR_Softmax_CreatePrimitive(axis);
1951
1952 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1953 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1954 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1955 EXPECT_NE(nullptr, model);
1956 }
1957
1958 /**
1959 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_095
1960 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1961 * @tc.type: FUNC
1962 */
1963 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_095, TestSize.Level0)
1964 {
1965 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_095");
1966 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1967
1968 std::vector<std::vector<int64_t>> paddings;
1969 std::vector<int64_t> block_shape {};
1970 void* primitive = mindspore::lite::MindIR_SpaceToBatchND_CreatePrimitive(block_shape, paddings);
1971
1972 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1973 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1974 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1975 EXPECT_NE(nullptr, model);
1976 }
1977
1978 /**
1979 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_096
1980 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
1981 * @tc.type: FUNC
1982 */
1983 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_096, TestSize.Level0)
1984 {
1985 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_096");
1986 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
1987
1988 int64_t outputNum {0};
1989 std::vector<int64_t> sizeSplits;
1990 int64_t axis {0};
1991 void* primitive = mindspore::lite::MindIR_Split_CreatePrimitive(outputNum, sizeSplits, axis);
1992
1993 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
1994 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
1995 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
1996 EXPECT_NE(nullptr, model);
1997 }
1998
1999 /**
2000 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_097
2001 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2002 * @tc.type: FUNC
2003 */
2004 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_097, TestSize.Level0)
2005 {
2006 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_097");
2007 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2008
2009 void* primitive = mindspore::lite::MindIR_Sqrt_CreatePrimitive();
2010
2011 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
2012 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
2013 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2014 EXPECT_NE(nullptr, model);
2015 }
2016
2017 /**
2018 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_098
2019 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2020 * @tc.type: FUNC
2021 */
2022 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_098, TestSize.Level0)
2023 {
2024 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_098");
2025 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2026
2027 void* primitive = mindspore::lite::MindIR_SquaredDifference_CreatePrimitive();
2028
2029 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
2030 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
2031 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2032 EXPECT_NE(nullptr, model);
2033 }
2034
2035 /**
2036 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_099
2037 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2038 * @tc.type: FUNC
2039 */
2040 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_099, TestSize.Level0)
2041 {
2042 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_099");
2043 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2044
2045 std::vector<int64_t> axis;
2046 void* primitive = mindspore::lite::MindIR_Squeeze_CreatePrimitive(axis);
2047
2048 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
2049 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
2050 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2051 EXPECT_NE(nullptr, model);
2052 }
2053
2054 /**
2055 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_100
2056 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2057 * @tc.type: FUNC
2058 */
2059 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_100, TestSize.Level0)
2060 {
2061 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_100");
2062 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2063
2064 int64_t axis = {0};
2065 void* primitive = mindspore::lite::MindIR_Stack_CreatePrimitive(axis);
2066
2067 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
2068 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
2069 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2070 EXPECT_NE(nullptr, model);
2071 }
2072
2073 /**
2074 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_101
2075 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2076 * @tc.type: FUNC
2077 */
2078 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_101, TestSize.Level0)
2079 {
2080 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_101");
2081 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2082
2083 int64_t beginMask = {0};
2084 int64_t endMask = {0};
2085 int64_t ellipsisMask = {0};
2086 int64_t newAxisMask = {0};
2087 int64_t shrinkAxisMask = {0};
2088 void* primitive = mindspore::lite::MindIR_StridedSlice_CreatePrimitive(beginMask, endMask, ellipsisMask,
2089 newAxisMask, shrinkAxisMask);
2090
2091 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
2092 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
2093 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2094 EXPECT_NE(nullptr, model);
2095 }
2096
2097 /**
2098 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_102
2099 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2100 * @tc.type: FUNC
2101 */
2102 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_102, TestSize.Level0)
2103 {
2104 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_102");
2105 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2106
2107 mindspore::lite::ActivationType activationType {mindspore::lite::ACTIVATION_TYPE_NO_ACTIVATION};
2108 void* primitive = mindspore::lite::MindIR_SubFusion_CreatePrimitive(activationType);
2109
2110 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
2111 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
2112 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2113 EXPECT_NE(nullptr, model);
2114 }
2115
2116 /**
2117 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_103
2118 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2119 * @tc.type: FUNC
2120 */
2121 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_103, TestSize.Level0)
2122 {
2123 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_103");
2124 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2125
2126 std::vector<int64_t> dims {0};
2127 void* primitive = mindspore::lite::MindIR_TileFusion_CreatePrimitive(dims);
2128
2129 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
2130 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
2131 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2132 EXPECT_NE(nullptr, model);
2133 }
2134
2135 /**
2136 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_104
2137 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2138 * @tc.type: FUNC
2139 */
2140 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_104, TestSize.Level0)
2141 {
2142 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_104");
2143 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2144
2145 int64_t axis {0};
2146 bool sorted {true};
2147 void* primitive = mindspore::lite::MindIR_TopKFusion_CreatePrimitive(sorted, axis);
2148
2149 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
2150 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
2151 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2152 EXPECT_NE(nullptr, model);
2153 }
2154
2155 /**
2156 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_105
2157 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2158 * @tc.type: FUNC
2159 */
2160 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_105, TestSize.Level0)
2161 {
2162 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_105");
2163 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2164
2165 void* primitive = mindspore::lite::MindIR_Transpose_CreatePrimitive();
2166
2167 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
2168 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
2169 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2170 EXPECT_NE(nullptr, model);
2171 }
2172
2173 /**
2174 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_106
2175 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2176 * @tc.type: FUNC
2177 */
2178 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_106, TestSize.Level0)
2179 {
2180 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_106");
2181 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2182
2183 std::vector<int64_t> axis;
2184 void* primitive = mindspore::lite::MindIR_Unsqueeze_CreatePrimitive(axis);
2185
2186 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
2187 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
2188 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2189 EXPECT_NE(nullptr, model);
2190 }
2191
2192 /**
2193 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_107
2194 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2195 * @tc.type: FUNC
2196 */
2197 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_107, TestSize.Level0)
2198 {
2199 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_107");
2200 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2201
2202 std::vector<int64_t> axis;
2203 void* primitive = mindspore::lite::MindIR_Unsqueeze_CreatePrimitive(axis);
2204
2205 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
2206 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
2207 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2208 EXPECT_NE(nullptr, model);
2209 }
2210
2211 /**
2212 * @tc.name: litegraphtohdimodeltest_litegraph_to_hdimodel_108
2213 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2214 * @tc.type: FUNC
2215 */
2216 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_litegraph_to_hdimodel_108, TestSize.Level0)
2217 {
2218 LOGE("LiteGraph_To_HDIModel litegraphtohdimodeltest_litegraph_to_hdimodel_108");
2219 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2220 MSLITE::LiteGraph::SubGraph* subGraph = new (std::nothrow) MSLITE::LiteGraph::SubGraph();
2221 subGraph->name_ = "NNRt_SubGraph";
2222 subGraph->input_indices_ = {1, 1, 1, 1};
2223 subGraph->output_indices_ = {1, 1, 1, 1};
2224 subGraph->node_indices_ = {1, 1, 1, 1};
2225
2226 void* tp = MSLITE::MindIR_Tensor_Create();
2227
2228 liteGraph.get()->all_tensors_.emplace_back(tp);
2229 liteGraph.get()->all_tensors_.emplace_back(nullptr);
2230 liteGraph.get()->sub_graphs_.emplace_back(subGraph);
2231
2232 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 1, 1, 1};
2233
2234 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2235 EXPECT_NE(nullptr, model);
2236
2237 uint8_t *mmapPtr = static_cast<uint8_t *>(mmap(nullptr,
2238 tensorBuffer.bufferSize, PROT_READ | PROT_WRITE, MAP_SHARED, tensorBuffer.fd, 0));
2239 EXPECT_EQ(MAP_FAILED, mmapPtr);
2240 }
2241
2242 /**
2243 * @tc.name: litegraphtohdimodeltest_hdimodel_destroy_001
2244 * @tc.desc: Verify the QuantParams function return nullptr in case of fd -1.
2245 * @tc.type: FUNC
2246 */
2247 HWTEST_F(LiteGraphToHDIModelTest, litegraphtohdimodeltest_hdimodel_destroy_001, TestSize.Level0)
2248 {
2249 LOGE("HDIModel_Destroy litegraphtohdimodeltest_hdimodel_destroy_001");
2250 std::shared_ptr<MSLITE::LiteGraph> liteGraph = std::make_shared<MSLITE::LiteGraph>();
2251
2252 float alpha {0.0f};
2253 float minVal {0.0f};
2254 float maxVal {0.0f};
2255 bool approximate {false};
2256 mindspore::lite::ActivationType activationType {mindspore::lite::ACTIVATION_TYPE_ABS};
2257
2258 void* primitive = mindspore::lite::MindIR_Activation_CreatePrimitive(activationType, alpha,
2259 minVal, maxVal, approximate);
2260
2261 liteGraph.get()->all_nodes_.emplace_back(getNode(primitive));
2262 OHOS::HDI::Nnrt::V1_0::SharedBuffer tensorBuffer {-1, 0, 0, 0};
2263 OHOS::HDI::Nnrt::V1_0::Model * model = LiteGraph_To_HDIModel(liteGraph.get(), tensorBuffer);
2264 EXPECT_NE(nullptr, model);
2265 HDIModel_Destroy(&model);
2266 }
2267 } // namespace UnitTest
2268 } // namespace V1
2269 } // namespace NeuralNetworkRuntime
2270 } // namespace OHOS