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 "ops/argmax_builder.h"
17
18 #include "ops_test.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22 using namespace OHOS::NeuralNetworkRuntime::Ops;
23
24 namespace OHOS {
25 namespace NeuralNetworkRuntime {
26 namespace UnitTest {
27 class ArgMaxBuilderTest : public OpsTest {
28 public:
29 void SetUp();
30 void TearDown();
31
32 void SetArgmaxAxis(OH_NN_DataType dataType,
33 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
34 void SetArgmaxKeepdims(OH_NN_DataType dataType,
35 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
36 void SetArgmaxTopK(OH_NN_DataType dataType,
37 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
38 void SetArgmaxOutMaxValue(OH_NN_DataType dataType,
39 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
40
41 public:
42 ArgMaxBuilder m_builder;
43 std::vector<uint32_t> m_inputs{0};
44 std::vector<uint32_t> m_outputs{1};
45 std::vector<uint32_t> m_params{2, 3, 4, 5};
46 std::vector<int32_t> m_input_dim{3, 3};
47 std::vector<int32_t> m_output_dim{3, 3};
48 std::vector<int32_t> m_param_dim{};
49 };
50
SetUp()51 void ArgMaxBuilderTest::SetUp() {}
52
TearDown()53 void ArgMaxBuilderTest::TearDown() {}
54
SetArgmaxAxis(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)55 void ArgMaxBuilderTest::SetArgmaxAxis(OH_NN_DataType dataType,
56 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
57 {
58 std::shared_ptr<NNTensor> tensor = TransToNNTensor(dataType, dim, quantParam, type);
59 int64_t* axisValue = new (std::nothrow) int64_t(0);
60 EXPECT_NE(nullptr, axisValue);
61 tensor->SetBuffer(axisValue, sizeof(int64_t));
62 m_allTensors.emplace_back(tensor);
63 }
64
SetArgmaxKeepdims(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)65 void ArgMaxBuilderTest::SetArgmaxKeepdims(OH_NN_DataType dataType,
66 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
67 {
68 std::shared_ptr<NNTensor> tensor = TransToNNTensor(dataType, dim, quantParam, type);
69 bool* keepdimsValue = new (std::nothrow) bool(false);
70 EXPECT_NE(nullptr, keepdimsValue);
71 tensor->SetBuffer(keepdimsValue, sizeof(bool));
72 m_allTensors.emplace_back(tensor);
73 }
74
SetArgmaxTopK(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)75 void ArgMaxBuilderTest::SetArgmaxTopK(OH_NN_DataType dataType,
76 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
77 {
78 std::shared_ptr<NNTensor> tensor = TransToNNTensor(dataType, dim, quantParam, type);
79 int64_t* topKValue = new (std::nothrow) int64_t(0);
80 EXPECT_NE(nullptr, topKValue);
81 tensor->SetBuffer(topKValue, sizeof(int64_t));
82 m_allTensors.emplace_back(tensor);
83 }
84
SetArgmaxOutMaxValue(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)85 void ArgMaxBuilderTest::SetArgmaxOutMaxValue(OH_NN_DataType dataType,
86 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
87 {
88 std::shared_ptr<NNTensor> tensor = TransToNNTensor(dataType, dim, quantParam, type);
89 bool* outMaxValueValue = new (std::nothrow) bool(false);
90 EXPECT_NE(nullptr, outMaxValueValue);
91 tensor->SetBuffer(outMaxValueValue, sizeof(bool));
92 m_allTensors.emplace_back(tensor);
93 }
94
95 /**
96 * @tc.name: argmax_build_001
97 * @tc.desc: Verify the success of the build function
98 * @tc.type: FUNC
99 */
100 HWTEST_F(ArgMaxBuilderTest, argmax_build_001, TestSize.Level1)
101 {
102 m_paramsIndex = m_params;
103 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
104 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
105
106 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
107 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
108 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
109 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
110
111 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
112 }
113 /**
114 * @tc.name: argmax_build_002
115 * @tc.desc: Verify the forbidden of the build function
116 * @tc.type: FUNC
117 */
118 HWTEST_F(ArgMaxBuilderTest, argmax_build_002, TestSize.Level1)
119 {
120 m_inputs = {0};
121 m_outputs = {1};
122 m_params = {2, 3, 4, 5};
123
124 m_paramsIndex = m_params;
125 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
126 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
127
128 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
129 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
130 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
131 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
132
133 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
134 EXPECT_EQ(OH_NN_OPERATION_FORBIDDEN, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
135 }
136
137 /**
138 * @tc.name: argmax_build_003
139 * @tc.desc: Verify the missing input of the build function
140 * @tc.type: FUNC
141 */
142 HWTEST_F(ArgMaxBuilderTest, argmax_build_003, TestSize.Level1)
143 {
144 m_inputs = {};
145 m_outputs = {1};
146 m_params = {2, 3};
147
148 m_paramsIndex = m_params;
149 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
150 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
151
152 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
153 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
154 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
155 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
156
157 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
158 }
159
160 /**
161 * @tc.name: argmax_build_004
162 * @tc.desc: Verify the missing output of the build function
163 * @tc.type: FUNC
164 */
165 HWTEST_F(ArgMaxBuilderTest, argmax_build_004, TestSize.Level1)
166 {
167 m_inputs = {0};
168 m_outputs = {};
169 m_params = {1, 2};
170
171 m_paramsIndex = m_params;
172 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
173 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
174
175 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
176 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
177 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
178 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
179
180 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
181 }
182
183 /**
184 * @tc.name: argmax_build_005
185 * @tc.desc: Verify the inputIndex out of bounds of the build function
186 * @tc.type: FUNC
187 */
188 HWTEST_F(ArgMaxBuilderTest, argmax_build_005, TestSize.Level1)
189 {
190 m_inputs = {6};
191 m_outputs = {1};
192 m_params = {2, 3};
193
194 m_paramsIndex = m_params;
195 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
196 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
197
198 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
199 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
200 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
201 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
202
203 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
204 }
205
206 /**
207 * @tc.name: argmax_build_006
208 * @tc.desc: Verify the outputIndex out of bounds of the build function
209 * @tc.type: FUNC
210 */
211 HWTEST_F(ArgMaxBuilderTest, argmax_build_006, TestSize.Level1)
212 {
213 m_inputs = {0};
214 m_outputs = {6};
215 m_params = {2, 3};
216
217 m_paramsIndex = m_params;
218 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
219 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
220
221 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
222 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
223 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
224 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
225
226 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
227 }
228
229 /**
230 * @tc.name: argmax_build_007
231 * @tc.desc: Verify the invalid axis of the build function
232 * @tc.type: FUNC
233 */
234 HWTEST_F(ArgMaxBuilderTest, argmax_build_007, TestSize.Level1)
235 {
236 m_paramsIndex = m_params;
237 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
238 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
239
240 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_FLOAT32, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
241 float* axisValueTest = new (std::nothrow) float(0);
242 EXPECT_NE(nullptr, axisValueTest);
243
244 tensor->SetBuffer(axisValueTest, sizeof(float));
245 m_allTensors.emplace_back(tensor);
246 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
247 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
248 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
249
250 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
251 }
252
253 /**
254 * @tc.name: argmax_build_008
255 * @tc.desc: Verify the invalid keepdims of the build function
256 * @tc.type: FUNC
257 */
258 HWTEST_F(ArgMaxBuilderTest, argmax_build_008, TestSize.Level1)
259 {
260 m_paramsIndex = m_params;
261 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
262 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
263
264 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
265 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
266 int64_t* keepdimsValue = new (std::nothrow) int64_t(0);
267 EXPECT_NE(nullptr, keepdimsValue);
268
269 tensor->SetBuffer(keepdimsValue, sizeof(int64_t));
270 m_allTensors.emplace_back(tensor);
271 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
272 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
273
274 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
275 }
276
277 /**
278 * @tc.name: argmax_build_009
279 * @tc.desc: Verify the invalid keepdims of the build function
280 * @tc.type: FUNC
281 */
282 HWTEST_F(ArgMaxBuilderTest, argmax_build_009, TestSize.Level1)
283 {
284 m_paramsIndex = m_params;
285 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
286 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
287
288 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
289 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
290
291 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_FLOAT32, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
292 float* topKValueTest = new (std::nothrow) float(0);
293 EXPECT_NE(nullptr, topKValueTest);
294 tensor->SetBuffer(topKValueTest, sizeof(float));
295 m_allTensors.emplace_back(tensor);
296 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
297
298 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
299 }
300
301 /**
302 * @tc.name: argmax_build_010
303 * @tc.desc: Verify the invalid keepdims of the build function
304 * @tc.type: FUNC
305 */
306 HWTEST_F(ArgMaxBuilderTest, argmax_build_010, TestSize.Level1)
307 {
308 m_paramsIndex = m_params;
309 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
310 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
311
312 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
313 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
314 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
315
316 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
317 int64_t* outMaxValue = new (std::nothrow) int64_t(0);
318 EXPECT_NE(nullptr, outMaxValue);
319 tensor->SetBuffer(outMaxValue, sizeof(int64_t));
320 m_allTensors.emplace_back(tensor);
321
322 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
323 }
324
325 /**
326 * @tc.name: argmax_build_011
327 * @tc.desc: Verify the invalid param to argmax's axis of the build function
328 * @tc.type: FUNC
329 */
330 HWTEST_F(ArgMaxBuilderTest, argmax_build_011, TestSize.Level1)
331 {
332 m_paramsIndex = m_params;
333 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
334 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
335
336 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
337 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
338 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
339 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
340
341 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
342 }
343
344 /**
345 * @tc.name: argmax_build_012
346 * @tc.desc: Verify the invalid param to argmax's keepDims of the build function
347 * @tc.type: FUNC
348 */
349 HWTEST_F(ArgMaxBuilderTest, argmax_build_012, TestSize.Level1)
350 {
351 m_paramsIndex = m_params;
352 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
353 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
354
355 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
356 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
357 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
358 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
359
360 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
361 }
362
363 /**
364 * @tc.name: argmax_build_013
365 * @tc.desc: Verify the invalid param to argmax's topK of the build function
366 * @tc.type: FUNC
367 */
368 HWTEST_F(ArgMaxBuilderTest, argmax_build_013, TestSize.Level1)
369 {
370 m_paramsIndex = m_params;
371 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
372 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
373
374 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
375 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
376 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
377 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
378
379 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
380 }
381
382 /**
383 * @tc.name: argmax_build_014
384 * @tc.desc: Verify the invalid param to argmax's outMaxValue of the build function
385 * @tc.type: FUNC
386 */
387 HWTEST_F(ArgMaxBuilderTest, argmax_build_014, TestSize.Level1)
388 {
389 m_paramsIndex = m_params;
390 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
391 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
392
393 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
394 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
395 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
396 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
397
398 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
399 }
400
401 /**
402 * @tc.name: argmax_build_015
403 * @tc.desc: Verify the argmax without set axis of the build function
404 * @tc.type: FUNC
405 */
406 HWTEST_F(ArgMaxBuilderTest, argmax_build_015, TestSize.Level1)
407 {
408 m_paramsIndex = m_params;
409 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
410 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
411
412 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
413 m_allTensors.emplace_back(tensor);
414 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
415 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
416 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
417
418 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
419 }
420
421 /**
422 * @tc.name: argmax_build_016
423 * @tc.desc: Verify the argmax without set keepdims of the build function
424 * @tc.type: FUNC
425 */
426 HWTEST_F(ArgMaxBuilderTest, argmax_build_016, TestSize.Level1)
427 {
428 m_paramsIndex = m_params;
429 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
430 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
431
432 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
433 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
434 m_allTensors.emplace_back(tensor);
435 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
436 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
437
438 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
439 }
440
441 /**
442 * @tc.name: argmax_build_017
443 * @tc.desc: Verify the argmax without set topK of the build function
444 * @tc.type: FUNC
445 */
446 HWTEST_F(ArgMaxBuilderTest, argmax_build_017, TestSize.Level1)
447 {
448 m_paramsIndex = m_params;
449 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
450 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
451
452 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
453 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
454 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
455 m_allTensors.emplace_back(tensor);
456 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
457
458 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
459 }
460
461 /**
462 * @tc.name: argmax_build_018
463 * @tc.desc: Verify the argmax without set outMaxValue of the build function
464 * @tc.type: FUNC
465 */
466 HWTEST_F(ArgMaxBuilderTest, argmax_build_018, TestSize.Level1)
467 {
468 m_paramsIndex = m_params;
469 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
470 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
471
472 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
473 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
474 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
475 std::shared_ptr<NNTensor> tensor = TransToNNTensor(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
476 m_allTensors.emplace_back(tensor);
477
478 EXPECT_EQ(OH_NN_INVALID_PARAMETER, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
479 }
480
481 /**
482 * @tc.name: argmax_getprimitive_001
483 * @tc.desc: Verify the behavior of the GetPrimitive function
484 * @tc.type: FUNC
485 */
486 HWTEST_F(ArgMaxBuilderTest, argmax_getprimitive_001, TestSize.Level1)
487 {
488 m_paramsIndex = m_params;
489 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
490 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
491
492 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
493 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
494 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
495 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
496 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_paramsIndex, m_inputsIndex, m_outputsIndex, m_allTensors));
497
498 LiteGraphTensorPtr primitive = m_builder.GetPrimitive();
499 LiteGraphTensorPtr expectPrimitive = {nullptr, DestroyLiteGraphPrimitive};
500 EXPECT_NE(expectPrimitive, primitive);
501 EXPECT_NE(nullptr, primitive);
502
503 int64_t axisReturn = mindspore::lite::MindIR_ArgMaxFusion_GetAxis(primitive.get());
504 EXPECT_EQ(axisReturn, 0);
505 bool keepdimsReturn = mindspore::lite::MindIR_ArgMaxFusion_GetKeepDims(primitive.get());
506 EXPECT_EQ(keepdimsReturn, false);
507 int64_t topKReturn = mindspore::lite::MindIR_ArgMaxFusion_GetTopK(primitive.get());
508 EXPECT_EQ(topKReturn, 0);
509 bool outMaxValueReturn = mindspore::lite::MindIR_ArgMaxFusion_GetOutMaxValue(primitive.get());
510 EXPECT_EQ(outMaxValueReturn, false);
511 }
512
513 /**
514 * @tc.name: argmax_getprimitive_002
515 * @tc.desc: Verify the behavior of the GetPrimitive function
516 * @tc.type: FUNC
517 */
518 HWTEST_F(ArgMaxBuilderTest, argmax_getprimitive_002, TestSize.Level1)
519 {
520 m_paramsIndex = m_params;
521 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_input_dim, nullptr);
522 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_output_dim, nullptr);
523
524 SetArgmaxAxis(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_AXIS);
525 SetArgmaxKeepdims(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_KEEPDIMS);
526 SetArgmaxTopK(OH_NN_INT64, m_param_dim, nullptr, OH_NN_ARG_MAX_TOP_K);
527 SetArgmaxOutMaxValue(OH_NN_BOOL, m_param_dim, nullptr, OH_NN_ARG_MAX_OUT_MAX_VALUE);
528 LiteGraphTensorPtr primitive = m_builder.GetPrimitive();
529 LiteGraphTensorPtr expectPrimitive = {nullptr, DestroyLiteGraphPrimitive};
530 EXPECT_EQ(expectPrimitive, primitive);
531 }
532 } // namespace UnitTest
533 } // namespace NeuralNetworkRuntime
534 } // namespace OHOS