1 // Generated from less.mod.py
2 // DO NOT EDIT
3 // clang-format off
4 #include "TestHarness.h"
5 using namespace test_helper;
6
7 namespace generated_tests::less {
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>({5.0f, 7.0f, 10.0f}),
19 .dimensions = {3},
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>({10.0f, 7.0f, 5.0f}),
29 .dimensions = {3},
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<bool8>({true, false, false}),
39 .dimensions = {3},
40 .isIgnored = false,
41 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
42 .numberOfConsumers = 0,
43 .scale = 0.0f,
44 .type = TestOperandType::TENSOR_BOOL8,
45 .zeroPoint = 0
46 }},
47 .operations = {{
48 .inputs = {0, 1},
49 .outputs = {2},
50 .type = TestOperationType::LESS
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("less_simple", get_test_model_simple());
61
62 } // namespace generated_tests::less
63
64 namespace generated_tests::less {
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},
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},
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<bool8>({true, false, false}),
96 .dimensions = {3},
97 .isIgnored = false,
98 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
99 .numberOfConsumers = 0,
100 .scale = 0.0f,
101 .type = TestOperandType::TENSOR_BOOL8,
102 .zeroPoint = 0
103 }, { // input0_new
104 .channelQuant = {},
105 .data = TestBuffer::createFromVector<float>({5.0f, 7.0f, 10.0f}),
106 .dimensions = {3},
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>({10.0f, 7.0f, 5.0f}),
136 .dimensions = {3},
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::LESS
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("less_simple_all_inputs_as_internal", get_test_model_simple_all_inputs_as_internal());
186
187 } // namespace generated_tests::less
188
189 namespace generated_tests::less {
190
get_test_model_simple_int32()191 const TestModel& get_test_model_simple_int32() {
192 static TestModel model = {
193 .expectFailure = false,
194 .expectedMultinomialDistributionTolerance = 0,
195 .isRelaxed = false,
196 .main = {
197 .inputIndexes = {0, 1},
198 .operands = {{ // input0
199 .channelQuant = {},
200 .data = TestBuffer::createFromVector<int32_t>({5, 7, 10}),
201 .dimensions = {3},
202 .isIgnored = false,
203 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
204 .numberOfConsumers = 1,
205 .scale = 0.0f,
206 .type = TestOperandType::TENSOR_INT32,
207 .zeroPoint = 0
208 }, { // input1
209 .channelQuant = {},
210 .data = TestBuffer::createFromVector<int32_t>({10, 7, 5}),
211 .dimensions = {3},
212 .isIgnored = false,
213 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
214 .numberOfConsumers = 1,
215 .scale = 0.0f,
216 .type = TestOperandType::TENSOR_INT32,
217 .zeroPoint = 0
218 }, { // output0
219 .channelQuant = {},
220 .data = TestBuffer::createFromVector<bool8>({true, false, false}),
221 .dimensions = {3},
222 .isIgnored = false,
223 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
224 .numberOfConsumers = 0,
225 .scale = 0.0f,
226 .type = TestOperandType::TENSOR_BOOL8,
227 .zeroPoint = 0
228 }},
229 .operations = {{
230 .inputs = {0, 1},
231 .outputs = {2},
232 .type = TestOperationType::LESS
233 }},
234 .outputIndexes = {2}
235 },
236 .minSupportedVersion = TestHalVersion::V1_2,
237 .referenced = {}
238 };
239 return model;
240 }
241
242 const auto dummy_test_model_simple_int32 = TestModelManager::get().add("less_simple_int32", get_test_model_simple_int32());
243
244 } // namespace generated_tests::less
245
246 namespace generated_tests::less {
247
get_test_model_simple_float16()248 const TestModel& get_test_model_simple_float16() {
249 static TestModel model = {
250 .expectFailure = false,
251 .expectedMultinomialDistributionTolerance = 0,
252 .isRelaxed = false,
253 .main = {
254 .inputIndexes = {0, 1},
255 .operands = {{ // input0
256 .channelQuant = {},
257 .data = TestBuffer::createFromVector<_Float16>({5.0f, 7.0f, 10.0f}),
258 .dimensions = {3},
259 .isIgnored = false,
260 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
261 .numberOfConsumers = 1,
262 .scale = 0.0f,
263 .type = TestOperandType::TENSOR_FLOAT16,
264 .zeroPoint = 0
265 }, { // input1
266 .channelQuant = {},
267 .data = TestBuffer::createFromVector<_Float16>({10.0f, 7.0f, 5.0f}),
268 .dimensions = {3},
269 .isIgnored = false,
270 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
271 .numberOfConsumers = 1,
272 .scale = 0.0f,
273 .type = TestOperandType::TENSOR_FLOAT16,
274 .zeroPoint = 0
275 }, { // output0
276 .channelQuant = {},
277 .data = TestBuffer::createFromVector<bool8>({true, false, false}),
278 .dimensions = {3},
279 .isIgnored = false,
280 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
281 .numberOfConsumers = 0,
282 .scale = 0.0f,
283 .type = TestOperandType::TENSOR_BOOL8,
284 .zeroPoint = 0
285 }},
286 .operations = {{
287 .inputs = {0, 1},
288 .outputs = {2},
289 .type = TestOperationType::LESS
290 }},
291 .outputIndexes = {2}
292 },
293 .minSupportedVersion = TestHalVersion::V1_2,
294 .referenced = {}
295 };
296 return model;
297 }
298
299 const auto dummy_test_model_simple_float16 = TestModelManager::get().add("less_simple_float16", get_test_model_simple_float16());
300
301 } // namespace generated_tests::less
302
303 namespace generated_tests::less {
304
get_test_model_simple_float16_all_inputs_as_internal()305 const TestModel& get_test_model_simple_float16_all_inputs_as_internal() {
306 static TestModel model = {
307 .expectFailure = false,
308 .expectedMultinomialDistributionTolerance = 0,
309 .isRelaxed = false,
310 .main = {
311 .inputIndexes = {3, 6},
312 .operands = {{ // input0
313 .channelQuant = {},
314 .data = TestBuffer::createFromVector<_Float16>({}),
315 .dimensions = {3},
316 .isIgnored = false,
317 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
318 .numberOfConsumers = 1,
319 .scale = 0.0f,
320 .type = TestOperandType::TENSOR_FLOAT16,
321 .zeroPoint = 0
322 }, { // input1
323 .channelQuant = {},
324 .data = TestBuffer::createFromVector<_Float16>({}),
325 .dimensions = {3},
326 .isIgnored = false,
327 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
328 .numberOfConsumers = 1,
329 .scale = 0.0f,
330 .type = TestOperandType::TENSOR_FLOAT16,
331 .zeroPoint = 0
332 }, { // output0
333 .channelQuant = {},
334 .data = TestBuffer::createFromVector<bool8>({true, false, false}),
335 .dimensions = {3},
336 .isIgnored = false,
337 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
338 .numberOfConsumers = 0,
339 .scale = 0.0f,
340 .type = TestOperandType::TENSOR_BOOL8,
341 .zeroPoint = 0
342 }, { // input0_new
343 .channelQuant = {},
344 .data = TestBuffer::createFromVector<_Float16>({5.0f, 7.0f, 10.0f}),
345 .dimensions = {3},
346 .isIgnored = false,
347 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
348 .numberOfConsumers = 1,
349 .scale = 0.0f,
350 .type = TestOperandType::TENSOR_FLOAT16,
351 .zeroPoint = 0
352 }, { // dummy2
353 .channelQuant = {},
354 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
355 .dimensions = {1},
356 .isIgnored = false,
357 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
358 .numberOfConsumers = 1,
359 .scale = 0.0f,
360 .type = TestOperandType::TENSOR_FLOAT16,
361 .zeroPoint = 0
362 }, { // param2
363 .channelQuant = {},
364 .data = TestBuffer::createFromVector<int32_t>({0}),
365 .dimensions = {},
366 .isIgnored = false,
367 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
368 .numberOfConsumers = 1,
369 .scale = 0.0f,
370 .type = TestOperandType::INT32,
371 .zeroPoint = 0
372 }, { // input1_new
373 .channelQuant = {},
374 .data = TestBuffer::createFromVector<_Float16>({10.0f, 7.0f, 5.0f}),
375 .dimensions = {3},
376 .isIgnored = false,
377 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
378 .numberOfConsumers = 1,
379 .scale = 0.0f,
380 .type = TestOperandType::TENSOR_FLOAT16,
381 .zeroPoint = 0
382 }, { // dummy3
383 .channelQuant = {},
384 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
385 .dimensions = {1},
386 .isIgnored = false,
387 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
388 .numberOfConsumers = 1,
389 .scale = 0.0f,
390 .type = TestOperandType::TENSOR_FLOAT16,
391 .zeroPoint = 0
392 }, { // param3
393 .channelQuant = {},
394 .data = TestBuffer::createFromVector<int32_t>({0}),
395 .dimensions = {},
396 .isIgnored = false,
397 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
398 .numberOfConsumers = 1,
399 .scale = 0.0f,
400 .type = TestOperandType::INT32,
401 .zeroPoint = 0
402 }},
403 .operations = {{
404 .inputs = {3, 4, 5},
405 .outputs = {0},
406 .type = TestOperationType::ADD
407 }, {
408 .inputs = {6, 7, 8},
409 .outputs = {1},
410 .type = TestOperationType::ADD
411 }, {
412 .inputs = {0, 1},
413 .outputs = {2},
414 .type = TestOperationType::LESS
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_all_inputs_as_internal = TestModelManager::get().add("less_simple_float16_all_inputs_as_internal", get_test_model_simple_float16_all_inputs_as_internal());
425
426 } // namespace generated_tests::less
427
428 namespace generated_tests::less {
429
get_test_model_simple_relaxed()430 const TestModel& get_test_model_simple_relaxed() {
431 static TestModel model = {
432 .expectFailure = false,
433 .expectedMultinomialDistributionTolerance = 0,
434 .isRelaxed = true,
435 .main = {
436 .inputIndexes = {0, 1},
437 .operands = {{ // input0
438 .channelQuant = {},
439 .data = TestBuffer::createFromVector<float>({5.0f, 7.0f, 10.0f}),
440 .dimensions = {3},
441 .isIgnored = false,
442 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
443 .numberOfConsumers = 1,
444 .scale = 0.0f,
445 .type = TestOperandType::TENSOR_FLOAT32,
446 .zeroPoint = 0
447 }, { // input1
448 .channelQuant = {},
449 .data = TestBuffer::createFromVector<float>({10.0f, 7.0f, 5.0f}),
450 .dimensions = {3},
451 .isIgnored = false,
452 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
453 .numberOfConsumers = 1,
454 .scale = 0.0f,
455 .type = TestOperandType::TENSOR_FLOAT32,
456 .zeroPoint = 0
457 }, { // output0
458 .channelQuant = {},
459 .data = TestBuffer::createFromVector<bool8>({true, false, false}),
460 .dimensions = {3},
461 .isIgnored = false,
462 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
463 .numberOfConsumers = 0,
464 .scale = 0.0f,
465 .type = TestOperandType::TENSOR_BOOL8,
466 .zeroPoint = 0
467 }},
468 .operations = {{
469 .inputs = {0, 1},
470 .outputs = {2},
471 .type = TestOperationType::LESS
472 }},
473 .outputIndexes = {2}
474 },
475 .minSupportedVersion = TestHalVersion::UNKNOWN,
476 .referenced = {}
477 };
478 return model;
479 }
480
481 const auto dummy_test_model_simple_relaxed = TestModelManager::get().add("less_simple_relaxed", get_test_model_simple_relaxed());
482
483 } // namespace generated_tests::less
484
485 namespace generated_tests::less {
486
get_test_model_simple_relaxed_all_inputs_as_internal()487 const TestModel& get_test_model_simple_relaxed_all_inputs_as_internal() {
488 static TestModel model = {
489 .expectFailure = false,
490 .expectedMultinomialDistributionTolerance = 0,
491 .isRelaxed = true,
492 .main = {
493 .inputIndexes = {3, 6},
494 .operands = {{ // input0
495 .channelQuant = {},
496 .data = TestBuffer::createFromVector<float>({}),
497 .dimensions = {3},
498 .isIgnored = false,
499 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
500 .numberOfConsumers = 1,
501 .scale = 0.0f,
502 .type = TestOperandType::TENSOR_FLOAT32,
503 .zeroPoint = 0
504 }, { // input1
505 .channelQuant = {},
506 .data = TestBuffer::createFromVector<float>({}),
507 .dimensions = {3},
508 .isIgnored = false,
509 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
510 .numberOfConsumers = 1,
511 .scale = 0.0f,
512 .type = TestOperandType::TENSOR_FLOAT32,
513 .zeroPoint = 0
514 }, { // output0
515 .channelQuant = {},
516 .data = TestBuffer::createFromVector<bool8>({true, false, false}),
517 .dimensions = {3},
518 .isIgnored = false,
519 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
520 .numberOfConsumers = 0,
521 .scale = 0.0f,
522 .type = TestOperandType::TENSOR_BOOL8,
523 .zeroPoint = 0
524 }, { // input0_new
525 .channelQuant = {},
526 .data = TestBuffer::createFromVector<float>({5.0f, 7.0f, 10.0f}),
527 .dimensions = {3},
528 .isIgnored = false,
529 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
530 .numberOfConsumers = 1,
531 .scale = 0.0f,
532 .type = TestOperandType::TENSOR_FLOAT32,
533 .zeroPoint = 0
534 }, { // dummy4
535 .channelQuant = {},
536 .data = TestBuffer::createFromVector<float>({0.0f}),
537 .dimensions = {1},
538 .isIgnored = false,
539 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
540 .numberOfConsumers = 1,
541 .scale = 0.0f,
542 .type = TestOperandType::TENSOR_FLOAT32,
543 .zeroPoint = 0
544 }, { // param4
545 .channelQuant = {},
546 .data = TestBuffer::createFromVector<int32_t>({0}),
547 .dimensions = {},
548 .isIgnored = false,
549 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
550 .numberOfConsumers = 1,
551 .scale = 0.0f,
552 .type = TestOperandType::INT32,
553 .zeroPoint = 0
554 }, { // input1_new
555 .channelQuant = {},
556 .data = TestBuffer::createFromVector<float>({10.0f, 7.0f, 5.0f}),
557 .dimensions = {3},
558 .isIgnored = false,
559 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
560 .numberOfConsumers = 1,
561 .scale = 0.0f,
562 .type = TestOperandType::TENSOR_FLOAT32,
563 .zeroPoint = 0
564 }, { // dummy5
565 .channelQuant = {},
566 .data = TestBuffer::createFromVector<float>({0.0f}),
567 .dimensions = {1},
568 .isIgnored = false,
569 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
570 .numberOfConsumers = 1,
571 .scale = 0.0f,
572 .type = TestOperandType::TENSOR_FLOAT32,
573 .zeroPoint = 0
574 }, { // param5
575 .channelQuant = {},
576 .data = TestBuffer::createFromVector<int32_t>({0}),
577 .dimensions = {},
578 .isIgnored = false,
579 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
580 .numberOfConsumers = 1,
581 .scale = 0.0f,
582 .type = TestOperandType::INT32,
583 .zeroPoint = 0
584 }},
585 .operations = {{
586 .inputs = {3, 4, 5},
587 .outputs = {0},
588 .type = TestOperationType::ADD
589 }, {
590 .inputs = {6, 7, 8},
591 .outputs = {1},
592 .type = TestOperationType::ADD
593 }, {
594 .inputs = {0, 1},
595 .outputs = {2},
596 .type = TestOperationType::LESS
597 }},
598 .outputIndexes = {2}
599 },
600 .minSupportedVersion = TestHalVersion::UNKNOWN,
601 .referenced = {}
602 };
603 return model;
604 }
605
606 const auto dummy_test_model_simple_relaxed_all_inputs_as_internal = TestModelManager::get().add("less_simple_relaxed_all_inputs_as_internal", get_test_model_simple_relaxed_all_inputs_as_internal());
607
608 } // namespace generated_tests::less
609
610 namespace generated_tests::less {
611
get_test_model_broadcast()612 const TestModel& get_test_model_broadcast() {
613 static TestModel model = {
614 .expectFailure = false,
615 .expectedMultinomialDistributionTolerance = 0,
616 .isRelaxed = false,
617 .main = {
618 .inputIndexes = {0, 1},
619 .operands = {{ // input01
620 .channelQuant = {},
621 .data = TestBuffer::createFromVector<float>({5.0f, 10.0f}),
622 .dimensions = {2, 1},
623 .isIgnored = false,
624 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
625 .numberOfConsumers = 1,
626 .scale = 0.0f,
627 .type = TestOperandType::TENSOR_FLOAT32,
628 .zeroPoint = 0
629 }, { // input11
630 .channelQuant = {},
631 .data = TestBuffer::createFromVector<float>({10.0f, 5.0f}),
632 .dimensions = {2},
633 .isIgnored = false,
634 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
635 .numberOfConsumers = 1,
636 .scale = 0.0f,
637 .type = TestOperandType::TENSOR_FLOAT32,
638 .zeroPoint = 0
639 }, { // output01
640 .channelQuant = {},
641 .data = TestBuffer::createFromVector<bool8>({true, false, false, false}),
642 .dimensions = {2, 2},
643 .isIgnored = false,
644 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
645 .numberOfConsumers = 0,
646 .scale = 0.0f,
647 .type = TestOperandType::TENSOR_BOOL8,
648 .zeroPoint = 0
649 }},
650 .operations = {{
651 .inputs = {0, 1},
652 .outputs = {2},
653 .type = TestOperationType::LESS
654 }},
655 .outputIndexes = {2}
656 },
657 .minSupportedVersion = TestHalVersion::V1_2,
658 .referenced = {}
659 };
660 return model;
661 }
662
663 const auto dummy_test_model_broadcast = TestModelManager::get().add("less_broadcast", get_test_model_broadcast());
664
665 } // namespace generated_tests::less
666
667 namespace generated_tests::less {
668
get_test_model_broadcast_all_inputs_as_internal()669 const TestModel& get_test_model_broadcast_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 = {{ // input01
677 .channelQuant = {},
678 .data = TestBuffer::createFromVector<float>({}),
679 .dimensions = {2, 1},
680 .isIgnored = false,
681 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
682 .numberOfConsumers = 1,
683 .scale = 0.0f,
684 .type = TestOperandType::TENSOR_FLOAT32,
685 .zeroPoint = 0
686 }, { // input11
687 .channelQuant = {},
688 .data = TestBuffer::createFromVector<float>({}),
689 .dimensions = {2},
690 .isIgnored = false,
691 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
692 .numberOfConsumers = 1,
693 .scale = 0.0f,
694 .type = TestOperandType::TENSOR_FLOAT32,
695 .zeroPoint = 0
696 }, { // output01
697 .channelQuant = {},
698 .data = TestBuffer::createFromVector<bool8>({true, false, false, false}),
699 .dimensions = {2, 2},
700 .isIgnored = false,
701 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
702 .numberOfConsumers = 0,
703 .scale = 0.0f,
704 .type = TestOperandType::TENSOR_BOOL8,
705 .zeroPoint = 0
706 }, { // input01_new
707 .channelQuant = {},
708 .data = TestBuffer::createFromVector<float>({5.0f, 10.0f}),
709 .dimensions = {2, 1},
710 .isIgnored = false,
711 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
712 .numberOfConsumers = 1,
713 .scale = 0.0f,
714 .type = TestOperandType::TENSOR_FLOAT32,
715 .zeroPoint = 0
716 }, { // dummy6
717 .channelQuant = {},
718 .data = TestBuffer::createFromVector<float>({0.0f}),
719 .dimensions = {1},
720 .isIgnored = false,
721 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
722 .numberOfConsumers = 1,
723 .scale = 0.0f,
724 .type = TestOperandType::TENSOR_FLOAT32,
725 .zeroPoint = 0
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 }, { // input11_new
737 .channelQuant = {},
738 .data = TestBuffer::createFromVector<float>({10.0f, 5.0f}),
739 .dimensions = {2},
740 .isIgnored = false,
741 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
742 .numberOfConsumers = 1,
743 .scale = 0.0f,
744 .type = TestOperandType::TENSOR_FLOAT32,
745 .zeroPoint = 0
746 }, { // dummy7
747 .channelQuant = {},
748 .data = TestBuffer::createFromVector<float>({0.0f}),
749 .dimensions = {1},
750 .isIgnored = false,
751 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
752 .numberOfConsumers = 1,
753 .scale = 0.0f,
754 .type = TestOperandType::TENSOR_FLOAT32,
755 .zeroPoint = 0
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::LESS
779 }},
780 .outputIndexes = {2}
781 },
782 .minSupportedVersion = TestHalVersion::V1_2,
783 .referenced = {}
784 };
785 return model;
786 }
787
788 const auto dummy_test_model_broadcast_all_inputs_as_internal = TestModelManager::get().add("less_broadcast_all_inputs_as_internal", get_test_model_broadcast_all_inputs_as_internal());
789
790 } // namespace generated_tests::less
791
792 namespace generated_tests::less {
793
get_test_model_broadcast_int32()794 const TestModel& get_test_model_broadcast_int32() {
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<int32_t>({5, 10}),
804 .dimensions = {2, 1},
805 .isIgnored = false,
806 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
807 .numberOfConsumers = 1,
808 .scale = 0.0f,
809 .type = TestOperandType::TENSOR_INT32,
810 .zeroPoint = 0
811 }, { // input11
812 .channelQuant = {},
813 .data = TestBuffer::createFromVector<int32_t>({10, 5}),
814 .dimensions = {2},
815 .isIgnored = false,
816 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
817 .numberOfConsumers = 1,
818 .scale = 0.0f,
819 .type = TestOperandType::TENSOR_INT32,
820 .zeroPoint = 0
821 }, { // output01
822 .channelQuant = {},
823 .data = TestBuffer::createFromVector<bool8>({true, false, false, false}),
824 .dimensions = {2, 2},
825 .isIgnored = false,
826 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
827 .numberOfConsumers = 0,
828 .scale = 0.0f,
829 .type = TestOperandType::TENSOR_BOOL8,
830 .zeroPoint = 0
831 }},
832 .operations = {{
833 .inputs = {0, 1},
834 .outputs = {2},
835 .type = TestOperationType::LESS
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_int32 = TestModelManager::get().add("less_broadcast_int32", get_test_model_broadcast_int32());
846
847 } // namespace generated_tests::less
848
849 namespace generated_tests::less {
850
get_test_model_broadcast_float16()851 const TestModel& get_test_model_broadcast_float16() {
852 static TestModel model = {
853 .expectFailure = false,
854 .expectedMultinomialDistributionTolerance = 0,
855 .isRelaxed = false,
856 .main = {
857 .inputIndexes = {0, 1},
858 .operands = {{ // input01
859 .channelQuant = {},
860 .data = TestBuffer::createFromVector<_Float16>({5.0f, 10.0f}),
861 .dimensions = {2, 1},
862 .isIgnored = false,
863 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
864 .numberOfConsumers = 1,
865 .scale = 0.0f,
866 .type = TestOperandType::TENSOR_FLOAT16,
867 .zeroPoint = 0
868 }, { // input11
869 .channelQuant = {},
870 .data = TestBuffer::createFromVector<_Float16>({10.0f, 5.0f}),
871 .dimensions = {2},
872 .isIgnored = false,
873 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
874 .numberOfConsumers = 1,
875 .scale = 0.0f,
876 .type = TestOperandType::TENSOR_FLOAT16,
877 .zeroPoint = 0
878 }, { // output01
879 .channelQuant = {},
880 .data = TestBuffer::createFromVector<bool8>({true, false, false, false}),
881 .dimensions = {2, 2},
882 .isIgnored = false,
883 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
884 .numberOfConsumers = 0,
885 .scale = 0.0f,
886 .type = TestOperandType::TENSOR_BOOL8,
887 .zeroPoint = 0
888 }},
889 .operations = {{
890 .inputs = {0, 1},
891 .outputs = {2},
892 .type = TestOperationType::LESS
893 }},
894 .outputIndexes = {2}
895 },
896 .minSupportedVersion = TestHalVersion::V1_2,
897 .referenced = {}
898 };
899 return model;
900 }
901
902 const auto dummy_test_model_broadcast_float16 = TestModelManager::get().add("less_broadcast_float16", get_test_model_broadcast_float16());
903
904 } // namespace generated_tests::less
905
906 namespace generated_tests::less {
907
get_test_model_broadcast_float16_all_inputs_as_internal()908 const TestModel& get_test_model_broadcast_float16_all_inputs_as_internal() {
909 static TestModel model = {
910 .expectFailure = false,
911 .expectedMultinomialDistributionTolerance = 0,
912 .isRelaxed = false,
913 .main = {
914 .inputIndexes = {3, 6},
915 .operands = {{ // input01
916 .channelQuant = {},
917 .data = TestBuffer::createFromVector<_Float16>({}),
918 .dimensions = {2, 1},
919 .isIgnored = false,
920 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
921 .numberOfConsumers = 1,
922 .scale = 0.0f,
923 .type = TestOperandType::TENSOR_FLOAT16,
924 .zeroPoint = 0
925 }, { // input11
926 .channelQuant = {},
927 .data = TestBuffer::createFromVector<_Float16>({}),
928 .dimensions = {2},
929 .isIgnored = false,
930 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
931 .numberOfConsumers = 1,
932 .scale = 0.0f,
933 .type = TestOperandType::TENSOR_FLOAT16,
934 .zeroPoint = 0
935 }, { // output01
936 .channelQuant = {},
937 .data = TestBuffer::createFromVector<bool8>({true, false, false, false}),
938 .dimensions = {2, 2},
939 .isIgnored = false,
940 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
941 .numberOfConsumers = 0,
942 .scale = 0.0f,
943 .type = TestOperandType::TENSOR_BOOL8,
944 .zeroPoint = 0
945 }, { // input01_new
946 .channelQuant = {},
947 .data = TestBuffer::createFromVector<_Float16>({5.0f, 10.0f}),
948 .dimensions = {2, 1},
949 .isIgnored = false,
950 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
951 .numberOfConsumers = 1,
952 .scale = 0.0f,
953 .type = TestOperandType::TENSOR_FLOAT16,
954 .zeroPoint = 0
955 }, { // dummy8
956 .channelQuant = {},
957 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
958 .dimensions = {1},
959 .isIgnored = false,
960 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
961 .numberOfConsumers = 1,
962 .scale = 0.0f,
963 .type = TestOperandType::TENSOR_FLOAT16,
964 .zeroPoint = 0
965 }, { // param8
966 .channelQuant = {},
967 .data = TestBuffer::createFromVector<int32_t>({0}),
968 .dimensions = {},
969 .isIgnored = false,
970 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
971 .numberOfConsumers = 1,
972 .scale = 0.0f,
973 .type = TestOperandType::INT32,
974 .zeroPoint = 0
975 }, { // input11_new
976 .channelQuant = {},
977 .data = TestBuffer::createFromVector<_Float16>({10.0f, 5.0f}),
978 .dimensions = {2},
979 .isIgnored = false,
980 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
981 .numberOfConsumers = 1,
982 .scale = 0.0f,
983 .type = TestOperandType::TENSOR_FLOAT16,
984 .zeroPoint = 0
985 }, { // dummy9
986 .channelQuant = {},
987 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
988 .dimensions = {1},
989 .isIgnored = false,
990 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
991 .numberOfConsumers = 1,
992 .scale = 0.0f,
993 .type = TestOperandType::TENSOR_FLOAT16,
994 .zeroPoint = 0
995 }, { // param9
996 .channelQuant = {},
997 .data = TestBuffer::createFromVector<int32_t>({0}),
998 .dimensions = {},
999 .isIgnored = false,
1000 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1001 .numberOfConsumers = 1,
1002 .scale = 0.0f,
1003 .type = TestOperandType::INT32,
1004 .zeroPoint = 0
1005 }},
1006 .operations = {{
1007 .inputs = {3, 4, 5},
1008 .outputs = {0},
1009 .type = TestOperationType::ADD
1010 }, {
1011 .inputs = {6, 7, 8},
1012 .outputs = {1},
1013 .type = TestOperationType::ADD
1014 }, {
1015 .inputs = {0, 1},
1016 .outputs = {2},
1017 .type = TestOperationType::LESS
1018 }},
1019 .outputIndexes = {2}
1020 },
1021 .minSupportedVersion = TestHalVersion::V1_2,
1022 .referenced = {}
1023 };
1024 return model;
1025 }
1026
1027 const auto dummy_test_model_broadcast_float16_all_inputs_as_internal = TestModelManager::get().add("less_broadcast_float16_all_inputs_as_internal", get_test_model_broadcast_float16_all_inputs_as_internal());
1028
1029 } // namespace generated_tests::less
1030
1031 namespace generated_tests::less {
1032
get_test_model_broadcast_relaxed()1033 const TestModel& get_test_model_broadcast_relaxed() {
1034 static TestModel model = {
1035 .expectFailure = false,
1036 .expectedMultinomialDistributionTolerance = 0,
1037 .isRelaxed = true,
1038 .main = {
1039 .inputIndexes = {0, 1},
1040 .operands = {{ // input01
1041 .channelQuant = {},
1042 .data = TestBuffer::createFromVector<float>({5.0f, 10.0f}),
1043 .dimensions = {2, 1},
1044 .isIgnored = false,
1045 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1046 .numberOfConsumers = 1,
1047 .scale = 0.0f,
1048 .type = TestOperandType::TENSOR_FLOAT32,
1049 .zeroPoint = 0
1050 }, { // input11
1051 .channelQuant = {},
1052 .data = TestBuffer::createFromVector<float>({10.0f, 5.0f}),
1053 .dimensions = {2},
1054 .isIgnored = false,
1055 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1056 .numberOfConsumers = 1,
1057 .scale = 0.0f,
1058 .type = TestOperandType::TENSOR_FLOAT32,
1059 .zeroPoint = 0
1060 }, { // output01
1061 .channelQuant = {},
1062 .data = TestBuffer::createFromVector<bool8>({true, false, false, false}),
1063 .dimensions = {2, 2},
1064 .isIgnored = false,
1065 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1066 .numberOfConsumers = 0,
1067 .scale = 0.0f,
1068 .type = TestOperandType::TENSOR_BOOL8,
1069 .zeroPoint = 0
1070 }},
1071 .operations = {{
1072 .inputs = {0, 1},
1073 .outputs = {2},
1074 .type = TestOperationType::LESS
1075 }},
1076 .outputIndexes = {2}
1077 },
1078 .minSupportedVersion = TestHalVersion::UNKNOWN,
1079 .referenced = {}
1080 };
1081 return model;
1082 }
1083
1084 const auto dummy_test_model_broadcast_relaxed = TestModelManager::get().add("less_broadcast_relaxed", get_test_model_broadcast_relaxed());
1085
1086 } // namespace generated_tests::less
1087
1088 namespace generated_tests::less {
1089
get_test_model_broadcast_relaxed_all_inputs_as_internal()1090 const TestModel& get_test_model_broadcast_relaxed_all_inputs_as_internal() {
1091 static TestModel model = {
1092 .expectFailure = false,
1093 .expectedMultinomialDistributionTolerance = 0,
1094 .isRelaxed = true,
1095 .main = {
1096 .inputIndexes = {3, 6},
1097 .operands = {{ // input01
1098 .channelQuant = {},
1099 .data = TestBuffer::createFromVector<float>({}),
1100 .dimensions = {2, 1},
1101 .isIgnored = false,
1102 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1103 .numberOfConsumers = 1,
1104 .scale = 0.0f,
1105 .type = TestOperandType::TENSOR_FLOAT32,
1106 .zeroPoint = 0
1107 }, { // input11
1108 .channelQuant = {},
1109 .data = TestBuffer::createFromVector<float>({}),
1110 .dimensions = {2},
1111 .isIgnored = false,
1112 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1113 .numberOfConsumers = 1,
1114 .scale = 0.0f,
1115 .type = TestOperandType::TENSOR_FLOAT32,
1116 .zeroPoint = 0
1117 }, { // output01
1118 .channelQuant = {},
1119 .data = TestBuffer::createFromVector<bool8>({true, false, false, false}),
1120 .dimensions = {2, 2},
1121 .isIgnored = false,
1122 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1123 .numberOfConsumers = 0,
1124 .scale = 0.0f,
1125 .type = TestOperandType::TENSOR_BOOL8,
1126 .zeroPoint = 0
1127 }, { // input01_new
1128 .channelQuant = {},
1129 .data = TestBuffer::createFromVector<float>({5.0f, 10.0f}),
1130 .dimensions = {2, 1},
1131 .isIgnored = false,
1132 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1133 .numberOfConsumers = 1,
1134 .scale = 0.0f,
1135 .type = TestOperandType::TENSOR_FLOAT32,
1136 .zeroPoint = 0
1137 }, { // dummy10
1138 .channelQuant = {},
1139 .data = TestBuffer::createFromVector<float>({0.0f}),
1140 .dimensions = {1},
1141 .isIgnored = false,
1142 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1143 .numberOfConsumers = 1,
1144 .scale = 0.0f,
1145 .type = TestOperandType::TENSOR_FLOAT32,
1146 .zeroPoint = 0
1147 }, { // param10
1148 .channelQuant = {},
1149 .data = TestBuffer::createFromVector<int32_t>({0}),
1150 .dimensions = {},
1151 .isIgnored = false,
1152 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1153 .numberOfConsumers = 1,
1154 .scale = 0.0f,
1155 .type = TestOperandType::INT32,
1156 .zeroPoint = 0
1157 }, { // input11_new
1158 .channelQuant = {},
1159 .data = TestBuffer::createFromVector<float>({10.0f, 5.0f}),
1160 .dimensions = {2},
1161 .isIgnored = false,
1162 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1163 .numberOfConsumers = 1,
1164 .scale = 0.0f,
1165 .type = TestOperandType::TENSOR_FLOAT32,
1166 .zeroPoint = 0
1167 }, { // dummy11
1168 .channelQuant = {},
1169 .data = TestBuffer::createFromVector<float>({0.0f}),
1170 .dimensions = {1},
1171 .isIgnored = false,
1172 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1173 .numberOfConsumers = 1,
1174 .scale = 0.0f,
1175 .type = TestOperandType::TENSOR_FLOAT32,
1176 .zeroPoint = 0
1177 }, { // param11
1178 .channelQuant = {},
1179 .data = TestBuffer::createFromVector<int32_t>({0}),
1180 .dimensions = {},
1181 .isIgnored = false,
1182 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1183 .numberOfConsumers = 1,
1184 .scale = 0.0f,
1185 .type = TestOperandType::INT32,
1186 .zeroPoint = 0
1187 }},
1188 .operations = {{
1189 .inputs = {3, 4, 5},
1190 .outputs = {0},
1191 .type = TestOperationType::ADD
1192 }, {
1193 .inputs = {6, 7, 8},
1194 .outputs = {1},
1195 .type = TestOperationType::ADD
1196 }, {
1197 .inputs = {0, 1},
1198 .outputs = {2},
1199 .type = TestOperationType::LESS
1200 }},
1201 .outputIndexes = {2}
1202 },
1203 .minSupportedVersion = TestHalVersion::UNKNOWN,
1204 .referenced = {}
1205 };
1206 return model;
1207 }
1208
1209 const auto dummy_test_model_broadcast_relaxed_all_inputs_as_internal = TestModelManager::get().add("less_broadcast_relaxed_all_inputs_as_internal", get_test_model_broadcast_relaxed_all_inputs_as_internal());
1210
1211 } // namespace generated_tests::less
1212
1213 namespace generated_tests::less {
1214
get_test_model_quantized_different_scale()1215 const TestModel& get_test_model_quantized_different_scale() {
1216 static TestModel model = {
1217 .expectFailure = false,
1218 .expectedMultinomialDistributionTolerance = 0,
1219 .isRelaxed = false,
1220 .main = {
1221 .inputIndexes = {0, 1},
1222 .operands = {{ // input02
1223 .channelQuant = {},
1224 .data = TestBuffer::createFromVector<uint8_t>({129, 130, 131}),
1225 .dimensions = {3},
1226 .isIgnored = false,
1227 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1228 .numberOfConsumers = 1,
1229 .scale = 1.0f,
1230 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1231 .zeroPoint = 128
1232 }, { // input12
1233 .channelQuant = {},
1234 .data = TestBuffer::createFromVector<uint8_t>({129}),
1235 .dimensions = {1},
1236 .isIgnored = false,
1237 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1238 .numberOfConsumers = 1,
1239 .scale = 2.0f,
1240 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1241 .zeroPoint = 128
1242 }, { // output02
1243 .channelQuant = {},
1244 .data = TestBuffer::createFromVector<bool8>({true, false, false}),
1245 .dimensions = {3},
1246 .isIgnored = false,
1247 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1248 .numberOfConsumers = 0,
1249 .scale = 0.0f,
1250 .type = TestOperandType::TENSOR_BOOL8,
1251 .zeroPoint = 0
1252 }},
1253 .operations = {{
1254 .inputs = {0, 1},
1255 .outputs = {2},
1256 .type = TestOperationType::LESS
1257 }},
1258 .outputIndexes = {2}
1259 },
1260 .minSupportedVersion = TestHalVersion::V1_2,
1261 .referenced = {}
1262 };
1263 return model;
1264 }
1265
1266 const auto dummy_test_model_quantized_different_scale = TestModelManager::get().add("less_quantized_different_scale", get_test_model_quantized_different_scale());
1267
1268 } // namespace generated_tests::less
1269
1270 namespace generated_tests::less {
1271
get_test_model_quantized_different_scale_all_inputs_as_internal()1272 const TestModel& get_test_model_quantized_different_scale_all_inputs_as_internal() {
1273 static TestModel model = {
1274 .expectFailure = false,
1275 .expectedMultinomialDistributionTolerance = 0,
1276 .isRelaxed = false,
1277 .main = {
1278 .inputIndexes = {3, 6},
1279 .operands = {{ // input02
1280 .channelQuant = {},
1281 .data = TestBuffer::createFromVector<uint8_t>({}),
1282 .dimensions = {3},
1283 .isIgnored = false,
1284 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1285 .numberOfConsumers = 1,
1286 .scale = 1.0f,
1287 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1288 .zeroPoint = 128
1289 }, { // input12
1290 .channelQuant = {},
1291 .data = TestBuffer::createFromVector<uint8_t>({}),
1292 .dimensions = {1},
1293 .isIgnored = false,
1294 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1295 .numberOfConsumers = 1,
1296 .scale = 2.0f,
1297 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1298 .zeroPoint = 128
1299 }, { // output02
1300 .channelQuant = {},
1301 .data = TestBuffer::createFromVector<bool8>({true, false, false}),
1302 .dimensions = {3},
1303 .isIgnored = false,
1304 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1305 .numberOfConsumers = 0,
1306 .scale = 0.0f,
1307 .type = TestOperandType::TENSOR_BOOL8,
1308 .zeroPoint = 0
1309 }, { // input02_new
1310 .channelQuant = {},
1311 .data = TestBuffer::createFromVector<uint8_t>({129, 130, 131}),
1312 .dimensions = {3},
1313 .isIgnored = false,
1314 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1315 .numberOfConsumers = 1,
1316 .scale = 1.0f,
1317 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1318 .zeroPoint = 128
1319 }, { // dummy12
1320 .channelQuant = {},
1321 .data = TestBuffer::createFromVector<uint8_t>({128}),
1322 .dimensions = {1},
1323 .isIgnored = false,
1324 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1325 .numberOfConsumers = 1,
1326 .scale = 1.0f,
1327 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1328 .zeroPoint = 128
1329 }, { // param12
1330 .channelQuant = {},
1331 .data = TestBuffer::createFromVector<int32_t>({0}),
1332 .dimensions = {},
1333 .isIgnored = false,
1334 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1335 .numberOfConsumers = 1,
1336 .scale = 0.0f,
1337 .type = TestOperandType::INT32,
1338 .zeroPoint = 0
1339 }, { // input12_new
1340 .channelQuant = {},
1341 .data = TestBuffer::createFromVector<uint8_t>({129}),
1342 .dimensions = {1},
1343 .isIgnored = false,
1344 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1345 .numberOfConsumers = 1,
1346 .scale = 2.0f,
1347 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1348 .zeroPoint = 128
1349 }, { // dummy13
1350 .channelQuant = {},
1351 .data = TestBuffer::createFromVector<uint8_t>({128}),
1352 .dimensions = {1},
1353 .isIgnored = false,
1354 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1355 .numberOfConsumers = 1,
1356 .scale = 2.0f,
1357 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1358 .zeroPoint = 128
1359 }, { // param13
1360 .channelQuant = {},
1361 .data = TestBuffer::createFromVector<int32_t>({0}),
1362 .dimensions = {},
1363 .isIgnored = false,
1364 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1365 .numberOfConsumers = 1,
1366 .scale = 0.0f,
1367 .type = TestOperandType::INT32,
1368 .zeroPoint = 0
1369 }},
1370 .operations = {{
1371 .inputs = {3, 4, 5},
1372 .outputs = {0},
1373 .type = TestOperationType::ADD
1374 }, {
1375 .inputs = {6, 7, 8},
1376 .outputs = {1},
1377 .type = TestOperationType::ADD
1378 }, {
1379 .inputs = {0, 1},
1380 .outputs = {2},
1381 .type = TestOperationType::LESS
1382 }},
1383 .outputIndexes = {2}
1384 },
1385 .minSupportedVersion = TestHalVersion::V1_2,
1386 .referenced = {}
1387 };
1388 return model;
1389 }
1390
1391 const auto dummy_test_model_quantized_different_scale_all_inputs_as_internal = TestModelManager::get().add("less_quantized_different_scale_all_inputs_as_internal", get_test_model_quantized_different_scale_all_inputs_as_internal());
1392
1393 } // namespace generated_tests::less
1394
1395 namespace generated_tests::less {
1396
get_test_model_quantized_different_zero_point()1397 const TestModel& get_test_model_quantized_different_zero_point() {
1398 static TestModel model = {
1399 .expectFailure = false,
1400 .expectedMultinomialDistributionTolerance = 0,
1401 .isRelaxed = false,
1402 .main = {
1403 .inputIndexes = {0, 1},
1404 .operands = {{ // input03
1405 .channelQuant = {},
1406 .data = TestBuffer::createFromVector<uint8_t>({129, 130, 131}),
1407 .dimensions = {3},
1408 .isIgnored = false,
1409 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1410 .numberOfConsumers = 1,
1411 .scale = 1.0f,
1412 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1413 .zeroPoint = 128
1414 }, { // input13
1415 .channelQuant = {},
1416 .data = TestBuffer::createFromVector<uint8_t>({131}),
1417 .dimensions = {1},
1418 .isIgnored = false,
1419 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1420 .numberOfConsumers = 1,
1421 .scale = 1.0f,
1422 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1423 .zeroPoint = 129
1424 }, { // output03
1425 .channelQuant = {},
1426 .data = TestBuffer::createFromVector<bool8>({true, false, false}),
1427 .dimensions = {3},
1428 .isIgnored = false,
1429 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1430 .numberOfConsumers = 0,
1431 .scale = 0.0f,
1432 .type = TestOperandType::TENSOR_BOOL8,
1433 .zeroPoint = 0
1434 }},
1435 .operations = {{
1436 .inputs = {0, 1},
1437 .outputs = {2},
1438 .type = TestOperationType::LESS
1439 }},
1440 .outputIndexes = {2}
1441 },
1442 .minSupportedVersion = TestHalVersion::V1_2,
1443 .referenced = {}
1444 };
1445 return model;
1446 }
1447
1448 const auto dummy_test_model_quantized_different_zero_point = TestModelManager::get().add("less_quantized_different_zero_point", get_test_model_quantized_different_zero_point());
1449
1450 } // namespace generated_tests::less
1451
1452 namespace generated_tests::less {
1453
get_test_model_quantized_different_zero_point_all_inputs_as_internal()1454 const TestModel& get_test_model_quantized_different_zero_point_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 = {{ // input03
1462 .channelQuant = {},
1463 .data = TestBuffer::createFromVector<uint8_t>({}),
1464 .dimensions = {3},
1465 .isIgnored = false,
1466 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1467 .numberOfConsumers = 1,
1468 .scale = 1.0f,
1469 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1470 .zeroPoint = 128
1471 }, { // input13
1472 .channelQuant = {},
1473 .data = TestBuffer::createFromVector<uint8_t>({}),
1474 .dimensions = {1},
1475 .isIgnored = false,
1476 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1477 .numberOfConsumers = 1,
1478 .scale = 1.0f,
1479 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1480 .zeroPoint = 129
1481 }, { // output03
1482 .channelQuant = {},
1483 .data = TestBuffer::createFromVector<bool8>({true, false, false}),
1484 .dimensions = {3},
1485 .isIgnored = false,
1486 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1487 .numberOfConsumers = 0,
1488 .scale = 0.0f,
1489 .type = TestOperandType::TENSOR_BOOL8,
1490 .zeroPoint = 0
1491 }, { // input03_new
1492 .channelQuant = {},
1493 .data = TestBuffer::createFromVector<uint8_t>({129, 130, 131}),
1494 .dimensions = {3},
1495 .isIgnored = false,
1496 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1497 .numberOfConsumers = 1,
1498 .scale = 1.0f,
1499 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1500 .zeroPoint = 128
1501 }, { // dummy14
1502 .channelQuant = {},
1503 .data = TestBuffer::createFromVector<uint8_t>({128}),
1504 .dimensions = {1},
1505 .isIgnored = false,
1506 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1507 .numberOfConsumers = 1,
1508 .scale = 1.0f,
1509 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1510 .zeroPoint = 128
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 }, { // input13_new
1522 .channelQuant = {},
1523 .data = TestBuffer::createFromVector<uint8_t>({131}),
1524 .dimensions = {1},
1525 .isIgnored = false,
1526 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1527 .numberOfConsumers = 1,
1528 .scale = 1.0f,
1529 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1530 .zeroPoint = 129
1531 }, { // dummy15
1532 .channelQuant = {},
1533 .data = TestBuffer::createFromVector<uint8_t>({129}),
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 = 129
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::LESS
1564 }},
1565 .outputIndexes = {2}
1566 },
1567 .minSupportedVersion = TestHalVersion::V1_2,
1568 .referenced = {}
1569 };
1570 return model;
1571 }
1572
1573 const auto dummy_test_model_quantized_different_zero_point_all_inputs_as_internal = TestModelManager::get().add("less_quantized_different_zero_point_all_inputs_as_internal", get_test_model_quantized_different_zero_point_all_inputs_as_internal());
1574
1575 } // namespace generated_tests::less
1576
1577 namespace generated_tests::less {
1578
get_test_model_quantized_overflow_second_input_if_requantized()1579 const TestModel& get_test_model_quantized_overflow_second_input_if_requantized() {
1580 static TestModel model = {
1581 .expectFailure = false,
1582 .expectedMultinomialDistributionTolerance = 0,
1583 .isRelaxed = false,
1584 .main = {
1585 .inputIndexes = {0, 1},
1586 .operands = {{ // input04
1587 .channelQuant = {},
1588 .data = TestBuffer::createFromVector<uint8_t>({0}),
1589 .dimensions = {1},
1590 .isIgnored = false,
1591 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1592 .numberOfConsumers = 1,
1593 .scale = 1.64771f,
1594 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1595 .zeroPoint = 31
1596 }, { // input14
1597 .channelQuant = {},
1598 .data = TestBuffer::createFromVector<uint8_t>({200}),
1599 .dimensions = {1},
1600 .isIgnored = false,
1601 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1602 .numberOfConsumers = 1,
1603 .scale = 1.49725f,
1604 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1605 .zeroPoint = 240
1606 }, { // output04
1607 .channelQuant = {},
1608 .data = TestBuffer::createFromVector<bool8>({false}),
1609 .dimensions = {1},
1610 .isIgnored = false,
1611 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1612 .numberOfConsumers = 0,
1613 .scale = 0.0f,
1614 .type = TestOperandType::TENSOR_BOOL8,
1615 .zeroPoint = 0
1616 }},
1617 .operations = {{
1618 .inputs = {0, 1},
1619 .outputs = {2},
1620 .type = TestOperationType::LESS
1621 }},
1622 .outputIndexes = {2}
1623 },
1624 .minSupportedVersion = TestHalVersion::V1_2,
1625 .referenced = {}
1626 };
1627 return model;
1628 }
1629
1630 const auto dummy_test_model_quantized_overflow_second_input_if_requantized = TestModelManager::get().add("less_quantized_overflow_second_input_if_requantized", get_test_model_quantized_overflow_second_input_if_requantized());
1631
1632 } // namespace generated_tests::less
1633
1634 namespace generated_tests::less {
1635
get_test_model_quantized_overflow_second_input_if_requantized_all_inputs_as_internal()1636 const TestModel& get_test_model_quantized_overflow_second_input_if_requantized_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 = {{ // input04
1644 .channelQuant = {},
1645 .data = TestBuffer::createFromVector<uint8_t>({}),
1646 .dimensions = {1},
1647 .isIgnored = false,
1648 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1649 .numberOfConsumers = 1,
1650 .scale = 1.64771f,
1651 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1652 .zeroPoint = 31
1653 }, { // input14
1654 .channelQuant = {},
1655 .data = TestBuffer::createFromVector<uint8_t>({}),
1656 .dimensions = {1},
1657 .isIgnored = false,
1658 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1659 .numberOfConsumers = 1,
1660 .scale = 1.49725f,
1661 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1662 .zeroPoint = 240
1663 }, { // output04
1664 .channelQuant = {},
1665 .data = TestBuffer::createFromVector<bool8>({false}),
1666 .dimensions = {1},
1667 .isIgnored = false,
1668 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1669 .numberOfConsumers = 0,
1670 .scale = 0.0f,
1671 .type = TestOperandType::TENSOR_BOOL8,
1672 .zeroPoint = 0
1673 }, { // input04_new
1674 .channelQuant = {},
1675 .data = TestBuffer::createFromVector<uint8_t>({0}),
1676 .dimensions = {1},
1677 .isIgnored = false,
1678 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1679 .numberOfConsumers = 1,
1680 .scale = 1.64771f,
1681 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1682 .zeroPoint = 31
1683 }, { // dummy16
1684 .channelQuant = {},
1685 .data = TestBuffer::createFromVector<uint8_t>({31}),
1686 .dimensions = {1},
1687 .isIgnored = false,
1688 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1689 .numberOfConsumers = 1,
1690 .scale = 1.64771f,
1691 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1692 .zeroPoint = 31
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 }, { // input14_new
1704 .channelQuant = {},
1705 .data = TestBuffer::createFromVector<uint8_t>({200}),
1706 .dimensions = {1},
1707 .isIgnored = false,
1708 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1709 .numberOfConsumers = 1,
1710 .scale = 1.49725f,
1711 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1712 .zeroPoint = 240
1713 }, { // dummy17
1714 .channelQuant = {},
1715 .data = TestBuffer::createFromVector<uint8_t>({240}),
1716 .dimensions = {1},
1717 .isIgnored = false,
1718 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1719 .numberOfConsumers = 1,
1720 .scale = 1.49725f,
1721 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1722 .zeroPoint = 240
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::LESS
1746 }},
1747 .outputIndexes = {2}
1748 },
1749 .minSupportedVersion = TestHalVersion::V1_2,
1750 .referenced = {}
1751 };
1752 return model;
1753 }
1754
1755 const auto dummy_test_model_quantized_overflow_second_input_if_requantized_all_inputs_as_internal = TestModelManager::get().add("less_quantized_overflow_second_input_if_requantized_all_inputs_as_internal", get_test_model_quantized_overflow_second_input_if_requantized_all_inputs_as_internal());
1756
1757 } // namespace generated_tests::less
1758
1759 namespace generated_tests::less {
1760
get_test_model_quantized_overflow_first_input_if_requantized()1761 const TestModel& get_test_model_quantized_overflow_first_input_if_requantized() {
1762 static TestModel model = {
1763 .expectFailure = false,
1764 .expectedMultinomialDistributionTolerance = 0,
1765 .isRelaxed = false,
1766 .main = {
1767 .inputIndexes = {0, 1},
1768 .operands = {{ // input05
1769 .channelQuant = {},
1770 .data = TestBuffer::createFromVector<uint8_t>({200}),
1771 .dimensions = {1},
1772 .isIgnored = false,
1773 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1774 .numberOfConsumers = 1,
1775 .scale = 1.49725f,
1776 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1777 .zeroPoint = 240
1778 }, { // input15
1779 .channelQuant = {},
1780 .data = TestBuffer::createFromVector<uint8_t>({0}),
1781 .dimensions = {1},
1782 .isIgnored = false,
1783 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1784 .numberOfConsumers = 1,
1785 .scale = 1.64771f,
1786 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1787 .zeroPoint = 31
1788 }, { // output05
1789 .channelQuant = {},
1790 .data = TestBuffer::createFromVector<bool8>({true}),
1791 .dimensions = {1},
1792 .isIgnored = false,
1793 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1794 .numberOfConsumers = 0,
1795 .scale = 0.0f,
1796 .type = TestOperandType::TENSOR_BOOL8,
1797 .zeroPoint = 0
1798 }},
1799 .operations = {{
1800 .inputs = {0, 1},
1801 .outputs = {2},
1802 .type = TestOperationType::LESS
1803 }},
1804 .outputIndexes = {2}
1805 },
1806 .minSupportedVersion = TestHalVersion::V1_2,
1807 .referenced = {}
1808 };
1809 return model;
1810 }
1811
1812 const auto dummy_test_model_quantized_overflow_first_input_if_requantized = TestModelManager::get().add("less_quantized_overflow_first_input_if_requantized", get_test_model_quantized_overflow_first_input_if_requantized());
1813
1814 } // namespace generated_tests::less
1815
1816 namespace generated_tests::less {
1817
get_test_model_quantized_overflow_first_input_if_requantized_all_inputs_as_internal()1818 const TestModel& get_test_model_quantized_overflow_first_input_if_requantized_all_inputs_as_internal() {
1819 static TestModel model = {
1820 .expectFailure = false,
1821 .expectedMultinomialDistributionTolerance = 0,
1822 .isRelaxed = false,
1823 .main = {
1824 .inputIndexes = {3, 6},
1825 .operands = {{ // input05
1826 .channelQuant = {},
1827 .data = TestBuffer::createFromVector<uint8_t>({}),
1828 .dimensions = {1},
1829 .isIgnored = false,
1830 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1831 .numberOfConsumers = 1,
1832 .scale = 1.49725f,
1833 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1834 .zeroPoint = 240
1835 }, { // input15
1836 .channelQuant = {},
1837 .data = TestBuffer::createFromVector<uint8_t>({}),
1838 .dimensions = {1},
1839 .isIgnored = false,
1840 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1841 .numberOfConsumers = 1,
1842 .scale = 1.64771f,
1843 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1844 .zeroPoint = 31
1845 }, { // output05
1846 .channelQuant = {},
1847 .data = TestBuffer::createFromVector<bool8>({true}),
1848 .dimensions = {1},
1849 .isIgnored = false,
1850 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1851 .numberOfConsumers = 0,
1852 .scale = 0.0f,
1853 .type = TestOperandType::TENSOR_BOOL8,
1854 .zeroPoint = 0
1855 }, { // input05_new
1856 .channelQuant = {},
1857 .data = TestBuffer::createFromVector<uint8_t>({200}),
1858 .dimensions = {1},
1859 .isIgnored = false,
1860 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1861 .numberOfConsumers = 1,
1862 .scale = 1.49725f,
1863 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1864 .zeroPoint = 240
1865 }, { // dummy18
1866 .channelQuant = {},
1867 .data = TestBuffer::createFromVector<uint8_t>({240}),
1868 .dimensions = {1},
1869 .isIgnored = false,
1870 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1871 .numberOfConsumers = 1,
1872 .scale = 1.49725f,
1873 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1874 .zeroPoint = 240
1875 }, { // param18
1876 .channelQuant = {},
1877 .data = TestBuffer::createFromVector<int32_t>({0}),
1878 .dimensions = {},
1879 .isIgnored = false,
1880 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1881 .numberOfConsumers = 1,
1882 .scale = 0.0f,
1883 .type = TestOperandType::INT32,
1884 .zeroPoint = 0
1885 }, { // input15_new
1886 .channelQuant = {},
1887 .data = TestBuffer::createFromVector<uint8_t>({0}),
1888 .dimensions = {1},
1889 .isIgnored = false,
1890 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1891 .numberOfConsumers = 1,
1892 .scale = 1.64771f,
1893 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1894 .zeroPoint = 31
1895 }, { // dummy19
1896 .channelQuant = {},
1897 .data = TestBuffer::createFromVector<uint8_t>({31}),
1898 .dimensions = {1},
1899 .isIgnored = false,
1900 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1901 .numberOfConsumers = 1,
1902 .scale = 1.64771f,
1903 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1904 .zeroPoint = 31
1905 }, { // param19
1906 .channelQuant = {},
1907 .data = TestBuffer::createFromVector<int32_t>({0}),
1908 .dimensions = {},
1909 .isIgnored = false,
1910 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1911 .numberOfConsumers = 1,
1912 .scale = 0.0f,
1913 .type = TestOperandType::INT32,
1914 .zeroPoint = 0
1915 }},
1916 .operations = {{
1917 .inputs = {3, 4, 5},
1918 .outputs = {0},
1919 .type = TestOperationType::ADD
1920 }, {
1921 .inputs = {6, 7, 8},
1922 .outputs = {1},
1923 .type = TestOperationType::ADD
1924 }, {
1925 .inputs = {0, 1},
1926 .outputs = {2},
1927 .type = TestOperationType::LESS
1928 }},
1929 .outputIndexes = {2}
1930 },
1931 .minSupportedVersion = TestHalVersion::V1_2,
1932 .referenced = {}
1933 };
1934 return model;
1935 }
1936
1937 const auto dummy_test_model_quantized_overflow_first_input_if_requantized_all_inputs_as_internal = TestModelManager::get().add("less_quantized_overflow_first_input_if_requantized_all_inputs_as_internal", get_test_model_quantized_overflow_first_input_if_requantized_all_inputs_as_internal());
1938
1939 } // namespace generated_tests::less
1940
1941 namespace generated_tests::less {
1942
get_test_model_boolean()1943 const TestModel& get_test_model_boolean() {
1944 static TestModel model = {
1945 .expectFailure = false,
1946 .expectedMultinomialDistributionTolerance = 0,
1947 .isRelaxed = false,
1948 .main = {
1949 .inputIndexes = {0, 1},
1950 .operands = {{ // input06
1951 .channelQuant = {},
1952 .data = TestBuffer::createFromVector<bool8>({false, true, false, true}),
1953 .dimensions = {4},
1954 .isIgnored = false,
1955 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1956 .numberOfConsumers = 1,
1957 .scale = 0.0f,
1958 .type = TestOperandType::TENSOR_BOOL8,
1959 .zeroPoint = 0
1960 }, { // input16
1961 .channelQuant = {},
1962 .data = TestBuffer::createFromVector<bool8>({false, false, true, true}),
1963 .dimensions = {4},
1964 .isIgnored = false,
1965 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1966 .numberOfConsumers = 1,
1967 .scale = 0.0f,
1968 .type = TestOperandType::TENSOR_BOOL8,
1969 .zeroPoint = 0
1970 }, { // output06
1971 .channelQuant = {},
1972 .data = TestBuffer::createFromVector<bool8>({false, false, true, false}),
1973 .dimensions = {4},
1974 .isIgnored = false,
1975 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1976 .numberOfConsumers = 0,
1977 .scale = 0.0f,
1978 .type = TestOperandType::TENSOR_BOOL8,
1979 .zeroPoint = 0
1980 }},
1981 .operations = {{
1982 .inputs = {0, 1},
1983 .outputs = {2},
1984 .type = TestOperationType::LESS
1985 }},
1986 .outputIndexes = {2}
1987 },
1988 .minSupportedVersion = TestHalVersion::V1_2,
1989 .referenced = {}
1990 };
1991 return model;
1992 }
1993
1994 const auto dummy_test_model_boolean = TestModelManager::get().add("less_boolean", get_test_model_boolean());
1995
1996 } // namespace generated_tests::less
1997
1998