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/detection_post_process_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 DetectionPostProcessBuilderTest : public OpsTest {
28 public:
29     void SetUp() override;
30     void TearDown() override;
31 
32 protected:
33     void SetInputTensor();
34     void SetInputSize(OH_NN_DataType dataType,
35         const std::vector<int32_t> &dim,  const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
36     void SetScale(OH_NN_DataType dataType,
37         const std::vector<int32_t> &dim,  const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
38     void SetNmsIoUThreshold(OH_NN_DataType dataType,
39         const std::vector<int32_t> &dim,  const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
40     void SetNmsScoreThreshold(OH_NN_DataType dataType,
41         const std::vector<int32_t> &dim,  const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
42     void SetMaxDetections(OH_NN_DataType dataType,
43         const std::vector<int32_t> &dim,  const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
44     void SetDetectionsPerClass(OH_NN_DataType dataType,
45         const std::vector<int32_t> &dim,  const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
46     void SetMaxClassesPerDetection(OH_NN_DataType dataType,
47         const std::vector<int32_t> &dim,  const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
48     void SetNumClasses(OH_NN_DataType dataType,
49         const std::vector<int32_t> &dim,  const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
50     void SetUseRegularNms(OH_NN_DataType dataType,
51         const std::vector<int32_t> &dim,  const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
52     void SetOutQuantized(OH_NN_DataType dataType,
53         const std::vector<int32_t> &dim,  const OH_NN_QuantParam* quantParam, OH_NN_TensorType type);
54 
55 protected:
56     DetectionPostProcessBuilder m_builder;
57     std::vector<uint32_t> m_inputs {0, 1, 2};
58     std::vector<uint32_t> m_outputs {3, 4, 5, 6};
59     std::vector<uint32_t> m_params {7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
60     std::vector<int32_t> m_inputBboxDim {1, 16};
61     std::vector<int32_t> m_inputScoresDim {1, 4};
62     std::vector<int32_t> m_inputAnchorsDim {1, 2, 8};
63     std::vector<int32_t> m_outputDim {2, 3};
64     std::vector<int32_t> m_paramDim {};
65     std::vector<int32_t> m_scaleDim {4};
66 };
67 
SetUp()68 void DetectionPostProcessBuilderTest::SetUp() {}
69 
TearDown()70 void DetectionPostProcessBuilderTest::TearDown() {}
71 
SetInputSize(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)72 void DetectionPostProcessBuilderTest::SetInputSize(OH_NN_DataType dataType,
73     const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
74 {
75     std::shared_ptr<NNTensor> inputSizeTensor = TransToNNTensor(dataType, dim, quantParam, type);
76     int64_t* inputSizeValue = new (std::nothrow) int64_t[1] {300};
77     EXPECT_NE(nullptr, inputSizeValue);
78     inputSizeTensor->SetBuffer(inputSizeValue, sizeof(int64_t));
79     m_allTensors.emplace_back(inputSizeTensor);
80 }
81 
SetScale(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)82 void DetectionPostProcessBuilderTest::SetScale(OH_NN_DataType dataType,
83     const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
84 {
85     std::shared_ptr<NNTensor> scaleTensor = TransToNNTensor(dataType, dim, quantParam, type);
86     float* scaleValue = new (std::nothrow) float[4] {10.0, 10.0, 5.0, 5.0};
87     int32_t scaleSize = 4;
88     EXPECT_NE(nullptr, scaleValue);
89     scaleTensor->SetBuffer(scaleValue, sizeof(float) * scaleSize);
90     m_allTensors.emplace_back(scaleTensor);
91 }
92 
SetNmsIoUThreshold(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)93 void DetectionPostProcessBuilderTest::SetNmsIoUThreshold(OH_NN_DataType dataType,
94     const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
95 {
96     std::shared_ptr<NNTensor> nmsIouThresholdTensor = TransToNNTensor(dataType, dim, quantParam, type);
97     float* nmsIouThresholdValue = new (std::nothrow) float[1] {0.5};
98     EXPECT_NE(nullptr, nmsIouThresholdValue);
99     nmsIouThresholdTensor->SetBuffer(nmsIouThresholdValue, sizeof(float));
100     m_allTensors.emplace_back(nmsIouThresholdTensor);
101 }
102 
SetNmsScoreThreshold(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)103 void DetectionPostProcessBuilderTest::SetNmsScoreThreshold(OH_NN_DataType dataType,
104     const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
105 {
106     std::shared_ptr<NNTensor> nmsScoreThresholdTensor = TransToNNTensor(dataType, dim, quantParam, type);
107     float* nmsScoreThresholdValue = new (std::nothrow) float[1] {0.5};
108     EXPECT_NE(nullptr, nmsScoreThresholdValue);
109     nmsScoreThresholdTensor->SetBuffer(nmsScoreThresholdValue, sizeof(float));
110     m_allTensors.emplace_back(nmsScoreThresholdTensor);
111 }
112 
SetMaxDetections(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)113 void DetectionPostProcessBuilderTest::SetMaxDetections(OH_NN_DataType dataType,
114     const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
115 {
116     std::shared_ptr<NNTensor> maxDetectionsTensor = TransToNNTensor(dataType, dim, quantParam, type);
117     int64_t* maxDetectionsValue = new (std::nothrow) int64_t[1] {5};
118     EXPECT_NE(nullptr, maxDetectionsValue);
119     maxDetectionsTensor->SetBuffer(maxDetectionsValue, sizeof(int64_t));
120     m_allTensors.emplace_back(maxDetectionsTensor);
121 }
122 
SetDetectionsPerClass(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)123 void DetectionPostProcessBuilderTest::SetDetectionsPerClass(OH_NN_DataType dataType,
124     const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
125 {
126     std::shared_ptr<NNTensor> detectionsPerClassTensor = TransToNNTensor(dataType, dim, quantParam, type);
127     int64_t* detectionsPerClassValue = new (std::nothrow) int64_t[1] {2};
128     EXPECT_NE(nullptr, detectionsPerClassValue);
129     detectionsPerClassTensor->SetBuffer(detectionsPerClassValue, sizeof(int64_t));
130     m_allTensors.emplace_back(detectionsPerClassTensor);
131 }
132 
SetMaxClassesPerDetection(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)133 void DetectionPostProcessBuilderTest::SetMaxClassesPerDetection(OH_NN_DataType dataType,
134     const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
135 {
136     std::shared_ptr<NNTensor> maxClassesPerDetectionTensor = TransToNNTensor(dataType, dim, quantParam, type);
137     int64_t* maxClassesPerDetectionValue = new (std::nothrow) int64_t[1] {1};
138     EXPECT_NE(nullptr, maxClassesPerDetectionValue);
139     maxClassesPerDetectionTensor->SetBuffer(maxClassesPerDetectionValue, sizeof(int64_t));
140     m_allTensors.emplace_back(maxClassesPerDetectionTensor);
141 }
142 
SetNumClasses(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)143 void DetectionPostProcessBuilderTest::SetNumClasses(OH_NN_DataType dataType,
144     const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
145 {
146     std::shared_ptr<NNTensor> numClassesTensor = TransToNNTensor(dataType, dim, quantParam, type);
147     int64_t* numClassesValue = new (std::nothrow) int64_t[1] {5};
148     EXPECT_NE(nullptr, numClassesValue);
149     numClassesTensor->SetBuffer(numClassesValue, sizeof(int64_t));
150     m_allTensors.emplace_back(numClassesTensor);
151 }
152 
SetUseRegularNms(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)153 void DetectionPostProcessBuilderTest::SetUseRegularNms(OH_NN_DataType dataType,
154     const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
155 {
156     std::shared_ptr<NNTensor> useRegularNmsTensor = TransToNNTensor(dataType, dim, quantParam, type);
157     bool* useRegularNmsValue = new (std::nothrow) bool(false);
158     EXPECT_NE(nullptr, useRegularNmsValue);
159     useRegularNmsTensor->SetBuffer(useRegularNmsValue, sizeof(bool));
160     m_allTensors.emplace_back(useRegularNmsTensor);
161 }
162 
SetOutQuantized(OH_NN_DataType dataType,const std::vector<int32_t> & dim,const OH_NN_QuantParam * quantParam,OH_NN_TensorType type)163 void DetectionPostProcessBuilderTest::SetOutQuantized(OH_NN_DataType dataType,
164     const std::vector<int32_t> &dim, const OH_NN_QuantParam* quantParam, OH_NN_TensorType type)
165 {
166     std::shared_ptr<NNTensor> outQuantizedTensor = TransToNNTensor(dataType, dim, quantParam, type);
167     bool* outQuantizedValue = new (std::nothrow) bool(false);
168     EXPECT_NE(nullptr, outQuantizedValue);
169     outQuantizedTensor->SetBuffer(outQuantizedValue, sizeof(bool));
170     m_allTensors.emplace_back(outQuantizedTensor);
171 }
172 
SetInputTensor()173 void DetectionPostProcessBuilderTest::SetInputTensor()
174 {
175     m_inputsIndex = m_inputs;
176     std::shared_ptr<NNTensor> bboxTensor;
177     bboxTensor = TransToNNTensor(OH_NN_FLOAT32, m_inputBboxDim, nullptr, OH_NN_TENSOR);
178     m_allTensors.emplace_back(bboxTensor);
179 
180     std::shared_ptr<NNTensor> scoresTensor;
181     scoresTensor = TransToNNTensor(OH_NN_FLOAT32, m_inputScoresDim, nullptr, OH_NN_TENSOR);
182     m_allTensors.emplace_back(scoresTensor);
183 
184     std::shared_ptr<NNTensor> anchorsTensor;
185     anchorsTensor = TransToNNTensor(OH_NN_FLOAT32, m_inputAnchorsDim, nullptr, OH_NN_TENSOR);
186     m_allTensors.emplace_back(anchorsTensor);
187 }
188 
189 /**
190  * @tc.name: detection_post_process_build_001
191  * @tc.desc: Verify that the build function returns a successful message.
192  * @tc.type: FUNC
193  */
194 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_001, TestSize.Level1)
195 {
196     SetInputTensor();
197     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
198     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
199     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
200     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
201     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
202     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
203     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
204     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
205     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
206     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
207     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
208 
209     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
210     EXPECT_EQ(OH_NN_SUCCESS, ret);
211 }
212 
213 /**
214  * @tc.name: detection_post_process_build_002
215  * @tc.desc: Verify that the build function returns a failed message with true m_isBuild.
216  * @tc.type: FUNC
217  */
218 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_002, TestSize.Level1)
219 {
220     SetInputTensor();
221     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
222     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
223     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
224     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
225     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
226     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
227     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
228     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
229     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
230     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
231     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
232 
233     EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors));
234     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
235     EXPECT_EQ(OH_NN_OPERATION_FORBIDDEN, ret);
236 }
237 
238 /**
239  * @tc.name: detection_post_process_build_003
240  * @tc.desc: Verify that the build function returns a failed message with invalided input.
241  * @tc.type: FUNC
242  */
243 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_003, TestSize.Level1)
244 {
245     m_inputs = {0, 1, 2, 3, 4};
246     m_outputs = {5, 6, 7, 8};
247     m_params = {9, 10, 11, 12, 13, 14, 15, 16, 17, 18};
248 
249     SaveInputTensor({1}, OH_NN_FLOAT32, m_inputBboxDim, nullptr);
250     SetInputTensor();
251     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
252     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
253     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
254     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
255     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
256     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
257     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
258     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
259     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
260     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
261     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
262 
263     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
264     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
265 }
266 
267 /**
268  * @tc.name: detection_post_process_build_004
269  * @tc.desc: Verify that the build function returns a failed message with invalided output.
270  * @tc.type: FUNC
271  */
272 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_004, TestSize.Level1)
273 {
274     m_outputs = {4, 5, 6, 7, 8};
275     m_params = {9, 10, 11, 12, 13, 14, 15, 16, 17, 18};
276 
277     SetInputTensor();
278     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
279     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
280     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
281     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
282     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
283     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
284     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
285     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
286     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
287     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
288     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
289 
290     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
291     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
292 }
293 
294 /**
295  * @tc.name: detection_post_process_build_005
296  * @tc.desc: Verify that the build function returns a failed message with empty allTensor.
297  * @tc.type: FUNC
298  */
299 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_005, TestSize.Level1)
300 {
301     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputs, m_outputs, m_allTensors);
302     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
303 }
304 
305 /**
306  * @tc.name: detection_post_process_build_006
307  * @tc.desc: Verify that the build function returns a failed message without output tensor.
308  * @tc.type: FUNC
309  */
310 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_006, TestSize.Level1)
311 {
312     SetInputTensor();
313 
314     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputs, m_allTensors);
315     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
316 }
317 
318 /**
319  * @tc.name: detection_post_process_build_007
320  * @tc.desc: Verify that the build function returns a failed message with invalid inputSize's dataType.
321  * @tc.type: FUNC
322  */
323 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_007, TestSize.Level1)
324 {
325     SetInputTensor();
326     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
327 
328     std::shared_ptr<NNTensor> inputSizeTensor = TransToNNTensor(OH_NN_FLOAT32, m_paramDim,
329         nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
__anone3dd87f30402null330     float* inputSizeValue = new (std::nothrow) float[1] {300.0f};
331     inputSizeTensor->SetBuffer(inputSizeValue, sizeof(float));
332     m_allTensors.emplace_back(inputSizeTensor);
333     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
334     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
335     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
336     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
337     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
338     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
339     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
340     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
341     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
342 
343     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
344     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
345 }
346 
347 /**
348  * @tc.name: detection_post_process_build_008
349  * @tc.desc: Verify that the build function returns a failed message with invalid scale's dataType.
350  * @tc.type: FUNC
351  */
352 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_008, TestSize.Level1)
353 {
354     SetInputTensor();
355     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
356 
357     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
358     std::shared_ptr<NNTensor> scaleTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
359         nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
360     int64_t* scaleValue = new (std::nothrow) int64_t[4] {10.0f, 10.0f, 5.0f, 5.0f};
361     int32_t scaleSize = 4;
362     scaleTensor->SetBuffer(scaleValue, sizeof(int64_t) * scaleSize);
363     m_allTensors.emplace_back(scaleTensor);
364     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
365     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
366     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
367     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
368     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
369     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
370     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
371     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
372 
373     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
374     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
375 }
376 
377 /**
378  * @tc.name: detection_post_process_build_009
379  * @tc.desc: Verify that the build function returns a failed message with invalid nmsIoUThreshold's dataType.
380  * @tc.type: FUNC
381  */
382 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_009, TestSize.Level1)
383 {
384     SetInputTensor();
385     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
386 
387     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
388     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
389     std::shared_ptr<NNTensor> nmsIoUThresholdTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
390         nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
391     int64_t* nmsIoUThresholdValue = new (std::nothrow) int64_t[1] {0};
392     nmsIoUThresholdTensor->SetBuffer(nmsIoUThresholdValue, sizeof(int64_t));
393     m_allTensors.emplace_back(nmsIoUThresholdTensor);
394     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
395     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
396     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
397     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
398     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
399     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
400     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
401 
402     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
403     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
404 }
405 
406 /**
407  * @tc.name: detection_post_process_build_010
408  * @tc.desc: Verify that the build function returns a failed message with invalid nmsScoreThreshold's dataType.
409  * @tc.type: FUNC
410  */
411 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_010, TestSize.Level1)
412 {
413     SetInputTensor();
414     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
415 
416     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
417     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
418     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
419     std::shared_ptr<NNTensor> nmsScoreThresholdTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
420         nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
421     int64_t* nmsScoreThresholdValue = new (std::nothrow) int64_t[1] {0};
422     nmsScoreThresholdTensor->SetBuffer(nmsScoreThresholdValue, sizeof(int64_t));
423     m_allTensors.emplace_back(nmsScoreThresholdTensor);
424     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
425     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
426     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
427     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
428     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
429     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
430 
431     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
432     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
433 }
434 
435 /**
436  * @tc.name: detection_post_process_build_011
437  * @tc.desc: Verify that the build function returns a failed message with invalid maxDetections's dataType.
438  * @tc.type: FUNC
439  */
440 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_011, TestSize.Level1)
441 {
442     SetInputTensor();
443     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
444 
445     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
446     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
447     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
448     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
449     std::shared_ptr<NNTensor> maxDetectionsTensor = TransToNNTensor(OH_NN_FLOAT32, m_paramDim,
450         nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
__anone3dd87f30502null451     float* maxDetectionsValue = new (std::nothrow) float[1] {5.0f};
452     maxDetectionsTensor->SetBuffer(maxDetectionsValue, sizeof(float));
453     m_allTensors.emplace_back(maxDetectionsTensor);
454     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
455     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
456     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
457     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
458     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
459 
460     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
461     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
462 }
463 
464 /**
465  * @tc.name: detection_post_process_build_012
466  * @tc.desc: Verify that the build function returns a failed message with invalid detectionsPerClass's dataType.
467  * @tc.type: FUNC
468  */
469 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_012, TestSize.Level1)
470 {
471     SetInputTensor();
472     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
473 
474     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
475     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
476     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
477     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
478     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
479     std::shared_ptr<NNTensor> detectionsPerClassTensor = TransToNNTensor(OH_NN_FLOAT32, m_paramDim,
480         nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
__anone3dd87f30602null481     float* detectionsPerClassValue = new (std::nothrow) float[1] {2.0f};
482     detectionsPerClassTensor->SetBuffer(detectionsPerClassValue, sizeof(float));
483     m_allTensors.emplace_back(detectionsPerClassTensor);
484     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
485     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
486     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
487     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
488 
489     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
490     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
491 }
492 
493 /**
494  * @tc.name: detection_post_process_build_013
495  * @tc.desc: Verify that the build function returns a failed message with invalid maxClassesPerDetection's dataType.
496  * @tc.type: FUNC
497  */
498 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_013, TestSize.Level1)
499 {
500     SetInputTensor();
501     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
502 
503     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
504     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
505     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
506     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
507     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
508     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
509     std::shared_ptr<NNTensor> maxClassesPerDetectionTensor = TransToNNTensor(OH_NN_FLOAT32, m_paramDim,
510         nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
__anone3dd87f30702null511     float* maxClassesPerDetectionValue = new (std::nothrow) float[2] {1.0f};
512     maxClassesPerDetectionTensor->SetBuffer(maxClassesPerDetectionValue, sizeof(float));
513     m_allTensors.emplace_back(maxClassesPerDetectionTensor);
514     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
515     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
516     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
517 
518     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
519     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
520 }
521 
522 /**
523  * @tc.name: detection_post_process_build_014
524  * @tc.desc: Verify that the build function returns a failed message with invalid numClasses's dataType.
525  * @tc.type: FUNC
526  */
527 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_014, TestSize.Level1)
528 {
529     SetInputTensor();
530     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
531 
532     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
533     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
534     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
535     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
536     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
537     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
538     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
539     std::shared_ptr<NNTensor> numClassesTensor = TransToNNTensor(OH_NN_FLOAT32, m_paramDim,
540         nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
__anone3dd87f30802null541     float* numClassesValue = new (std::nothrow) float[1] {5.0f};
542     numClassesTensor->SetBuffer(numClassesValue, sizeof(float));
543     m_allTensors.emplace_back(numClassesTensor);
544     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
545     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
546     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
547 
548     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
549     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
550 }
551 
552 /**
553  * @tc.name: detection_post_process_build_015
554  * @tc.desc: Verify that the build function returns a failed message with invalid useRegularNms's dataType.
555  * @tc.type: FUNC
556  */
557 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_015, TestSize.Level1)
558 {
559     SetInputTensor();
560     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
561 
562     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
563     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
564     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
565     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
566     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
567     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
568     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
569     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
570     std::shared_ptr<NNTensor> useRegularNmsTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
571         nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
572     int64_t* useRegularNmsValue = new (std::nothrow) int64_t[1] {0};
573     useRegularNmsTensor->SetBuffer(useRegularNmsValue, sizeof(int64_t));
574     m_allTensors.emplace_back(useRegularNmsTensor);
575     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
576 
577     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
578     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
579 }
580 
581 /**
582  * @tc.name: detection_post_process_build_016
583  * @tc.desc: Verify that the build function returns a failed message with invalid outQuantized's dataType.
584  * @tc.type: FUNC
585  */
586 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_016, TestSize.Level1)
587 {
588     SetInputTensor();
589     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
590 
591     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
592     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
593     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
594     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
595     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
596     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
597     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
598     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
599     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
600     std::shared_ptr<NNTensor> outQuantizedTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
601         nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
602     int64_t* outQuantizedValue = new (std::nothrow) int64_t[1] {0};
603     outQuantizedTensor->SetBuffer(outQuantizedValue, sizeof(int64_t));
604     m_allTensors.emplace_back(outQuantizedTensor);
605 
606     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
607     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
608 }
609 
610 /**
611  * @tc.name: detection_post_process_build_017
612  * @tc.desc: Verify that the build function returns a failed message with passing invalid inputSize.
613  * @tc.type: FUNC
614  */
615 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_017, TestSize.Level1)
616 {
617     SetInputTensor();
618     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
619 
620     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
621     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
622     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
623     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
624     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
625     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
626     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
627     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
628     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
629     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
630 
631     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
632     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
633 }
634 
635 /**
636  * @tc.name: detection_post_process_build_018
637  * @tc.desc: Verify that the build function returns a failed message with passing invalid scale.
638  * @tc.type: FUNC
639  */
640 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_018, TestSize.Level1)
641 {
642     SetInputTensor();
643     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
644 
645     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
646     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
647     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
648     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
649     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
650     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
651     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
652     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
653     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
654     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
655 
656     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
657     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
658 }
659 
660 /**
661  * @tc.name: detection_post_process_build_019
662  * @tc.desc: Verify that the build function returns a failed message with passing invalid nmsIoUThreshold.
663  * @tc.type: FUNC
664  */
665 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_019, TestSize.Level1)
666 {
667     SetInputTensor();
668     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
669 
670     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
671     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
672     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
673     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
674     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
675     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
676     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
677     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
678     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
679     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
680 
681     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
682     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
683 }
684 
685 /**
686  * @tc.name: detection_post_process_build_020
687  * @tc.desc: Verify that the build function returns a failed message with passing invalid nmsScoreThreshold.
688  * @tc.type: FUNC
689  */
690 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_020, TestSize.Level1)
691 {
692     SetInputTensor();
693     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
694 
695     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
696     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
697     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
698     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
699     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
700     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
701     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
702     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
703     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
704     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
705 
706     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
707     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
708 }
709 
710 /**
711  * @tc.name: detection_post_process_build_021
712  * @tc.desc: Verify that the build function returns a failed message with passing invalid maxDetections.
713  * @tc.type: FUNC
714  */
715 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_021, TestSize.Level1)
716 {
717     SetInputTensor();
718     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
719 
720     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
721     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
722     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
723     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
724     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
725     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
726     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
727     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
728     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
729     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
730 
731     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
732     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
733 }
734 
735 /**
736  * @tc.name: detection_post_process_build_022
737  * @tc.desc: Verify that the build function returns a failed message with passing invalid detectionsPerClass.
738  * @tc.type: FUNC
739  */
740 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_022, TestSize.Level1)
741 {
742     SetInputTensor();
743     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
744 
745     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
746     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
747     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
748     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
749     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
750     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
751     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
752     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
753     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
754     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
755 
756     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
757     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
758 }
759 
760 /**
761  * @tc.name: detection_post_process_build_023
762  * @tc.desc: Verify that the build function returns a failed message with passing invalid maxClassesPerDetection.
763  * @tc.type: FUNC
764  */
765 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_023, TestSize.Level1)
766 {
767     SetInputTensor();
768     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
769 
770     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
771     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
772     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
773     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
774     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
775     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
776     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
777     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
778     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
779     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
780 
781     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
782     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
783 }
784 
785 /**
786  * @tc.name: detection_post_process_build_024
787  * @tc.desc: Verify that the build function returns a failed message with passing invalid numClasses.
788  * @tc.type: FUNC
789  */
790 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_024, TestSize.Level1)
791 {
792     SetInputTensor();
793     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
794 
795     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
796     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
797     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
798     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
799     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
800     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
801     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
802     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
803     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
804     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
805 
806     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
807     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
808 }
809 
810 /**
811  * @tc.name: detection_post_process_build_025
812  * @tc.desc: Verify that the build function returns a failed message with passing invalid useRegularNms.
813  * @tc.type: FUNC
814  */
815 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_025, TestSize.Level1)
816 {
817     SetInputTensor();
818     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
819 
820     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
821     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
822     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
823     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
824     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
825     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
826     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
827     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
828     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
829     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
830 
831     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
832     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
833 }
834 
835 /**
836  * @tc.name: detection_post_process_build_026
837  * @tc.desc: Verify that the build function returns a failed message with passing invalid outQuantized.
838  * @tc.type: FUNC
839  */
840 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_026, TestSize.Level1)
841 {
842     SetInputTensor();
843     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
844 
845     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
846     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
847     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
848     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
849     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
850     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
851     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
852     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
853     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
854     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_MUL_ACTIVATION_TYPE);
855 
856     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
857     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
858 }
859 
860 /**
861  * @tc.name: detection_post_process_build_027
862  * @tc.desc: Verify that the build function returns a failed message without set buffer for InputSize.
863  * @tc.type: FUNC
864  */
865 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_027, TestSize.Level1)
866 {
867     SetInputTensor();
868     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
869 
870     std::shared_ptr<NNTensor> inputSizeTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
871         nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
872     m_allTensors.emplace_back(inputSizeTensor);
873     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
874     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
875     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
876     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
877     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
878     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
879     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
880     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
881     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
882 
883     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
884     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
885 }
886 
887 /**
888  * @tc.name: detection_post_process_build_028
889  * @tc.desc: Verify that the build function returns a failed message without set buffer for scale.
890  * @tc.type: FUNC
891  */
892 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_028, TestSize.Level1)
893 {
894     SetInputTensor();
895     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
896 
897     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
898     std::shared_ptr<NNTensor> scaleTensor = TransToNNTensor(OH_NN_FLOAT32, m_paramDim,
899         nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
900     m_allTensors.emplace_back(scaleTensor);
901     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
902     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
903     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
904     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
905     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
906     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
907     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
908     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
909 
910     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
911     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
912 }
913 
914 /**
915  * @tc.name: detection_post_process_build_029
916  * @tc.desc: Verify that the build function returns a failed message without set buffer for nmsIoUThreshold.
917  * @tc.type: FUNC
918  */
919 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_029, TestSize.Level1)
920 {
921     SetInputTensor();
922     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
923 
924     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
925     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
926     std::shared_ptr<NNTensor> nmsIoUThresholdTensor = TransToNNTensor(OH_NN_FLOAT32, m_paramDim,
927         nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
928     m_allTensors.emplace_back(nmsIoUThresholdTensor);
929     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
930     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
931     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
932     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
933     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
934     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
935     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
936 
937     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
938     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
939 }
940 
941 /**
942  * @tc.name: detection_post_process_build_030
943  * @tc.desc: Verify that the build function returns a failed message without set buffer for nmsScoreThreshold.
944  * @tc.type: FUNC
945  */
946 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_030, TestSize.Level1)
947 {
948     SetInputTensor();
949     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
950 
951     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
952     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
953     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
954     std::shared_ptr<NNTensor> nmsScoreThresholdTensor = TransToNNTensor(OH_NN_FLOAT32, m_paramDim,
955         nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
956     m_allTensors.emplace_back(nmsScoreThresholdTensor);
957     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
958     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
959     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
960     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
961     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
962     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
963 
964     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
965     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
966 }
967 
968 /**
969  * @tc.name: detection_post_process_build_031
970  * @tc.desc: Verify that the build function returns a failed message without set buffer for maxDetections.
971  * @tc.type: FUNC
972  */
973 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_031, TestSize.Level1)
974 {
975     SetInputTensor();
976     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
977 
978     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
979     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
980     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
981     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
982     std::shared_ptr<NNTensor> maxDetectionsTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
983         nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
984     m_allTensors.emplace_back(maxDetectionsTensor);
985     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
986     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
987     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
988     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
989     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
990 
991     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
992     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
993 }
994 
995 /**
996  * @tc.name: detection_post_process_build_032
997  * @tc.desc: Verify that the build function returns a failed message without set buffer for detectionsPerClass.
998  * @tc.type: FUNC
999  */
1000 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_032, TestSize.Level1)
1001 {
1002     SetInputTensor();
1003     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
1004 
1005     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
1006     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
1007     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
1008     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
1009     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
1010     std::shared_ptr<NNTensor> detectionsPerClassTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
1011         nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
1012     m_allTensors.emplace_back(detectionsPerClassTensor);
1013     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
1014     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
1015     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
1016     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
1017 
1018     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
1019     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
1020 }
1021 
1022 /**
1023  * @tc.name: detection_post_process_build_033
1024  * @tc.desc: Verify that the build function returns a failed message without set buffer for maxClassesPerDetection.
1025  * @tc.type: FUNC
1026  */
1027 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_033, TestSize.Level1)
1028 {
1029     SetInputTensor();
1030     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
1031 
1032     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
1033     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
1034     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
1035     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
1036     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
1037     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
1038     std::shared_ptr<NNTensor> maxClassesPerDetectionTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
1039         nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
1040     m_allTensors.emplace_back(maxClassesPerDetectionTensor);
1041     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
1042     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
1043     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
1044 
1045     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
1046     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
1047 }
1048 
1049 /**
1050  * @tc.name: detection_post_process_build_034
1051  * @tc.desc: Verify that the build function returns a failed message without set buffer for numClasses.
1052  * @tc.type: FUNC
1053  */
1054 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_034, TestSize.Level1)
1055 {
1056     SetInputTensor();
1057     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
1058 
1059     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
1060     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
1061     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
1062     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
1063     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
1064     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
1065     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
1066     std::shared_ptr<NNTensor> numClassesTensor = TransToNNTensor(OH_NN_INT64, m_paramDim,
1067         nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
1068     m_allTensors.emplace_back(numClassesTensor);
1069     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
1070     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
1071 
1072     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
1073     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
1074 }
1075 
1076 /**
1077  * @tc.name: detection_post_process_build_035
1078  * @tc.desc: Verify that the build function returns a failed message without set buffer for useRegularNms.
1079  * @tc.type: FUNC
1080  */
1081 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_035, TestSize.Level1)
1082 {
1083     SetInputTensor();
1084     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
1085 
1086     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
1087     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
1088     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
1089     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
1090     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
1091     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
1092     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
1093     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
1094     std::shared_ptr<NNTensor> useRegularNmsTensor = TransToNNTensor(OH_NN_BOOL, m_paramDim,
1095         nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
1096     m_allTensors.emplace_back(useRegularNmsTensor);
1097     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
1098 
1099     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
1100     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
1101 }
1102 
1103 /**
1104  * @tc.name: detection_post_process_build_036
1105  * @tc.desc: Verify that the build function returns a failed message without set buffer for outQuantized.
1106  * @tc.type: FUNC
1107  */
1108 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_build_036, TestSize.Level1)
1109 {
1110     SetInputTensor();
1111     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
1112 
1113     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
1114     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
1115     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
1116     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
1117     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
1118     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
1119     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
1120     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
1121     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
1122     std::shared_ptr<NNTensor> outQuantizedTensor = TransToNNTensor(OH_NN_BOOL, m_paramDim,
1123         nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
1124     m_allTensors.emplace_back(outQuantizedTensor);
1125 
1126     OH_NN_ReturnCode ret = m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors);
1127     EXPECT_EQ(OH_NN_INVALID_PARAMETER, ret);
1128 }
1129 
1130 /**
1131  * @tc.name: detection_post_process_getprimitive_001
1132  * @tc.desc: Verify that the getPrimitive function returns a successful message
1133  * @tc.type: FUNC
1134  */
1135 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_getprimitive_001, TestSize.Level1)
1136 {
1137     SetInputTensor();
1138     SaveOutputTensor(m_outputs, OH_NN_FLOAT32, m_outputDim, nullptr);
1139 
1140     SetInputSize(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_INPUT_SIZE);
1141     SetScale(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_SCALE);
1142     SetNmsIoUThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_IOU_THRESHOLD);
1143     SetNmsScoreThreshold(OH_NN_FLOAT32, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NMS_SCORE_THRESHOLD);
1144     SetMaxDetections(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_DETECTIONS);
1145     SetDetectionsPerClass(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_DETECTIONS_PER_CLASS);
1146     SetMaxClassesPerDetection(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_MAX_CLASSES_PER_DETECTION);
1147     SetNumClasses(OH_NN_INT64, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_NUM_CLASSES);
1148     SetUseRegularNms(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_USE_REGULAR_NMS);
1149     SetOutQuantized(OH_NN_BOOL, m_paramDim, nullptr, OH_NN_DETECTION_POST_PROCESS_OUT_QUANTIZED);
1150 
1151     int64_t inputSizeValue = 300;
1152     std::vector<float> scaleValue = {10.0f, 10.0f, 5.0f, 5.0f};
1153     float nmsIoUThresholdValue = 0.5f;
1154     float nmsScoreThresholdValue = 0.5f;
1155     int64_t maxDetectionsValue = 5;
1156     int64_t detectionsPerClassValue = 2;
1157     int64_t maxClassesPerDetectionValue = 1;
1158     int64_t numClassesValue = 5;
1159     bool useRegularNmsValue = false;
1160     bool outQuantizedValue = false;
1161 
1162     EXPECT_EQ(OH_NN_SUCCESS, m_builder.Build(m_params, m_inputsIndex, m_outputsIndex, m_allTensors));
1163     LiteGraphPrimitvePtr primitive = m_builder.GetPrimitive();
1164     LiteGraphPrimitvePtr expectPrimitive(nullptr, DestroyLiteGraphPrimitive);
1165     EXPECT_NE(expectPrimitive, primitive);
1166 
1167     auto returnInputSize = mindspore::lite::MindIR_DetectionPostProcess_GetInputSize(primitive.get());
1168     EXPECT_EQ(returnInputSize, inputSizeValue);
1169     auto returnScale = mindspore::lite::MindIR_DetectionPostProcess_GetScale(primitive.get());
1170     auto returnScaleSize = returnScale.size();
1171     for (size_t i = 0; i < returnScaleSize; ++i) {
1172         EXPECT_EQ(returnScale[i], scaleValue[i]);
1173     }
1174     auto returnNmsIoUThresholdValue = mindspore::lite::MindIR_DetectionPostProcess_GetNmsIouThreshold(primitive.get());
1175     EXPECT_EQ(returnNmsIoUThresholdValue, nmsIoUThresholdValue);
1176     auto returnNmsScoreThreshold = mindspore::lite::MindIR_DetectionPostProcess_GetNmsScoreThreshold(primitive.get());
1177     EXPECT_EQ(returnNmsScoreThreshold, nmsScoreThresholdValue);
1178     auto returnMaxDetections = mindspore::lite::MindIR_DetectionPostProcess_GetMaxDetections(primitive.get());
1179     EXPECT_EQ(returnMaxDetections, maxDetectionsValue);
1180     auto returnDetectionsPerClass =
1181         mindspore::lite::MindIR_DetectionPostProcess_GetDetectionsPerClass(primitive.get());
1182     EXPECT_EQ(returnDetectionsPerClass, detectionsPerClassValue);
1183     auto returnMaxClassesPerDetection =
1184         mindspore::lite::MindIR_DetectionPostProcess_GetMaxClassesPerDetection(primitive.get());
1185     EXPECT_EQ(returnMaxClassesPerDetection, maxClassesPerDetectionValue);
1186     auto returnNumClasses = mindspore::lite::MindIR_DetectionPostProcess_GetNumClasses(primitive.get());
1187     EXPECT_EQ(returnNumClasses, numClassesValue);
1188     auto returnUseRegularNms = mindspore::lite::MindIR_DetectionPostProcess_GetUseRegularNms(primitive.get());
1189     EXPECT_EQ(returnUseRegularNms, useRegularNmsValue);
1190     auto returnOutQuantized = mindspore::lite::MindIR_DetectionPostProcess_GetOutQuantized(primitive.get());
1191     EXPECT_EQ(returnOutQuantized, outQuantizedValue);
1192 }
1193 
1194 /**
1195  * @tc.name: detection_post_process_getprimitive_002
1196  * @tc.desc: Verify that the getPrimitive function returns a failed message without build.
1197  * @tc.type: FUNC
1198  */
1199 HWTEST_F(DetectionPostProcessBuilderTest, detection_post_process_getprimitive_002, TestSize.Level1)
1200 {
1201     LiteGraphPrimitvePtr primitive = m_builder.GetPrimitive();
1202     LiteGraphPrimitvePtr expectPrimitive(nullptr, DestroyLiteGraphPrimitive);
1203     EXPECT_EQ(expectPrimitive, primitive);
1204 }
1205 }
1206 }
1207 }