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