1 // Generated from minimum.mod.py
2 // DO NOT EDIT
3 // clang-format off
4 #include "TestHarness.h"
5 using namespace test_helper; // NOLINT(google-build-using-namespace)
6
7 namespace generated_tests::minimum {
8
get_test_model_simple()9 const TestModel& get_test_model_simple() {
10 static TestModel model = {
11 .main = {
12 .operands = {{ // input0
13 .type = TestOperandType::TENSOR_FLOAT32,
14 .dimensions = {3, 1, 2},
15 .numberOfConsumers = 1,
16 .scale = 0.0f,
17 .zeroPoint = 0,
18 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
19 .channelQuant = {},
20 .isIgnored = false,
21 .data = TestBuffer::createFromVector<float>({1.0f, 0.0f, -1.0f, 11.0f, -2.0f, -1.44f})
22 }, { // input1
23 .type = TestOperandType::TENSOR_FLOAT32,
24 .dimensions = {3, 1, 2},
25 .numberOfConsumers = 1,
26 .scale = 0.0f,
27 .zeroPoint = 0,
28 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29 .channelQuant = {},
30 .isIgnored = false,
31 .data = TestBuffer::createFromVector<float>({-1.0f, 0.0f, 1.0f, 12.0f, -3.0f, -1.43f})
32 }, { // output0
33 .type = TestOperandType::TENSOR_FLOAT32,
34 .dimensions = {3, 1, 2},
35 .numberOfConsumers = 0,
36 .scale = 0.0f,
37 .zeroPoint = 0,
38 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
39 .channelQuant = {},
40 .isIgnored = false,
41 .data = TestBuffer::createFromVector<float>({-1.0f, 0.0f, -1.0f, 11.0f, -3.0f, -1.44f})
42 }},
43 .operations = {{
44 .type = TestOperationType::MINIMUM,
45 .inputs = {0, 1},
46 .outputs = {2}
47 }},
48 .inputIndexes = {0, 1},
49 .outputIndexes = {2}
50 },
51 .referenced = {},
52 .isRelaxed = false,
53 .expectedMultinomialDistributionTolerance = 0,
54 .expectFailure = false,
55 .minSupportedVersion = TestHalVersion::V1_2
56 };
57 return model;
58 }
59
60 const auto dummy_test_model_simple = TestModelManager::get().add("minimum_simple", get_test_model_simple());
61
62 } // namespace generated_tests::minimum
63
64 namespace generated_tests::minimum {
65
get_test_model_simple_all_inputs_as_internal()66 const TestModel& get_test_model_simple_all_inputs_as_internal() {
67 static TestModel model = {
68 .main = {
69 .operands = {{ // input0
70 .type = TestOperandType::TENSOR_FLOAT32,
71 .dimensions = {3, 1, 2},
72 .numberOfConsumers = 1,
73 .scale = 0.0f,
74 .zeroPoint = 0,
75 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
76 .channelQuant = {},
77 .isIgnored = false,
78 .data = TestBuffer::createFromVector<float>({})
79 }, { // input1
80 .type = TestOperandType::TENSOR_FLOAT32,
81 .dimensions = {3, 1, 2},
82 .numberOfConsumers = 1,
83 .scale = 0.0f,
84 .zeroPoint = 0,
85 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
86 .channelQuant = {},
87 .isIgnored = false,
88 .data = TestBuffer::createFromVector<float>({})
89 }, { // output0
90 .type = TestOperandType::TENSOR_FLOAT32,
91 .dimensions = {3, 1, 2},
92 .numberOfConsumers = 0,
93 .scale = 0.0f,
94 .zeroPoint = 0,
95 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
96 .channelQuant = {},
97 .isIgnored = false,
98 .data = TestBuffer::createFromVector<float>({-1.0f, 0.0f, -1.0f, 11.0f, -3.0f, -1.44f})
99 }, { // input0_new
100 .type = TestOperandType::TENSOR_FLOAT32,
101 .dimensions = {3, 1, 2},
102 .numberOfConsumers = 1,
103 .scale = 0.0f,
104 .zeroPoint = 0,
105 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
106 .channelQuant = {},
107 .isIgnored = false,
108 .data = TestBuffer::createFromVector<float>({1.0f, 0.0f, -1.0f, 11.0f, -2.0f, -1.44f})
109 }, { // placeholder
110 .type = TestOperandType::TENSOR_FLOAT32,
111 .dimensions = {1},
112 .numberOfConsumers = 1,
113 .scale = 0.0f,
114 .zeroPoint = 0,
115 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
116 .channelQuant = {},
117 .isIgnored = false,
118 .data = TestBuffer::createFromVector<float>({0.0f})
119 }, { // param
120 .type = TestOperandType::INT32,
121 .dimensions = {},
122 .numberOfConsumers = 1,
123 .scale = 0.0f,
124 .zeroPoint = 0,
125 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
126 .channelQuant = {},
127 .isIgnored = false,
128 .data = TestBuffer::createFromVector<int32_t>({0})
129 }, { // input1_new
130 .type = TestOperandType::TENSOR_FLOAT32,
131 .dimensions = {3, 1, 2},
132 .numberOfConsumers = 1,
133 .scale = 0.0f,
134 .zeroPoint = 0,
135 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
136 .channelQuant = {},
137 .isIgnored = false,
138 .data = TestBuffer::createFromVector<float>({-1.0f, 0.0f, 1.0f, 12.0f, -3.0f, -1.43f})
139 }, { // placeholder1
140 .type = TestOperandType::TENSOR_FLOAT32,
141 .dimensions = {1},
142 .numberOfConsumers = 1,
143 .scale = 0.0f,
144 .zeroPoint = 0,
145 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
146 .channelQuant = {},
147 .isIgnored = false,
148 .data = TestBuffer::createFromVector<float>({0.0f})
149 }, { // param1
150 .type = TestOperandType::INT32,
151 .dimensions = {},
152 .numberOfConsumers = 1,
153 .scale = 0.0f,
154 .zeroPoint = 0,
155 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
156 .channelQuant = {},
157 .isIgnored = false,
158 .data = TestBuffer::createFromVector<int32_t>({0})
159 }},
160 .operations = {{
161 .type = TestOperationType::ADD,
162 .inputs = {3, 4, 5},
163 .outputs = {0}
164 }, {
165 .type = TestOperationType::ADD,
166 .inputs = {6, 7, 8},
167 .outputs = {1}
168 }, {
169 .type = TestOperationType::MINIMUM,
170 .inputs = {0, 1},
171 .outputs = {2}
172 }},
173 .inputIndexes = {3, 6},
174 .outputIndexes = {2}
175 },
176 .referenced = {},
177 .isRelaxed = false,
178 .expectedMultinomialDistributionTolerance = 0,
179 .expectFailure = false,
180 .minSupportedVersion = TestHalVersion::V1_2
181 };
182 return model;
183 }
184
185 const auto dummy_test_model_simple_all_inputs_as_internal = TestModelManager::get().add("minimum_simple_all_inputs_as_internal", get_test_model_simple_all_inputs_as_internal());
186
187 } // namespace generated_tests::minimum
188
189 namespace generated_tests::minimum {
190
get_test_model_simple_relaxed()191 const TestModel& get_test_model_simple_relaxed() {
192 static TestModel model = {
193 .main = {
194 .operands = {{ // input0
195 .type = TestOperandType::TENSOR_FLOAT32,
196 .dimensions = {3, 1, 2},
197 .numberOfConsumers = 1,
198 .scale = 0.0f,
199 .zeroPoint = 0,
200 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
201 .channelQuant = {},
202 .isIgnored = false,
203 .data = TestBuffer::createFromVector<float>({1.0f, 0.0f, -1.0f, 11.0f, -2.0f, -1.44f})
204 }, { // input1
205 .type = TestOperandType::TENSOR_FLOAT32,
206 .dimensions = {3, 1, 2},
207 .numberOfConsumers = 1,
208 .scale = 0.0f,
209 .zeroPoint = 0,
210 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
211 .channelQuant = {},
212 .isIgnored = false,
213 .data = TestBuffer::createFromVector<float>({-1.0f, 0.0f, 1.0f, 12.0f, -3.0f, -1.43f})
214 }, { // output0
215 .type = TestOperandType::TENSOR_FLOAT32,
216 .dimensions = {3, 1, 2},
217 .numberOfConsumers = 0,
218 .scale = 0.0f,
219 .zeroPoint = 0,
220 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
221 .channelQuant = {},
222 .isIgnored = false,
223 .data = TestBuffer::createFromVector<float>({-1.0f, 0.0f, -1.0f, 11.0f, -3.0f, -1.44f})
224 }},
225 .operations = {{
226 .type = TestOperationType::MINIMUM,
227 .inputs = {0, 1},
228 .outputs = {2}
229 }},
230 .inputIndexes = {0, 1},
231 .outputIndexes = {2}
232 },
233 .referenced = {},
234 .isRelaxed = true,
235 .expectedMultinomialDistributionTolerance = 0,
236 .expectFailure = false,
237 .minSupportedVersion = TestHalVersion::UNKNOWN
238 };
239 return model;
240 }
241
242 const auto dummy_test_model_simple_relaxed = TestModelManager::get().add("minimum_simple_relaxed", get_test_model_simple_relaxed());
243
244 } // namespace generated_tests::minimum
245
246 namespace generated_tests::minimum {
247
get_test_model_simple_relaxed_all_inputs_as_internal()248 const TestModel& get_test_model_simple_relaxed_all_inputs_as_internal() {
249 static TestModel model = {
250 .main = {
251 .operands = {{ // input0
252 .type = TestOperandType::TENSOR_FLOAT32,
253 .dimensions = {3, 1, 2},
254 .numberOfConsumers = 1,
255 .scale = 0.0f,
256 .zeroPoint = 0,
257 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
258 .channelQuant = {},
259 .isIgnored = false,
260 .data = TestBuffer::createFromVector<float>({})
261 }, { // input1
262 .type = TestOperandType::TENSOR_FLOAT32,
263 .dimensions = {3, 1, 2},
264 .numberOfConsumers = 1,
265 .scale = 0.0f,
266 .zeroPoint = 0,
267 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
268 .channelQuant = {},
269 .isIgnored = false,
270 .data = TestBuffer::createFromVector<float>({})
271 }, { // output0
272 .type = TestOperandType::TENSOR_FLOAT32,
273 .dimensions = {3, 1, 2},
274 .numberOfConsumers = 0,
275 .scale = 0.0f,
276 .zeroPoint = 0,
277 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
278 .channelQuant = {},
279 .isIgnored = false,
280 .data = TestBuffer::createFromVector<float>({-1.0f, 0.0f, -1.0f, 11.0f, -3.0f, -1.44f})
281 }, { // input0_new
282 .type = TestOperandType::TENSOR_FLOAT32,
283 .dimensions = {3, 1, 2},
284 .numberOfConsumers = 1,
285 .scale = 0.0f,
286 .zeroPoint = 0,
287 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
288 .channelQuant = {},
289 .isIgnored = false,
290 .data = TestBuffer::createFromVector<float>({1.0f, 0.0f, -1.0f, 11.0f, -2.0f, -1.44f})
291 }, { // placeholder2
292 .type = TestOperandType::TENSOR_FLOAT32,
293 .dimensions = {1},
294 .numberOfConsumers = 1,
295 .scale = 0.0f,
296 .zeroPoint = 0,
297 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
298 .channelQuant = {},
299 .isIgnored = false,
300 .data = TestBuffer::createFromVector<float>({0.0f})
301 }, { // param2
302 .type = TestOperandType::INT32,
303 .dimensions = {},
304 .numberOfConsumers = 1,
305 .scale = 0.0f,
306 .zeroPoint = 0,
307 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
308 .channelQuant = {},
309 .isIgnored = false,
310 .data = TestBuffer::createFromVector<int32_t>({0})
311 }, { // input1_new
312 .type = TestOperandType::TENSOR_FLOAT32,
313 .dimensions = {3, 1, 2},
314 .numberOfConsumers = 1,
315 .scale = 0.0f,
316 .zeroPoint = 0,
317 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
318 .channelQuant = {},
319 .isIgnored = false,
320 .data = TestBuffer::createFromVector<float>({-1.0f, 0.0f, 1.0f, 12.0f, -3.0f, -1.43f})
321 }, { // placeholder3
322 .type = TestOperandType::TENSOR_FLOAT32,
323 .dimensions = {1},
324 .numberOfConsumers = 1,
325 .scale = 0.0f,
326 .zeroPoint = 0,
327 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
328 .channelQuant = {},
329 .isIgnored = false,
330 .data = TestBuffer::createFromVector<float>({0.0f})
331 }, { // param3
332 .type = TestOperandType::INT32,
333 .dimensions = {},
334 .numberOfConsumers = 1,
335 .scale = 0.0f,
336 .zeroPoint = 0,
337 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
338 .channelQuant = {},
339 .isIgnored = false,
340 .data = TestBuffer::createFromVector<int32_t>({0})
341 }},
342 .operations = {{
343 .type = TestOperationType::ADD,
344 .inputs = {3, 4, 5},
345 .outputs = {0}
346 }, {
347 .type = TestOperationType::ADD,
348 .inputs = {6, 7, 8},
349 .outputs = {1}
350 }, {
351 .type = TestOperationType::MINIMUM,
352 .inputs = {0, 1},
353 .outputs = {2}
354 }},
355 .inputIndexes = {3, 6},
356 .outputIndexes = {2}
357 },
358 .referenced = {},
359 .isRelaxed = true,
360 .expectedMultinomialDistributionTolerance = 0,
361 .expectFailure = false,
362 .minSupportedVersion = TestHalVersion::UNKNOWN
363 };
364 return model;
365 }
366
367 const auto dummy_test_model_simple_relaxed_all_inputs_as_internal = TestModelManager::get().add("minimum_simple_relaxed_all_inputs_as_internal", get_test_model_simple_relaxed_all_inputs_as_internal());
368
369 } // namespace generated_tests::minimum
370
371 namespace generated_tests::minimum {
372
get_test_model_simple_float16()373 const TestModel& get_test_model_simple_float16() {
374 static TestModel model = {
375 .main = {
376 .operands = {{ // input0
377 .type = TestOperandType::TENSOR_FLOAT16,
378 .dimensions = {3, 1, 2},
379 .numberOfConsumers = 1,
380 .scale = 0.0f,
381 .zeroPoint = 0,
382 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
383 .channelQuant = {},
384 .isIgnored = false,
385 .data = TestBuffer::createFromVector<_Float16>({1.0f, 0.0f, -1.0f, 11.0f, -2.0f, -1.440000057220459f})
386 }, { // input1
387 .type = TestOperandType::TENSOR_FLOAT16,
388 .dimensions = {3, 1, 2},
389 .numberOfConsumers = 1,
390 .scale = 0.0f,
391 .zeroPoint = 0,
392 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
393 .channelQuant = {},
394 .isIgnored = false,
395 .data = TestBuffer::createFromVector<_Float16>({-1.0f, 0.0f, 1.0f, 12.0f, -3.0f, -1.4299999475479126f})
396 }, { // output0
397 .type = TestOperandType::TENSOR_FLOAT16,
398 .dimensions = {3, 1, 2},
399 .numberOfConsumers = 0,
400 .scale = 0.0f,
401 .zeroPoint = 0,
402 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
403 .channelQuant = {},
404 .isIgnored = false,
405 .data = TestBuffer::createFromVector<_Float16>({-1.0f, 0.0f, -1.0f, 11.0f, -3.0f, -1.440000057220459f})
406 }},
407 .operations = {{
408 .type = TestOperationType::MINIMUM,
409 .inputs = {0, 1},
410 .outputs = {2}
411 }},
412 .inputIndexes = {0, 1},
413 .outputIndexes = {2}
414 },
415 .referenced = {},
416 .isRelaxed = false,
417 .expectedMultinomialDistributionTolerance = 0,
418 .expectFailure = false,
419 .minSupportedVersion = TestHalVersion::V1_2
420 };
421 return model;
422 }
423
424 const auto dummy_test_model_simple_float16 = TestModelManager::get().add("minimum_simple_float16", get_test_model_simple_float16());
425
426 } // namespace generated_tests::minimum
427
428 namespace generated_tests::minimum {
429
get_test_model_simple_float16_all_inputs_as_internal()430 const TestModel& get_test_model_simple_float16_all_inputs_as_internal() {
431 static TestModel model = {
432 .main = {
433 .operands = {{ // input0
434 .type = TestOperandType::TENSOR_FLOAT16,
435 .dimensions = {3, 1, 2},
436 .numberOfConsumers = 1,
437 .scale = 0.0f,
438 .zeroPoint = 0,
439 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
440 .channelQuant = {},
441 .isIgnored = false,
442 .data = TestBuffer::createFromVector<_Float16>({})
443 }, { // input1
444 .type = TestOperandType::TENSOR_FLOAT16,
445 .dimensions = {3, 1, 2},
446 .numberOfConsumers = 1,
447 .scale = 0.0f,
448 .zeroPoint = 0,
449 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
450 .channelQuant = {},
451 .isIgnored = false,
452 .data = TestBuffer::createFromVector<_Float16>({})
453 }, { // output0
454 .type = TestOperandType::TENSOR_FLOAT16,
455 .dimensions = {3, 1, 2},
456 .numberOfConsumers = 0,
457 .scale = 0.0f,
458 .zeroPoint = 0,
459 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
460 .channelQuant = {},
461 .isIgnored = false,
462 .data = TestBuffer::createFromVector<_Float16>({-1.0f, 0.0f, -1.0f, 11.0f, -3.0f, -1.440000057220459f})
463 }, { // input0_new
464 .type = TestOperandType::TENSOR_FLOAT16,
465 .dimensions = {3, 1, 2},
466 .numberOfConsumers = 1,
467 .scale = 0.0f,
468 .zeroPoint = 0,
469 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
470 .channelQuant = {},
471 .isIgnored = false,
472 .data = TestBuffer::createFromVector<_Float16>({1.0f, 0.0f, -1.0f, 11.0f, -2.0f, -1.440000057220459f})
473 }, { // placeholder4
474 .type = TestOperandType::TENSOR_FLOAT16,
475 .dimensions = {1},
476 .numberOfConsumers = 1,
477 .scale = 0.0f,
478 .zeroPoint = 0,
479 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
480 .channelQuant = {},
481 .isIgnored = false,
482 .data = TestBuffer::createFromVector<_Float16>({0.0f})
483 }, { // param4
484 .type = TestOperandType::INT32,
485 .dimensions = {},
486 .numberOfConsumers = 1,
487 .scale = 0.0f,
488 .zeroPoint = 0,
489 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
490 .channelQuant = {},
491 .isIgnored = false,
492 .data = TestBuffer::createFromVector<int32_t>({0})
493 }, { // input1_new
494 .type = TestOperandType::TENSOR_FLOAT16,
495 .dimensions = {3, 1, 2},
496 .numberOfConsumers = 1,
497 .scale = 0.0f,
498 .zeroPoint = 0,
499 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
500 .channelQuant = {},
501 .isIgnored = false,
502 .data = TestBuffer::createFromVector<_Float16>({-1.0f, 0.0f, 1.0f, 12.0f, -3.0f, -1.4299999475479126f})
503 }, { // placeholder5
504 .type = TestOperandType::TENSOR_FLOAT16,
505 .dimensions = {1},
506 .numberOfConsumers = 1,
507 .scale = 0.0f,
508 .zeroPoint = 0,
509 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
510 .channelQuant = {},
511 .isIgnored = false,
512 .data = TestBuffer::createFromVector<_Float16>({0.0f})
513 }, { // param5
514 .type = TestOperandType::INT32,
515 .dimensions = {},
516 .numberOfConsumers = 1,
517 .scale = 0.0f,
518 .zeroPoint = 0,
519 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
520 .channelQuant = {},
521 .isIgnored = false,
522 .data = TestBuffer::createFromVector<int32_t>({0})
523 }},
524 .operations = {{
525 .type = TestOperationType::ADD,
526 .inputs = {3, 4, 5},
527 .outputs = {0}
528 }, {
529 .type = TestOperationType::ADD,
530 .inputs = {6, 7, 8},
531 .outputs = {1}
532 }, {
533 .type = TestOperationType::MINIMUM,
534 .inputs = {0, 1},
535 .outputs = {2}
536 }},
537 .inputIndexes = {3, 6},
538 .outputIndexes = {2}
539 },
540 .referenced = {},
541 .isRelaxed = false,
542 .expectedMultinomialDistributionTolerance = 0,
543 .expectFailure = false,
544 .minSupportedVersion = TestHalVersion::V1_2
545 };
546 return model;
547 }
548
549 const auto dummy_test_model_simple_float16_all_inputs_as_internal = TestModelManager::get().add("minimum_simple_float16_all_inputs_as_internal", get_test_model_simple_float16_all_inputs_as_internal());
550
551 } // namespace generated_tests::minimum
552
553 namespace generated_tests::minimum {
554
get_test_model_simple_int32()555 const TestModel& get_test_model_simple_int32() {
556 static TestModel model = {
557 .main = {
558 .operands = {{ // input0
559 .type = TestOperandType::TENSOR_INT32,
560 .dimensions = {3, 1, 2},
561 .numberOfConsumers = 1,
562 .scale = 0.0f,
563 .zeroPoint = 0,
564 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
565 .channelQuant = {},
566 .isIgnored = false,
567 .data = TestBuffer::createFromVector<int32_t>({1, 0, -1, 11, -2, -1})
568 }, { // input1
569 .type = TestOperandType::TENSOR_INT32,
570 .dimensions = {3, 1, 2},
571 .numberOfConsumers = 1,
572 .scale = 0.0f,
573 .zeroPoint = 0,
574 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
575 .channelQuant = {},
576 .isIgnored = false,
577 .data = TestBuffer::createFromVector<int32_t>({-1, 0, 1, 12, -3, -1})
578 }, { // output0
579 .type = TestOperandType::TENSOR_INT32,
580 .dimensions = {3, 1, 2},
581 .numberOfConsumers = 0,
582 .scale = 0.0f,
583 .zeroPoint = 0,
584 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
585 .channelQuant = {},
586 .isIgnored = false,
587 .data = TestBuffer::createFromVector<int32_t>({-1, 0, -1, 11, -3, -1})
588 }},
589 .operations = {{
590 .type = TestOperationType::MINIMUM,
591 .inputs = {0, 1},
592 .outputs = {2}
593 }},
594 .inputIndexes = {0, 1},
595 .outputIndexes = {2}
596 },
597 .referenced = {},
598 .isRelaxed = false,
599 .expectedMultinomialDistributionTolerance = 0,
600 .expectFailure = false,
601 .minSupportedVersion = TestHalVersion::V1_2
602 };
603 return model;
604 }
605
606 const auto dummy_test_model_simple_int32 = TestModelManager::get().add("minimum_simple_int32", get_test_model_simple_int32());
607
608 } // namespace generated_tests::minimum
609
610 namespace generated_tests::minimum {
611
get_test_model_simple_quant8()612 const TestModel& get_test_model_simple_quant8() {
613 static TestModel model = {
614 .main = {
615 .operands = {{ // input0
616 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
617 .dimensions = {3, 1, 2},
618 .numberOfConsumers = 1,
619 .scale = 0.5f,
620 .zeroPoint = 127,
621 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
622 .channelQuant = {},
623 .isIgnored = false,
624 .data = TestBuffer::createFromVector<uint8_t>({129, 127, 125, 149, 123, 124})
625 }, { // input1
626 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
627 .dimensions = {3, 1, 2},
628 .numberOfConsumers = 1,
629 .scale = 1.0f,
630 .zeroPoint = 100,
631 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
632 .channelQuant = {},
633 .isIgnored = false,
634 .data = TestBuffer::createFromVector<uint8_t>({99, 100, 101, 112, 97, 99})
635 }, { // output0
636 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
637 .dimensions = {3, 1, 2},
638 .numberOfConsumers = 0,
639 .scale = 2.0f,
640 .zeroPoint = 80,
641 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
642 .channelQuant = {},
643 .isIgnored = false,
644 .data = TestBuffer::createFromVector<uint8_t>({80, 80, 80, 86, 78, 79})
645 }},
646 .operations = {{
647 .type = TestOperationType::MINIMUM,
648 .inputs = {0, 1},
649 .outputs = {2}
650 }},
651 .inputIndexes = {0, 1},
652 .outputIndexes = {2}
653 },
654 .referenced = {},
655 .isRelaxed = false,
656 .expectedMultinomialDistributionTolerance = 0,
657 .expectFailure = false,
658 .minSupportedVersion = TestHalVersion::V1_2
659 };
660 return model;
661 }
662
663 const auto dummy_test_model_simple_quant8 = TestModelManager::get().add("minimum_simple_quant8", get_test_model_simple_quant8());
664
665 } // namespace generated_tests::minimum
666
667 namespace generated_tests::minimum {
668
get_test_model_simple_quant8_all_inputs_as_internal()669 const TestModel& get_test_model_simple_quant8_all_inputs_as_internal() {
670 static TestModel model = {
671 .main = {
672 .operands = {{ // input0
673 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
674 .dimensions = {3, 1, 2},
675 .numberOfConsumers = 1,
676 .scale = 0.5f,
677 .zeroPoint = 127,
678 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
679 .channelQuant = {},
680 .isIgnored = false,
681 .data = TestBuffer::createFromVector<uint8_t>({})
682 }, { // input1
683 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
684 .dimensions = {3, 1, 2},
685 .numberOfConsumers = 1,
686 .scale = 1.0f,
687 .zeroPoint = 100,
688 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
689 .channelQuant = {},
690 .isIgnored = false,
691 .data = TestBuffer::createFromVector<uint8_t>({})
692 }, { // output0
693 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
694 .dimensions = {3, 1, 2},
695 .numberOfConsumers = 0,
696 .scale = 2.0f,
697 .zeroPoint = 80,
698 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
699 .channelQuant = {},
700 .isIgnored = false,
701 .data = TestBuffer::createFromVector<uint8_t>({80, 80, 80, 86, 78, 79})
702 }, { // input0_new
703 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
704 .dimensions = {3, 1, 2},
705 .numberOfConsumers = 1,
706 .scale = 0.5f,
707 .zeroPoint = 127,
708 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
709 .channelQuant = {},
710 .isIgnored = false,
711 .data = TestBuffer::createFromVector<uint8_t>({129, 127, 125, 149, 123, 124})
712 }, { // placeholder6
713 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
714 .dimensions = {1},
715 .numberOfConsumers = 1,
716 .scale = 0.5f,
717 .zeroPoint = 127,
718 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
719 .channelQuant = {},
720 .isIgnored = false,
721 .data = TestBuffer::createFromVector<uint8_t>({127})
722 }, { // param6
723 .type = TestOperandType::INT32,
724 .dimensions = {},
725 .numberOfConsumers = 1,
726 .scale = 0.0f,
727 .zeroPoint = 0,
728 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
729 .channelQuant = {},
730 .isIgnored = false,
731 .data = TestBuffer::createFromVector<int32_t>({0})
732 }, { // input1_new
733 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
734 .dimensions = {3, 1, 2},
735 .numberOfConsumers = 1,
736 .scale = 1.0f,
737 .zeroPoint = 100,
738 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
739 .channelQuant = {},
740 .isIgnored = false,
741 .data = TestBuffer::createFromVector<uint8_t>({99, 100, 101, 112, 97, 99})
742 }, { // placeholder7
743 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
744 .dimensions = {1},
745 .numberOfConsumers = 1,
746 .scale = 1.0f,
747 .zeroPoint = 100,
748 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
749 .channelQuant = {},
750 .isIgnored = false,
751 .data = TestBuffer::createFromVector<uint8_t>({100})
752 }, { // param7
753 .type = TestOperandType::INT32,
754 .dimensions = {},
755 .numberOfConsumers = 1,
756 .scale = 0.0f,
757 .zeroPoint = 0,
758 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
759 .channelQuant = {},
760 .isIgnored = false,
761 .data = TestBuffer::createFromVector<int32_t>({0})
762 }},
763 .operations = {{
764 .type = TestOperationType::ADD,
765 .inputs = {3, 4, 5},
766 .outputs = {0}
767 }, {
768 .type = TestOperationType::ADD,
769 .inputs = {6, 7, 8},
770 .outputs = {1}
771 }, {
772 .type = TestOperationType::MINIMUM,
773 .inputs = {0, 1},
774 .outputs = {2}
775 }},
776 .inputIndexes = {3, 6},
777 .outputIndexes = {2}
778 },
779 .referenced = {},
780 .isRelaxed = false,
781 .expectedMultinomialDistributionTolerance = 0,
782 .expectFailure = false,
783 .minSupportedVersion = TestHalVersion::V1_2
784 };
785 return model;
786 }
787
788 const auto dummy_test_model_simple_quant8_all_inputs_as_internal = TestModelManager::get().add("minimum_simple_quant8_all_inputs_as_internal", get_test_model_simple_quant8_all_inputs_as_internal());
789
790 } // namespace generated_tests::minimum
791
792 namespace generated_tests::minimum {
793
get_test_model_broadcast()794 const TestModel& get_test_model_broadcast() {
795 static TestModel model = {
796 .main = {
797 .operands = {{ // input01
798 .type = TestOperandType::TENSOR_FLOAT32,
799 .dimensions = {3, 1, 2},
800 .numberOfConsumers = 1,
801 .scale = 0.0f,
802 .zeroPoint = 0,
803 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
804 .channelQuant = {},
805 .isIgnored = false,
806 .data = TestBuffer::createFromVector<float>({1.0f, 0.0f, -1.0f, -2.0f, -1.44f, 11.0f})
807 }, { // input11
808 .type = TestOperandType::TENSOR_FLOAT32,
809 .dimensions = {2},
810 .numberOfConsumers = 1,
811 .scale = 0.0f,
812 .zeroPoint = 0,
813 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
814 .channelQuant = {},
815 .isIgnored = false,
816 .data = TestBuffer::createFromVector<float>({0.5f, 2.0f})
817 }, { // output01
818 .type = TestOperandType::TENSOR_FLOAT32,
819 .dimensions = {3, 1, 2},
820 .numberOfConsumers = 0,
821 .scale = 0.0f,
822 .zeroPoint = 0,
823 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
824 .channelQuant = {},
825 .isIgnored = false,
826 .data = TestBuffer::createFromVector<float>({0.5f, 0.0f, -1.0f, -2.0f, -1.44f, 2.0f})
827 }},
828 .operations = {{
829 .type = TestOperationType::MINIMUM,
830 .inputs = {0, 1},
831 .outputs = {2}
832 }},
833 .inputIndexes = {0, 1},
834 .outputIndexes = {2}
835 },
836 .referenced = {},
837 .isRelaxed = false,
838 .expectedMultinomialDistributionTolerance = 0,
839 .expectFailure = false,
840 .minSupportedVersion = TestHalVersion::V1_2
841 };
842 return model;
843 }
844
845 const auto dummy_test_model_broadcast = TestModelManager::get().add("minimum_broadcast", get_test_model_broadcast());
846
847 } // namespace generated_tests::minimum
848
849 namespace generated_tests::minimum {
850
get_test_model_broadcast_all_inputs_as_internal()851 const TestModel& get_test_model_broadcast_all_inputs_as_internal() {
852 static TestModel model = {
853 .main = {
854 .operands = {{ // input01
855 .type = TestOperandType::TENSOR_FLOAT32,
856 .dimensions = {3, 1, 2},
857 .numberOfConsumers = 1,
858 .scale = 0.0f,
859 .zeroPoint = 0,
860 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
861 .channelQuant = {},
862 .isIgnored = false,
863 .data = TestBuffer::createFromVector<float>({})
864 }, { // input11
865 .type = TestOperandType::TENSOR_FLOAT32,
866 .dimensions = {2},
867 .numberOfConsumers = 1,
868 .scale = 0.0f,
869 .zeroPoint = 0,
870 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
871 .channelQuant = {},
872 .isIgnored = false,
873 .data = TestBuffer::createFromVector<float>({})
874 }, { // output01
875 .type = TestOperandType::TENSOR_FLOAT32,
876 .dimensions = {3, 1, 2},
877 .numberOfConsumers = 0,
878 .scale = 0.0f,
879 .zeroPoint = 0,
880 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
881 .channelQuant = {},
882 .isIgnored = false,
883 .data = TestBuffer::createFromVector<float>({0.5f, 0.0f, -1.0f, -2.0f, -1.44f, 2.0f})
884 }, { // input01_new
885 .type = TestOperandType::TENSOR_FLOAT32,
886 .dimensions = {3, 1, 2},
887 .numberOfConsumers = 1,
888 .scale = 0.0f,
889 .zeroPoint = 0,
890 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
891 .channelQuant = {},
892 .isIgnored = false,
893 .data = TestBuffer::createFromVector<float>({1.0f, 0.0f, -1.0f, -2.0f, -1.44f, 11.0f})
894 }, { // placeholder8
895 .type = TestOperandType::TENSOR_FLOAT32,
896 .dimensions = {1},
897 .numberOfConsumers = 1,
898 .scale = 0.0f,
899 .zeroPoint = 0,
900 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
901 .channelQuant = {},
902 .isIgnored = false,
903 .data = TestBuffer::createFromVector<float>({0.0f})
904 }, { // param8
905 .type = TestOperandType::INT32,
906 .dimensions = {},
907 .numberOfConsumers = 1,
908 .scale = 0.0f,
909 .zeroPoint = 0,
910 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
911 .channelQuant = {},
912 .isIgnored = false,
913 .data = TestBuffer::createFromVector<int32_t>({0})
914 }, { // input11_new
915 .type = TestOperandType::TENSOR_FLOAT32,
916 .dimensions = {2},
917 .numberOfConsumers = 1,
918 .scale = 0.0f,
919 .zeroPoint = 0,
920 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
921 .channelQuant = {},
922 .isIgnored = false,
923 .data = TestBuffer::createFromVector<float>({0.5f, 2.0f})
924 }, { // placeholder9
925 .type = TestOperandType::TENSOR_FLOAT32,
926 .dimensions = {1},
927 .numberOfConsumers = 1,
928 .scale = 0.0f,
929 .zeroPoint = 0,
930 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
931 .channelQuant = {},
932 .isIgnored = false,
933 .data = TestBuffer::createFromVector<float>({0.0f})
934 }, { // param9
935 .type = TestOperandType::INT32,
936 .dimensions = {},
937 .numberOfConsumers = 1,
938 .scale = 0.0f,
939 .zeroPoint = 0,
940 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
941 .channelQuant = {},
942 .isIgnored = false,
943 .data = TestBuffer::createFromVector<int32_t>({0})
944 }},
945 .operations = {{
946 .type = TestOperationType::ADD,
947 .inputs = {3, 4, 5},
948 .outputs = {0}
949 }, {
950 .type = TestOperationType::ADD,
951 .inputs = {6, 7, 8},
952 .outputs = {1}
953 }, {
954 .type = TestOperationType::MINIMUM,
955 .inputs = {0, 1},
956 .outputs = {2}
957 }},
958 .inputIndexes = {3, 6},
959 .outputIndexes = {2}
960 },
961 .referenced = {},
962 .isRelaxed = false,
963 .expectedMultinomialDistributionTolerance = 0,
964 .expectFailure = false,
965 .minSupportedVersion = TestHalVersion::V1_2
966 };
967 return model;
968 }
969
970 const auto dummy_test_model_broadcast_all_inputs_as_internal = TestModelManager::get().add("minimum_broadcast_all_inputs_as_internal", get_test_model_broadcast_all_inputs_as_internal());
971
972 } // namespace generated_tests::minimum
973
974 namespace generated_tests::minimum {
975
get_test_model_broadcast_relaxed()976 const TestModel& get_test_model_broadcast_relaxed() {
977 static TestModel model = {
978 .main = {
979 .operands = {{ // input01
980 .type = TestOperandType::TENSOR_FLOAT32,
981 .dimensions = {3, 1, 2},
982 .numberOfConsumers = 1,
983 .scale = 0.0f,
984 .zeroPoint = 0,
985 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
986 .channelQuant = {},
987 .isIgnored = false,
988 .data = TestBuffer::createFromVector<float>({1.0f, 0.0f, -1.0f, -2.0f, -1.44f, 11.0f})
989 }, { // input11
990 .type = TestOperandType::TENSOR_FLOAT32,
991 .dimensions = {2},
992 .numberOfConsumers = 1,
993 .scale = 0.0f,
994 .zeroPoint = 0,
995 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
996 .channelQuant = {},
997 .isIgnored = false,
998 .data = TestBuffer::createFromVector<float>({0.5f, 2.0f})
999 }, { // output01
1000 .type = TestOperandType::TENSOR_FLOAT32,
1001 .dimensions = {3, 1, 2},
1002 .numberOfConsumers = 0,
1003 .scale = 0.0f,
1004 .zeroPoint = 0,
1005 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1006 .channelQuant = {},
1007 .isIgnored = false,
1008 .data = TestBuffer::createFromVector<float>({0.5f, 0.0f, -1.0f, -2.0f, -1.44f, 2.0f})
1009 }},
1010 .operations = {{
1011 .type = TestOperationType::MINIMUM,
1012 .inputs = {0, 1},
1013 .outputs = {2}
1014 }},
1015 .inputIndexes = {0, 1},
1016 .outputIndexes = {2}
1017 },
1018 .referenced = {},
1019 .isRelaxed = true,
1020 .expectedMultinomialDistributionTolerance = 0,
1021 .expectFailure = false,
1022 .minSupportedVersion = TestHalVersion::UNKNOWN
1023 };
1024 return model;
1025 }
1026
1027 const auto dummy_test_model_broadcast_relaxed = TestModelManager::get().add("minimum_broadcast_relaxed", get_test_model_broadcast_relaxed());
1028
1029 } // namespace generated_tests::minimum
1030
1031 namespace generated_tests::minimum {
1032
get_test_model_broadcast_relaxed_all_inputs_as_internal()1033 const TestModel& get_test_model_broadcast_relaxed_all_inputs_as_internal() {
1034 static TestModel model = {
1035 .main = {
1036 .operands = {{ // input01
1037 .type = TestOperandType::TENSOR_FLOAT32,
1038 .dimensions = {3, 1, 2},
1039 .numberOfConsumers = 1,
1040 .scale = 0.0f,
1041 .zeroPoint = 0,
1042 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1043 .channelQuant = {},
1044 .isIgnored = false,
1045 .data = TestBuffer::createFromVector<float>({})
1046 }, { // input11
1047 .type = TestOperandType::TENSOR_FLOAT32,
1048 .dimensions = {2},
1049 .numberOfConsumers = 1,
1050 .scale = 0.0f,
1051 .zeroPoint = 0,
1052 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1053 .channelQuant = {},
1054 .isIgnored = false,
1055 .data = TestBuffer::createFromVector<float>({})
1056 }, { // output01
1057 .type = TestOperandType::TENSOR_FLOAT32,
1058 .dimensions = {3, 1, 2},
1059 .numberOfConsumers = 0,
1060 .scale = 0.0f,
1061 .zeroPoint = 0,
1062 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1063 .channelQuant = {},
1064 .isIgnored = false,
1065 .data = TestBuffer::createFromVector<float>({0.5f, 0.0f, -1.0f, -2.0f, -1.44f, 2.0f})
1066 }, { // input01_new
1067 .type = TestOperandType::TENSOR_FLOAT32,
1068 .dimensions = {3, 1, 2},
1069 .numberOfConsumers = 1,
1070 .scale = 0.0f,
1071 .zeroPoint = 0,
1072 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1073 .channelQuant = {},
1074 .isIgnored = false,
1075 .data = TestBuffer::createFromVector<float>({1.0f, 0.0f, -1.0f, -2.0f, -1.44f, 11.0f})
1076 }, { // placeholder10
1077 .type = TestOperandType::TENSOR_FLOAT32,
1078 .dimensions = {1},
1079 .numberOfConsumers = 1,
1080 .scale = 0.0f,
1081 .zeroPoint = 0,
1082 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1083 .channelQuant = {},
1084 .isIgnored = false,
1085 .data = TestBuffer::createFromVector<float>({0.0f})
1086 }, { // param10
1087 .type = TestOperandType::INT32,
1088 .dimensions = {},
1089 .numberOfConsumers = 1,
1090 .scale = 0.0f,
1091 .zeroPoint = 0,
1092 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1093 .channelQuant = {},
1094 .isIgnored = false,
1095 .data = TestBuffer::createFromVector<int32_t>({0})
1096 }, { // input11_new
1097 .type = TestOperandType::TENSOR_FLOAT32,
1098 .dimensions = {2},
1099 .numberOfConsumers = 1,
1100 .scale = 0.0f,
1101 .zeroPoint = 0,
1102 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1103 .channelQuant = {},
1104 .isIgnored = false,
1105 .data = TestBuffer::createFromVector<float>({0.5f, 2.0f})
1106 }, { // placeholder11
1107 .type = TestOperandType::TENSOR_FLOAT32,
1108 .dimensions = {1},
1109 .numberOfConsumers = 1,
1110 .scale = 0.0f,
1111 .zeroPoint = 0,
1112 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1113 .channelQuant = {},
1114 .isIgnored = false,
1115 .data = TestBuffer::createFromVector<float>({0.0f})
1116 }, { // param11
1117 .type = TestOperandType::INT32,
1118 .dimensions = {},
1119 .numberOfConsumers = 1,
1120 .scale = 0.0f,
1121 .zeroPoint = 0,
1122 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1123 .channelQuant = {},
1124 .isIgnored = false,
1125 .data = TestBuffer::createFromVector<int32_t>({0})
1126 }},
1127 .operations = {{
1128 .type = TestOperationType::ADD,
1129 .inputs = {3, 4, 5},
1130 .outputs = {0}
1131 }, {
1132 .type = TestOperationType::ADD,
1133 .inputs = {6, 7, 8},
1134 .outputs = {1}
1135 }, {
1136 .type = TestOperationType::MINIMUM,
1137 .inputs = {0, 1},
1138 .outputs = {2}
1139 }},
1140 .inputIndexes = {3, 6},
1141 .outputIndexes = {2}
1142 },
1143 .referenced = {},
1144 .isRelaxed = true,
1145 .expectedMultinomialDistributionTolerance = 0,
1146 .expectFailure = false,
1147 .minSupportedVersion = TestHalVersion::UNKNOWN
1148 };
1149 return model;
1150 }
1151
1152 const auto dummy_test_model_broadcast_relaxed_all_inputs_as_internal = TestModelManager::get().add("minimum_broadcast_relaxed_all_inputs_as_internal", get_test_model_broadcast_relaxed_all_inputs_as_internal());
1153
1154 } // namespace generated_tests::minimum
1155
1156 namespace generated_tests::minimum {
1157
get_test_model_broadcast_float16()1158 const TestModel& get_test_model_broadcast_float16() {
1159 static TestModel model = {
1160 .main = {
1161 .operands = {{ // input01
1162 .type = TestOperandType::TENSOR_FLOAT16,
1163 .dimensions = {3, 1, 2},
1164 .numberOfConsumers = 1,
1165 .scale = 0.0f,
1166 .zeroPoint = 0,
1167 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1168 .channelQuant = {},
1169 .isIgnored = false,
1170 .data = TestBuffer::createFromVector<_Float16>({1.0f, 0.0f, -1.0f, -2.0f, -1.440000057220459f, 11.0f})
1171 }, { // input11
1172 .type = TestOperandType::TENSOR_FLOAT16,
1173 .dimensions = {2},
1174 .numberOfConsumers = 1,
1175 .scale = 0.0f,
1176 .zeroPoint = 0,
1177 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1178 .channelQuant = {},
1179 .isIgnored = false,
1180 .data = TestBuffer::createFromVector<_Float16>({0.5f, 2.0f})
1181 }, { // output01
1182 .type = TestOperandType::TENSOR_FLOAT16,
1183 .dimensions = {3, 1, 2},
1184 .numberOfConsumers = 0,
1185 .scale = 0.0f,
1186 .zeroPoint = 0,
1187 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1188 .channelQuant = {},
1189 .isIgnored = false,
1190 .data = TestBuffer::createFromVector<_Float16>({0.5f, 0.0f, -1.0f, -2.0f, -1.440000057220459f, 2.0f})
1191 }},
1192 .operations = {{
1193 .type = TestOperationType::MINIMUM,
1194 .inputs = {0, 1},
1195 .outputs = {2}
1196 }},
1197 .inputIndexes = {0, 1},
1198 .outputIndexes = {2}
1199 },
1200 .referenced = {},
1201 .isRelaxed = false,
1202 .expectedMultinomialDistributionTolerance = 0,
1203 .expectFailure = false,
1204 .minSupportedVersion = TestHalVersion::V1_2
1205 };
1206 return model;
1207 }
1208
1209 const auto dummy_test_model_broadcast_float16 = TestModelManager::get().add("minimum_broadcast_float16", get_test_model_broadcast_float16());
1210
1211 } // namespace generated_tests::minimum
1212
1213 namespace generated_tests::minimum {
1214
get_test_model_broadcast_float16_all_inputs_as_internal()1215 const TestModel& get_test_model_broadcast_float16_all_inputs_as_internal() {
1216 static TestModel model = {
1217 .main = {
1218 .operands = {{ // input01
1219 .type = TestOperandType::TENSOR_FLOAT16,
1220 .dimensions = {3, 1, 2},
1221 .numberOfConsumers = 1,
1222 .scale = 0.0f,
1223 .zeroPoint = 0,
1224 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1225 .channelQuant = {},
1226 .isIgnored = false,
1227 .data = TestBuffer::createFromVector<_Float16>({})
1228 }, { // input11
1229 .type = TestOperandType::TENSOR_FLOAT16,
1230 .dimensions = {2},
1231 .numberOfConsumers = 1,
1232 .scale = 0.0f,
1233 .zeroPoint = 0,
1234 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1235 .channelQuant = {},
1236 .isIgnored = false,
1237 .data = TestBuffer::createFromVector<_Float16>({})
1238 }, { // output01
1239 .type = TestOperandType::TENSOR_FLOAT16,
1240 .dimensions = {3, 1, 2},
1241 .numberOfConsumers = 0,
1242 .scale = 0.0f,
1243 .zeroPoint = 0,
1244 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1245 .channelQuant = {},
1246 .isIgnored = false,
1247 .data = TestBuffer::createFromVector<_Float16>({0.5f, 0.0f, -1.0f, -2.0f, -1.440000057220459f, 2.0f})
1248 }, { // input01_new
1249 .type = TestOperandType::TENSOR_FLOAT16,
1250 .dimensions = {3, 1, 2},
1251 .numberOfConsumers = 1,
1252 .scale = 0.0f,
1253 .zeroPoint = 0,
1254 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1255 .channelQuant = {},
1256 .isIgnored = false,
1257 .data = TestBuffer::createFromVector<_Float16>({1.0f, 0.0f, -1.0f, -2.0f, -1.440000057220459f, 11.0f})
1258 }, { // placeholder12
1259 .type = TestOperandType::TENSOR_FLOAT16,
1260 .dimensions = {1},
1261 .numberOfConsumers = 1,
1262 .scale = 0.0f,
1263 .zeroPoint = 0,
1264 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1265 .channelQuant = {},
1266 .isIgnored = false,
1267 .data = TestBuffer::createFromVector<_Float16>({0.0f})
1268 }, { // param12
1269 .type = TestOperandType::INT32,
1270 .dimensions = {},
1271 .numberOfConsumers = 1,
1272 .scale = 0.0f,
1273 .zeroPoint = 0,
1274 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1275 .channelQuant = {},
1276 .isIgnored = false,
1277 .data = TestBuffer::createFromVector<int32_t>({0})
1278 }, { // input11_new
1279 .type = TestOperandType::TENSOR_FLOAT16,
1280 .dimensions = {2},
1281 .numberOfConsumers = 1,
1282 .scale = 0.0f,
1283 .zeroPoint = 0,
1284 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1285 .channelQuant = {},
1286 .isIgnored = false,
1287 .data = TestBuffer::createFromVector<_Float16>({0.5f, 2.0f})
1288 }, { // placeholder13
1289 .type = TestOperandType::TENSOR_FLOAT16,
1290 .dimensions = {1},
1291 .numberOfConsumers = 1,
1292 .scale = 0.0f,
1293 .zeroPoint = 0,
1294 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1295 .channelQuant = {},
1296 .isIgnored = false,
1297 .data = TestBuffer::createFromVector<_Float16>({0.0f})
1298 }, { // param13
1299 .type = TestOperandType::INT32,
1300 .dimensions = {},
1301 .numberOfConsumers = 1,
1302 .scale = 0.0f,
1303 .zeroPoint = 0,
1304 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1305 .channelQuant = {},
1306 .isIgnored = false,
1307 .data = TestBuffer::createFromVector<int32_t>({0})
1308 }},
1309 .operations = {{
1310 .type = TestOperationType::ADD,
1311 .inputs = {3, 4, 5},
1312 .outputs = {0}
1313 }, {
1314 .type = TestOperationType::ADD,
1315 .inputs = {6, 7, 8},
1316 .outputs = {1}
1317 }, {
1318 .type = TestOperationType::MINIMUM,
1319 .inputs = {0, 1},
1320 .outputs = {2}
1321 }},
1322 .inputIndexes = {3, 6},
1323 .outputIndexes = {2}
1324 },
1325 .referenced = {},
1326 .isRelaxed = false,
1327 .expectedMultinomialDistributionTolerance = 0,
1328 .expectFailure = false,
1329 .minSupportedVersion = TestHalVersion::V1_2
1330 };
1331 return model;
1332 }
1333
1334 const auto dummy_test_model_broadcast_float16_all_inputs_as_internal = TestModelManager::get().add("minimum_broadcast_float16_all_inputs_as_internal", get_test_model_broadcast_float16_all_inputs_as_internal());
1335
1336 } // namespace generated_tests::minimum
1337
1338 namespace generated_tests::minimum {
1339
get_test_model_broadcast_int32()1340 const TestModel& get_test_model_broadcast_int32() {
1341 static TestModel model = {
1342 .main = {
1343 .operands = {{ // input01
1344 .type = TestOperandType::TENSOR_INT32,
1345 .dimensions = {3, 1, 2},
1346 .numberOfConsumers = 1,
1347 .scale = 0.0f,
1348 .zeroPoint = 0,
1349 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1350 .channelQuant = {},
1351 .isIgnored = false,
1352 .data = TestBuffer::createFromVector<int32_t>({1, 0, -1, -2, -1, 11})
1353 }, { // input11
1354 .type = TestOperandType::TENSOR_INT32,
1355 .dimensions = {2},
1356 .numberOfConsumers = 1,
1357 .scale = 0.0f,
1358 .zeroPoint = 0,
1359 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1360 .channelQuant = {},
1361 .isIgnored = false,
1362 .data = TestBuffer::createFromVector<int32_t>({0, 2})
1363 }, { // output01
1364 .type = TestOperandType::TENSOR_INT32,
1365 .dimensions = {3, 1, 2},
1366 .numberOfConsumers = 0,
1367 .scale = 0.0f,
1368 .zeroPoint = 0,
1369 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1370 .channelQuant = {},
1371 .isIgnored = false,
1372 .data = TestBuffer::createFromVector<int32_t>({0, 0, -1, -2, -1, 2})
1373 }},
1374 .operations = {{
1375 .type = TestOperationType::MINIMUM,
1376 .inputs = {0, 1},
1377 .outputs = {2}
1378 }},
1379 .inputIndexes = {0, 1},
1380 .outputIndexes = {2}
1381 },
1382 .referenced = {},
1383 .isRelaxed = false,
1384 .expectedMultinomialDistributionTolerance = 0,
1385 .expectFailure = false,
1386 .minSupportedVersion = TestHalVersion::V1_2
1387 };
1388 return model;
1389 }
1390
1391 const auto dummy_test_model_broadcast_int32 = TestModelManager::get().add("minimum_broadcast_int32", get_test_model_broadcast_int32());
1392
1393 } // namespace generated_tests::minimum
1394
1395 namespace generated_tests::minimum {
1396
get_test_model_broadcast_quant8()1397 const TestModel& get_test_model_broadcast_quant8() {
1398 static TestModel model = {
1399 .main = {
1400 .operands = {{ // input01
1401 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1402 .dimensions = {3, 1, 2},
1403 .numberOfConsumers = 1,
1404 .scale = 0.5f,
1405 .zeroPoint = 127,
1406 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1407 .channelQuant = {},
1408 .isIgnored = false,
1409 .data = TestBuffer::createFromVector<uint8_t>({129, 127, 125, 123, 124, 149})
1410 }, { // input11
1411 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1412 .dimensions = {2},
1413 .numberOfConsumers = 1,
1414 .scale = 1.0f,
1415 .zeroPoint = 100,
1416 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1417 .channelQuant = {},
1418 .isIgnored = false,
1419 .data = TestBuffer::createFromVector<uint8_t>({100, 102})
1420 }, { // output01
1421 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1422 .dimensions = {3, 1, 2},
1423 .numberOfConsumers = 0,
1424 .scale = 2.0f,
1425 .zeroPoint = 80,
1426 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1427 .channelQuant = {},
1428 .isIgnored = false,
1429 .data = TestBuffer::createFromVector<uint8_t>({80, 80, 80, 79, 79, 81})
1430 }},
1431 .operations = {{
1432 .type = TestOperationType::MINIMUM,
1433 .inputs = {0, 1},
1434 .outputs = {2}
1435 }},
1436 .inputIndexes = {0, 1},
1437 .outputIndexes = {2}
1438 },
1439 .referenced = {},
1440 .isRelaxed = false,
1441 .expectedMultinomialDistributionTolerance = 0,
1442 .expectFailure = false,
1443 .minSupportedVersion = TestHalVersion::V1_2
1444 };
1445 return model;
1446 }
1447
1448 const auto dummy_test_model_broadcast_quant8 = TestModelManager::get().add("minimum_broadcast_quant8", get_test_model_broadcast_quant8());
1449
1450 } // namespace generated_tests::minimum
1451
1452 namespace generated_tests::minimum {
1453
get_test_model_broadcast_quant8_all_inputs_as_internal()1454 const TestModel& get_test_model_broadcast_quant8_all_inputs_as_internal() {
1455 static TestModel model = {
1456 .main = {
1457 .operands = {{ // input01
1458 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1459 .dimensions = {3, 1, 2},
1460 .numberOfConsumers = 1,
1461 .scale = 0.5f,
1462 .zeroPoint = 127,
1463 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1464 .channelQuant = {},
1465 .isIgnored = false,
1466 .data = TestBuffer::createFromVector<uint8_t>({})
1467 }, { // input11
1468 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1469 .dimensions = {2},
1470 .numberOfConsumers = 1,
1471 .scale = 1.0f,
1472 .zeroPoint = 100,
1473 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1474 .channelQuant = {},
1475 .isIgnored = false,
1476 .data = TestBuffer::createFromVector<uint8_t>({})
1477 }, { // output01
1478 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1479 .dimensions = {3, 1, 2},
1480 .numberOfConsumers = 0,
1481 .scale = 2.0f,
1482 .zeroPoint = 80,
1483 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1484 .channelQuant = {},
1485 .isIgnored = false,
1486 .data = TestBuffer::createFromVector<uint8_t>({80, 80, 80, 79, 79, 81})
1487 }, { // input01_new
1488 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1489 .dimensions = {3, 1, 2},
1490 .numberOfConsumers = 1,
1491 .scale = 0.5f,
1492 .zeroPoint = 127,
1493 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1494 .channelQuant = {},
1495 .isIgnored = false,
1496 .data = TestBuffer::createFromVector<uint8_t>({129, 127, 125, 123, 124, 149})
1497 }, { // placeholder14
1498 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1499 .dimensions = {1},
1500 .numberOfConsumers = 1,
1501 .scale = 0.5f,
1502 .zeroPoint = 127,
1503 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1504 .channelQuant = {},
1505 .isIgnored = false,
1506 .data = TestBuffer::createFromVector<uint8_t>({127})
1507 }, { // param14
1508 .type = TestOperandType::INT32,
1509 .dimensions = {},
1510 .numberOfConsumers = 1,
1511 .scale = 0.0f,
1512 .zeroPoint = 0,
1513 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1514 .channelQuant = {},
1515 .isIgnored = false,
1516 .data = TestBuffer::createFromVector<int32_t>({0})
1517 }, { // input11_new
1518 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1519 .dimensions = {2},
1520 .numberOfConsumers = 1,
1521 .scale = 1.0f,
1522 .zeroPoint = 100,
1523 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1524 .channelQuant = {},
1525 .isIgnored = false,
1526 .data = TestBuffer::createFromVector<uint8_t>({100, 102})
1527 }, { // placeholder15
1528 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1529 .dimensions = {1},
1530 .numberOfConsumers = 1,
1531 .scale = 1.0f,
1532 .zeroPoint = 100,
1533 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1534 .channelQuant = {},
1535 .isIgnored = false,
1536 .data = TestBuffer::createFromVector<uint8_t>({100})
1537 }, { // param15
1538 .type = TestOperandType::INT32,
1539 .dimensions = {},
1540 .numberOfConsumers = 1,
1541 .scale = 0.0f,
1542 .zeroPoint = 0,
1543 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1544 .channelQuant = {},
1545 .isIgnored = false,
1546 .data = TestBuffer::createFromVector<int32_t>({0})
1547 }},
1548 .operations = {{
1549 .type = TestOperationType::ADD,
1550 .inputs = {3, 4, 5},
1551 .outputs = {0}
1552 }, {
1553 .type = TestOperationType::ADD,
1554 .inputs = {6, 7, 8},
1555 .outputs = {1}
1556 }, {
1557 .type = TestOperationType::MINIMUM,
1558 .inputs = {0, 1},
1559 .outputs = {2}
1560 }},
1561 .inputIndexes = {3, 6},
1562 .outputIndexes = {2}
1563 },
1564 .referenced = {},
1565 .isRelaxed = false,
1566 .expectedMultinomialDistributionTolerance = 0,
1567 .expectFailure = false,
1568 .minSupportedVersion = TestHalVersion::V1_2
1569 };
1570 return model;
1571 }
1572
1573 const auto dummy_test_model_broadcast_quant8_all_inputs_as_internal = TestModelManager::get().add("minimum_broadcast_quant8_all_inputs_as_internal", get_test_model_broadcast_quant8_all_inputs_as_internal());
1574
1575 } // namespace generated_tests::minimum
1576
1577 namespace generated_tests::minimum {
1578
get_test_model_overflow()1579 const TestModel& get_test_model_overflow() {
1580 static TestModel model = {
1581 .main = {
1582 .operands = {{ // input02
1583 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1584 .dimensions = {2},
1585 .numberOfConsumers = 1,
1586 .scale = 1.0f,
1587 .zeroPoint = 128,
1588 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1589 .channelQuant = {},
1590 .isIgnored = false,
1591 .data = TestBuffer::createFromVector<uint8_t>({60, 128})
1592 }, { // input12
1593 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1594 .dimensions = {2},
1595 .numberOfConsumers = 1,
1596 .scale = 1.0f,
1597 .zeroPoint = 128,
1598 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1599 .channelQuant = {},
1600 .isIgnored = false,
1601 .data = TestBuffer::createFromVector<uint8_t>({128, 200})
1602 }, { // output02
1603 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1604 .dimensions = {2},
1605 .numberOfConsumers = 0,
1606 .scale = 0.5f,
1607 .zeroPoint = 128,
1608 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1609 .channelQuant = {},
1610 .isIgnored = false,
1611 .data = TestBuffer::createFromVector<uint8_t>({0, 128})
1612 }},
1613 .operations = {{
1614 .type = TestOperationType::MINIMUM,
1615 .inputs = {0, 1},
1616 .outputs = {2}
1617 }},
1618 .inputIndexes = {0, 1},
1619 .outputIndexes = {2}
1620 },
1621 .referenced = {},
1622 .isRelaxed = false,
1623 .expectedMultinomialDistributionTolerance = 0,
1624 .expectFailure = false,
1625 .minSupportedVersion = TestHalVersion::V1_2
1626 };
1627 return model;
1628 }
1629
1630 const auto dummy_test_model_overflow = TestModelManager::get().add("minimum_overflow", get_test_model_overflow());
1631
1632 } // namespace generated_tests::minimum
1633
1634 namespace generated_tests::minimum {
1635
get_test_model_overflow_all_inputs_as_internal()1636 const TestModel& get_test_model_overflow_all_inputs_as_internal() {
1637 static TestModel model = {
1638 .main = {
1639 .operands = {{ // input02
1640 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1641 .dimensions = {2},
1642 .numberOfConsumers = 1,
1643 .scale = 1.0f,
1644 .zeroPoint = 128,
1645 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1646 .channelQuant = {},
1647 .isIgnored = false,
1648 .data = TestBuffer::createFromVector<uint8_t>({})
1649 }, { // input12
1650 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1651 .dimensions = {2},
1652 .numberOfConsumers = 1,
1653 .scale = 1.0f,
1654 .zeroPoint = 128,
1655 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1656 .channelQuant = {},
1657 .isIgnored = false,
1658 .data = TestBuffer::createFromVector<uint8_t>({})
1659 }, { // output02
1660 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1661 .dimensions = {2},
1662 .numberOfConsumers = 0,
1663 .scale = 0.5f,
1664 .zeroPoint = 128,
1665 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1666 .channelQuant = {},
1667 .isIgnored = false,
1668 .data = TestBuffer::createFromVector<uint8_t>({0, 128})
1669 }, { // input02_new
1670 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1671 .dimensions = {2},
1672 .numberOfConsumers = 1,
1673 .scale = 1.0f,
1674 .zeroPoint = 128,
1675 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1676 .channelQuant = {},
1677 .isIgnored = false,
1678 .data = TestBuffer::createFromVector<uint8_t>({60, 128})
1679 }, { // placeholder16
1680 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1681 .dimensions = {1},
1682 .numberOfConsumers = 1,
1683 .scale = 1.0f,
1684 .zeroPoint = 128,
1685 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1686 .channelQuant = {},
1687 .isIgnored = false,
1688 .data = TestBuffer::createFromVector<uint8_t>({128})
1689 }, { // param16
1690 .type = TestOperandType::INT32,
1691 .dimensions = {},
1692 .numberOfConsumers = 1,
1693 .scale = 0.0f,
1694 .zeroPoint = 0,
1695 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1696 .channelQuant = {},
1697 .isIgnored = false,
1698 .data = TestBuffer::createFromVector<int32_t>({0})
1699 }, { // input12_new
1700 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1701 .dimensions = {2},
1702 .numberOfConsumers = 1,
1703 .scale = 1.0f,
1704 .zeroPoint = 128,
1705 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1706 .channelQuant = {},
1707 .isIgnored = false,
1708 .data = TestBuffer::createFromVector<uint8_t>({128, 200})
1709 }, { // placeholder17
1710 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1711 .dimensions = {1},
1712 .numberOfConsumers = 1,
1713 .scale = 1.0f,
1714 .zeroPoint = 128,
1715 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1716 .channelQuant = {},
1717 .isIgnored = false,
1718 .data = TestBuffer::createFromVector<uint8_t>({128})
1719 }, { // param17
1720 .type = TestOperandType::INT32,
1721 .dimensions = {},
1722 .numberOfConsumers = 1,
1723 .scale = 0.0f,
1724 .zeroPoint = 0,
1725 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1726 .channelQuant = {},
1727 .isIgnored = false,
1728 .data = TestBuffer::createFromVector<int32_t>({0})
1729 }},
1730 .operations = {{
1731 .type = TestOperationType::ADD,
1732 .inputs = {3, 4, 5},
1733 .outputs = {0}
1734 }, {
1735 .type = TestOperationType::ADD,
1736 .inputs = {6, 7, 8},
1737 .outputs = {1}
1738 }, {
1739 .type = TestOperationType::MINIMUM,
1740 .inputs = {0, 1},
1741 .outputs = {2}
1742 }},
1743 .inputIndexes = {3, 6},
1744 .outputIndexes = {2}
1745 },
1746 .referenced = {},
1747 .isRelaxed = false,
1748 .expectedMultinomialDistributionTolerance = 0,
1749 .expectFailure = false,
1750 .minSupportedVersion = TestHalVersion::V1_2
1751 };
1752 return model;
1753 }
1754
1755 const auto dummy_test_model_overflow_all_inputs_as_internal = TestModelManager::get().add("minimum_overflow_all_inputs_as_internal", get_test_model_overflow_all_inputs_as_internal());
1756
1757 } // namespace generated_tests::minimum
1758
1759