1 /*
2 * Copyright (c) 2024 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/lrn_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 LRNBuilderTest : public OpsTest {
28 public:
29 void SetUp() override;
30 void TearDown() override;
31
32 protected:
33 void SaveDepthRadius(OH_NN_DataType dataType,
34 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
35 void SaveAlpha(OH_NN_DataType dataType,
36 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
37 void SaveBeta(OH_NN_DataType dataType,
38 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
39 void SaveBias(OH_NN_DataType dataType,
40 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
41 void SaveNormRegion(OH_NN_DataType dataType,
42 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
43
44 protected:
45 LRNBuilder m_builder;
46 std::vector<uint32_t> m_inputs {0};
47 std::vector<uint32_t> m_outputs {1};
48 std::vector<uint32_t> m_params {2, 3, 4, 5, 6};
49 std::vector<int32_t> m_inputDim {1, 3, 2, 2};
50 std::vector<int32_t> m_outputDim {1, 3, 2, 2};
51 std::vector<int32_t> m_paramDim {};
52 };
53
SetUp()54 void LRNBuilderTest::SetUp() {}
55
TearDown()56 void LRNBuilderTest::TearDown() {}
57
SaveDepthRadius(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)58 void LRNBuilderTest::SaveDepthRadius(OH_NN_DataType dataType,
59 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
60 {
61 std::shared_ptr<NNTensor> depthRadiusTensor = TransToNNTensor(dataType, dim, quantParam, type);
62 int64_t* depthRadiusValue = new (std::nothrow) int64_t[1] {1};
63 EXPECT_NE(nullptr, depthRadiusValue);
64 depthRadiusTensor->SetBuffer(depthRadiusValue, sizeof(int64_t));
65 m_allTensors.emplace_back(depthRadiusTensor);
66 }
67
SaveAlpha(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)68 void LRNBuilderTest::SaveAlpha(OH_NN_DataType dataType,
69 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
70 {
71 std::shared_ptr<NNTensor> alphaTensor = TransToNNTensor(dataType, dim, quantParam, type);
72 float* alphaValue = new (std::nothrow) float[1] {0.0001};
73 EXPECT_NE(nullptr, alphaValue);
74 alphaTensor->SetBuffer(alphaValue, sizeof(float));
75 m_allTensors.emplace_back(alphaTensor);
76 }
77
SaveBeta(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)78 void LRNBuilderTest::SaveBeta(OH_NN_DataType dataType,
79 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
80 {
81 std::shared_ptr<NNTensor> betaTensor = TransToNNTensor(dataType, dim, quantParam, type);
82 float* betaValue = new (std::nothrow) float[1] {0.75};
83 EXPECT_NE(nullptr, betaValue);
84 betaTensor->SetBuffer(betaValue, sizeof(float));
85 m_allTensors.emplace_back(betaTensor);
86 }
87
SaveBias(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)88 void LRNBuilderTest::SaveBias(OH_NN_DataType dataType,
89 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
90 {
91 std::shared_ptr<NNTensor> biasTensor = TransToNNTensor(dataType, dim, quantParam, type);
92 float* biasValue = new (std::nothrow) float[1] {2.0f};
93 EXPECT_NE(nullptr, biasValue);
94 biasTensor->SetBuffer(biasValue, sizeof(float));
95 m_allTensors.emplace_back(biasTensor);
96 }
97
SaveNormRegion(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)98 void LRNBuilderTest::SaveNormRegion(OH_NN_DataType dataType,
99 const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
100 {
101 std::shared_ptr<NNTensor> normRegionTensor = TransToNNTensor(dataType, dim, quantParam, type);
102 int32_t* normRegionValue = new (std::nothrow) int32_t[1] {0};
103 EXPECT_NE(nullptr, normRegionValue);
104 normRegionTensor->SetBuffer(normRegionValue, sizeof(int32_t));
105 m_allTensors.emplace_back(normRegionTensor);
106 }
107
108 /**
109 * @tc.name: lrn_build_001
110 * @tc.desc: Verify that the build function returns a successful message.
111 * @tc.type: FUNC
112 */
113 HWTEST_F(LRNBuilderTest, lrn_build_001, TestSize.Level1)
114 {
115 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
116 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
117 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
118 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
119 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
120 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
121 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
122
123 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
124 EXPECT_EQ(OH_NN_SUCCESS, ret);
125 }
126
127 /**
128 * @tc.name: lrn_build_002
129 * @tc.desc: Verify that the build function returns a failed message with true m_isBuild.
130 * @tc.type: FUNC
131 */
132 HWTEST_F(LRNBuilderTest, lrn_build_002, TestSize.Level1)
133 {
134 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
135 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
136 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
137 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
138 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
139 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
140 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
141
142 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors));
143 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
144 EXPECT_EQ(OH_NN_OPERATION_FORBIDDEN, ret);
145 }
146
147 /**
148 * @tc.name: lrn_build_003
149 * @tc.desc: Verify that the build function returns a failed message with invalided input.
150 * @tc.type: FUNC
151 */
152 HWTEST_F(LRNBuilderTest, lrn_build_003, TestSize.Level1)
153 {
154 m_inputs = {0, 1};
155 m_outputs = {2};
156 m_params = {3, 4, 5, 6, 7};
157
158 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
159 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
160 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
161 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
162 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
163 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
164 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
165
166 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
167 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
168 }
169
170 /**
171 * @tc.name: lrn_build_004
172 * @tc.desc: Verify that the build function returns a failed message with invalided output.
173 * @tc.type: FUNC
174 */
175 HWTEST_F(LRNBuilderTest, lrn_build_004, TestSize.Level1)
176 {
177 m_outputs = {1, 2};
178 m_params = {3, 4, 5, 6, 7};
179
180 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
181 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
182 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
183 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
184 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
185 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
186 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
187
188 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
189 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
190 }
191
192 /**
193 * @tc.name: lrn_build_005
194 * @tc.desc: Verify that the build function returns a failed message with empty allTensor.
195 * @tc.type: FUNC
196 */
197 HWTEST_F(LRNBuilderTest, lrn_build_005, TestSize.Level1)
198 {
199 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputs, m_outputs, m_allTensors);
200 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
201 }
202
203 /**
204 * @tc.name: lrn_build_006
205 * @tc.desc: Verify that the build function returns a failed message without output tensor.
206 * @tc.type: FUNC
207 */
208 HWTEST_F(LRNBuilderTest, lrn_build_006, TestSize.Level1)
209 {
210 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
211
212 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputs, m_allTensors);
213 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
214 }
215
216 /**
217 * @tc.name: lrn_build_007
218 * @tc.desc: Verify that the build function returns a failed message with invalid depthRadius's dataType.
219 * @tc.type: FUNC
220 */
221 HWTEST_F(LRNBuilderTest, lrn_build_007, TestSize.Level1)
222 {
223 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
224 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
225
226 std::shared_ptr<NNTensor> depthRadiusTensor = TransToNNTensor(OH_NN_FLOAT32, m_paramDim,
227 nullptr, OH_NN_LRN_DEPTH_RADIUS);
__anonff346cdd0402null228 float* depthRadiusValue = new (std::nothrow) float[1] {1.5};
229 depthRadiusTensor->SetBuffer(depthRadiusValue, sizeof(float));
230 m_allTensors.emplace_back(depthRadiusTensor);
231 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
232 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
233 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
234 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
235
236 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
237 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
238 }
239
240 /**
241 * @tc.name: lrn_build_008
242 * @tc.desc: Verify that the build function returns a failed message with invalid alpha's dataType.
243 * @tc.type: FUNC
244 */
245 HWTEST_F(LRNBuilderTest, lrn_build_008, TestSize.Level1)
246 {
247 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
248 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
249
250 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
251 std::shared_ptr<NNTensor> alphaTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
252 nullptr, OH_NN_LRN_ALPHA);
253 int64_t* alphaValue = new (std::nothrow) int64_t[1] {0};
254 alphaTensor->SetBuffer(alphaValue, sizeof(int64_t));
255 m_allTensors.emplace_back(alphaTensor);
256 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
257 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
258 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
259
260 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
261 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
262 }
263
264 /**
265 * @tc.name: lrn_build_009
266 * @tc.desc: Verify that the build function returns a failed message with invalid beta's dataType.
267 * @tc.type: FUNC
268 */
269 HWTEST_F(LRNBuilderTest, lrn_build_009, TestSize.Level1)
270 {
271 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
272 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
273
274 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
275 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
276 std::shared_ptr<NNTensor> betaTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
277 nullptr, OH_NN_LRN_BETA);
278 int64_t* betaValue = new (std::nothrow) int64_t[1] {1};
279 betaTensor->SetBuffer(betaValue, sizeof(int64_t));
280 m_allTensors.emplace_back(betaTensor);
281 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
282 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
283
284 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
285 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
286 }
287
288 /**
289 * @tc.name: lrn_build_010
290 * @tc.desc: Verify that the build function returns a failed message with invalid bias's dataType.
291 * @tc.type: FUNC
292 */
293 HWTEST_F(LRNBuilderTest, lrn_build_010, TestSize.Level1)
294 {
295 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
296 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
297
298 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
299 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
300 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
301 std::shared_ptr<NNTensor> biasTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
302 nullptr, OH_NN_LRN_BIAS);
303 int64_t* biasValue = new (std::nothrow) int64_t[2] {2};
304 biasTensor->SetBuffer(biasValue, sizeof(int64_t));
305 m_allTensors.emplace_back(biasTensor);
306 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
307
308 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
309 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
310 }
311
312 /**
313 * @tc.name: lrn_build_011
314 * @tc.desc: Verify that the build function returns a failed message with invalid normRegion's dataType.
315 * @tc.type: FUNC
316 */
317 HWTEST_F(LRNBuilderTest, lrn_build_011, TestSize.Level1)
318 {
319 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
320 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
321
322 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
323 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
324 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
325 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
326 std::shared_ptr<NNTensor> normRegionTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
327 nullptr, OH_NN_LRN_NORM_REGION);
328 int64_t* normRegionValue = new (std::nothrow) int64_t[1] {0};
329 normRegionTensor->SetBuffer(normRegionValue, sizeof(int64_t));
330 m_allTensors.emplace_back(normRegionTensor);
331
332 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
333 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
334 }
335
336 /**
337 * @tc.name: lrn_build_012
338 * @tc.desc: Verify that the build function returns a failed message with passing invalid depthRadius.
339 * @tc.type: FUNC
340 */
341 HWTEST_F(LRNBuilderTest, lrn_build_012, TestSize.Level1)
342 {
343 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
344 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
345 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
346 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
347 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
348 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
349 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
350
351 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
352 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
353 }
354
355 /**
356 * @tc.name: lrn_build_013
357 * @tc.desc: Verify that the build function returns a failed message with passing invalid alpha.
358 * @tc.type: FUNC
359 */
360 HWTEST_F(LRNBuilderTest, lrn_build_013, TestSize.Level1)
361 {
362 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
363 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
364 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
365 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
366 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
367 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
368 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
369
370 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
371 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
372 }
373
374 /**
375 * @tc.name: lrn_build_014
376 * @tc.desc: Verify that the build function returns a failed message with passing invalid beta.
377 * @tc.type: FUNC
378 */
379 HWTEST_F(LRNBuilderTest, lrn_build_014, TestSize.Level1)
380 {
381 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
382 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
383 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
384 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
385 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
386 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
387 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
388
389 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
390 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
391 }
392
393 /**
394 * @tc.name: lrn_build_015
395 * @tc.desc: Verify that the build function returns a failed message with passing invalid bias.
396 * @tc.type: FUNC
397 */
398 HWTEST_F(LRNBuilderTest, lrn_build_015, TestSize.Level1)
399 {
400 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
401 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
402 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
403 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
404 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
405 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
406 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
407
408 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
409 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
410 }
411
412 /**
413 * @tc.name: lrn_build_016
414 * @tc.desc: Verify that the build function returns a failed message with passing invalid normRegion.
415 * @tc.type: FUNC
416 */
417 HWTEST_F(LRNBuilderTest, lrn_build_016, TestSize.Level1)
418 {
419 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
420 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
421 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
422 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
423 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
424 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
425 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
426
427 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
428 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
429 }
430
431 /**
432 * @tc.name: lrn_build_017
433 * @tc.desc: Verify that the build function returns a failed message without set buffer for depthRadius.
434 * @tc.type: FUNC
435 */
436 HWTEST_F(LRNBuilderTest, lrn_build_017, TestSize.Level1)
437 {
438 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
439 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
440
441 std::shared_ptr<NNTensor> depthRadiusTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
442 nullptr, OH_NN_LRN_DEPTH_RADIUS);
443 m_allTensors.emplace_back(depthRadiusTensor);
444 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
445 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
446 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
447 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
448
449 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
450 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
451 }
452
453 /**
454 * @tc.name: lrn_build_018
455 * @tc.desc: Verify that the build function returns a failed message without set buffer for alpha.
456 * @tc.type: FUNC
457 */
458 HWTEST_F(LRNBuilderTest, lrn_build_018, TestSize.Level1)
459 {
460 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
461 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
462
463 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
464 std::shared_ptr<NNTensor> alphaTensor = TransToNNTensor(OH_NN_FLOAT32, m_paramDim,
465 nullptr, OH_NN_LRN_ALPHA);
466 m_allTensors.emplace_back(alphaTensor);
467 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
468 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
469 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
470
471 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
472 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
473 }
474
475 /**
476 * @tc.name: lrn_build_019
477 * @tc.desc: Verify that the build function returns a failed message without set buffer for beta.
478 * @tc.type: FUNC
479 */
480 HWTEST_F(LRNBuilderTest, lrn_build_019, TestSize.Level1)
481 {
482 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
483 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
484
485 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
486 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
487 std::shared_ptr<NNTensor> betaTensor = TransToNNTensor(OH_NN_FLOAT32, m_paramDim,
488 nullptr, OH_NN_LRN_BETA);
489 m_allTensors.emplace_back(betaTensor);
490 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
491 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
492
493 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
494 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
495 }
496
497 /**
498 * @tc.name: lrn_build_020
499 * @tc.desc: Verify that the build function returns a failed message without set buffer for bias.
500 * @tc.type: FUNC
501 */
502 HWTEST_F(LRNBuilderTest, lrn_build_020, TestSize.Level1)
503 {
504 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
505 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
506
507 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
508 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
509 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
510 std::shared_ptr<NNTensor> biasTensor = TransToNNTensor(OH_NN_FLOAT32, m_paramDim,
511 nullptr, OH_NN_LRN_BIAS);
512 m_allTensors.emplace_back(biasTensor);
513 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
514
515 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
516 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
517 }
518
519 /**
520 * @tc.name: lrn_build_021
521 * @tc.desc: Verify that the build function returns a failed message without set buffer for normRegion.
522 * @tc.type: FUNC
523 */
524 HWTEST_F(LRNBuilderTest, lrn_build_021, TestSize.Level1)
525 {
526 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
527 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
528
529 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
530 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
531 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
532 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
533 std::shared_ptr<NNTensor> normRegionTensor = TransToNNTensor(OH_NN_INT32, m_paramDim,
534 nullptr, OH_NN_LRN_NORM_REGION);
535 m_allTensors.emplace_back(normRegionTensor);
536
537 OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
538 EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
539 }
540
541 /**
542 * @tc.name: lrn_getprimitive_001
543 * @tc.desc: Verify that the getPrimitive function returns a successful message
544 * @tc.type: FUNC
545 */
546 HWTEST_F(LRNBuilderTest, lrn_getprimitive_001, TestSize.Level1)
547 {
548 SaveInputTensor(m_inputs, OH_NN_FLOAT32, m_inputDim, nullptr);
549 SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
550 SaveDepthRadius(OH_NN_INT64, m_paramDim, nullptr, OH_NN_LRN_DEPTH_RADIUS);
551 SaveAlpha(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_ALPHA);
552 SaveBeta(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BETA);
553 SaveBias(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_LRN_BIAS);
554 SaveNormRegion(OH_NN_INT32, m_paramDim, nullptr, OH_NN_LRN_NORM_REGION);
555
556 int64_t depthRadiusValue {1};
557 float alphaValue {0.0001};
558 float betaValue {0.75};
559 float biasValue {2.0f};
560 std::string normRegionValue = "ACROSS_CHANNELS";
561
562 EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors));
563 LiteGraphPrimitvePtr primitive = m_builder.GetPrimitive();
564 LiteGraphPrimitvePtr expectPrimitive(nullptr, DestroyLiteGraphPrimitive);
565 EXPECT_NE(expectPrimitive, primitive);
566
567 auto returnDepthRadius = mindspore::lite::MindIR_LRN_GetDepthRadius(primitive.get());
568 EXPECT_EQ(returnDepthRadius, depthRadiusValue);
569 auto returnAlpha = mindspore::lite::MindIR_LRN_GetAlpha(primitive.get());
570 EXPECT_EQ(returnAlpha, alphaValue);
571 auto returnBeta = mindspore::lite::MindIR_LRN_GetBeta(primitive.get());
572 EXPECT_EQ(returnBeta, betaValue);
573 auto returnBias = mindspore::lite::MindIR_LRN_GetBias(primitive.get());
574 EXPECT_EQ(returnBias, biasValue);
575 auto returnNormRegion = mindspore::lite::MindIR_LRN_GetNormRegion(primitive.get());
576 EXPECT_EQ(returnNormRegion, normRegionValue);
577 }
578
579 /**
580 * @tc.name: lrn_getprimitive_002
581 * @tc.desc: Verify that the getPrimitive function returns a failed message without build.
582 * @tc.type: FUNC
583 */
584 HWTEST_F(LRNBuilderTest, lrn_getprimitive_002, TestSize.Level1)
585 {
586 LiteGraphPrimitvePtr primitive = m_builder.GetPrimitive();
587 LiteGraphPrimitvePtr expectPrimitive(nullptr, DestroyLiteGraphPrimitive);
588 EXPECT_EQ(expectPrimitive, primitive);
589 }
590 }
591 }
592 }