1 // clang-format off
2 // Generated file (from: not_equal.mod.py). Do not edit
3 // Create the model
createTestModel()4 Model createTestModel() {
5 const std::vector<Operand> operands = {
6 {
7 .type = OperandType::TENSOR_FLOAT32,
8 .dimensions = {3},
9 .numberOfConsumers = 1,
10 .scale = 0.0f,
11 .zeroPoint = 0,
12 .lifetime = OperandLifeTime::MODEL_INPUT,
13 .location = {.poolIndex = 0, .offset = 0, .length = 0},
14 },
15 {
16 .type = OperandType::TENSOR_FLOAT32,
17 .dimensions = {3},
18 .numberOfConsumers = 1,
19 .scale = 0.0f,
20 .zeroPoint = 0,
21 .lifetime = OperandLifeTime::MODEL_INPUT,
22 .location = {.poolIndex = 0, .offset = 0, .length = 0},
23 },
24 {
25 .type = OperandType::TENSOR_BOOL8,
26 .dimensions = {3},
27 .numberOfConsumers = 0,
28 .scale = 0.0f,
29 .zeroPoint = 0,
30 .lifetime = OperandLifeTime::MODEL_OUTPUT,
31 .location = {.poolIndex = 0, .offset = 0, .length = 0},
32 }
33 };
34
35 const std::vector<Operation> operations = {
36 {
37 .type = OperationType::NOT_EQUAL,
38 .inputs = {0, 1},
39 .outputs = {2},
40 }
41 };
42
43 const std::vector<uint32_t> inputIndexes = {0, 1};
44 const std::vector<uint32_t> outputIndexes = {2};
45 std::vector<uint8_t> operandValues = {};
46 const std::vector<hidl_memory> pools = {};
47
48 return {
49 .operands = operands,
50 .operations = operations,
51 .inputIndexes = inputIndexes,
52 .outputIndexes = outputIndexes,
53 .operandValues = operandValues,
54 .pools = pools,
55 };
56 }
57
is_ignored(int i)58 inline bool is_ignored(int i) {
59 static std::set<int> ignore = {};
60 return ignore.find(i) != ignore.end();
61 }
62
63 // Create the model
createTestModel_int32()64 Model createTestModel_int32() {
65 const std::vector<Operand> operands = {
66 {
67 .type = OperandType::TENSOR_INT32,
68 .dimensions = {3},
69 .numberOfConsumers = 1,
70 .scale = 0.0f,
71 .zeroPoint = 0,
72 .lifetime = OperandLifeTime::MODEL_INPUT,
73 .location = {.poolIndex = 0, .offset = 0, .length = 0},
74 },
75 {
76 .type = OperandType::TENSOR_INT32,
77 .dimensions = {3},
78 .numberOfConsumers = 1,
79 .scale = 0.0f,
80 .zeroPoint = 0,
81 .lifetime = OperandLifeTime::MODEL_INPUT,
82 .location = {.poolIndex = 0, .offset = 0, .length = 0},
83 },
84 {
85 .type = OperandType::TENSOR_BOOL8,
86 .dimensions = {3},
87 .numberOfConsumers = 0,
88 .scale = 0.0f,
89 .zeroPoint = 0,
90 .lifetime = OperandLifeTime::MODEL_OUTPUT,
91 .location = {.poolIndex = 0, .offset = 0, .length = 0},
92 }
93 };
94
95 const std::vector<Operation> operations = {
96 {
97 .type = OperationType::NOT_EQUAL,
98 .inputs = {0, 1},
99 .outputs = {2},
100 }
101 };
102
103 const std::vector<uint32_t> inputIndexes = {0, 1};
104 const std::vector<uint32_t> outputIndexes = {2};
105 std::vector<uint8_t> operandValues = {};
106 const std::vector<hidl_memory> pools = {};
107
108 return {
109 .operands = operands,
110 .operations = operations,
111 .inputIndexes = inputIndexes,
112 .outputIndexes = outputIndexes,
113 .operandValues = operandValues,
114 .pools = pools,
115 };
116 }
117
is_ignored_int32(int i)118 inline bool is_ignored_int32(int i) {
119 static std::set<int> ignore = {};
120 return ignore.find(i) != ignore.end();
121 }
122
123 // Create the model
createTestModel_float16()124 Model createTestModel_float16() {
125 const std::vector<Operand> operands = {
126 {
127 .type = OperandType::TENSOR_FLOAT16,
128 .dimensions = {3},
129 .numberOfConsumers = 1,
130 .scale = 0.0f,
131 .zeroPoint = 0,
132 .lifetime = OperandLifeTime::MODEL_INPUT,
133 .location = {.poolIndex = 0, .offset = 0, .length = 0},
134 },
135 {
136 .type = OperandType::TENSOR_FLOAT16,
137 .dimensions = {3},
138 .numberOfConsumers = 1,
139 .scale = 0.0f,
140 .zeroPoint = 0,
141 .lifetime = OperandLifeTime::MODEL_INPUT,
142 .location = {.poolIndex = 0, .offset = 0, .length = 0},
143 },
144 {
145 .type = OperandType::TENSOR_BOOL8,
146 .dimensions = {3},
147 .numberOfConsumers = 0,
148 .scale = 0.0f,
149 .zeroPoint = 0,
150 .lifetime = OperandLifeTime::MODEL_OUTPUT,
151 .location = {.poolIndex = 0, .offset = 0, .length = 0},
152 }
153 };
154
155 const std::vector<Operation> operations = {
156 {
157 .type = OperationType::NOT_EQUAL,
158 .inputs = {0, 1},
159 .outputs = {2},
160 }
161 };
162
163 const std::vector<uint32_t> inputIndexes = {0, 1};
164 const std::vector<uint32_t> outputIndexes = {2};
165 std::vector<uint8_t> operandValues = {};
166 const std::vector<hidl_memory> pools = {};
167
168 return {
169 .operands = operands,
170 .operations = operations,
171 .inputIndexes = inputIndexes,
172 .outputIndexes = outputIndexes,
173 .operandValues = operandValues,
174 .pools = pools,
175 };
176 }
177
is_ignored_float16(int i)178 inline bool is_ignored_float16(int i) {
179 static std::set<int> ignore = {};
180 return ignore.find(i) != ignore.end();
181 }
182
183 // Create the model
createTestModel_relaxed()184 Model createTestModel_relaxed() {
185 const std::vector<Operand> operands = {
186 {
187 .type = OperandType::TENSOR_FLOAT32,
188 .dimensions = {3},
189 .numberOfConsumers = 1,
190 .scale = 0.0f,
191 .zeroPoint = 0,
192 .lifetime = OperandLifeTime::MODEL_INPUT,
193 .location = {.poolIndex = 0, .offset = 0, .length = 0},
194 },
195 {
196 .type = OperandType::TENSOR_FLOAT32,
197 .dimensions = {3},
198 .numberOfConsumers = 1,
199 .scale = 0.0f,
200 .zeroPoint = 0,
201 .lifetime = OperandLifeTime::MODEL_INPUT,
202 .location = {.poolIndex = 0, .offset = 0, .length = 0},
203 },
204 {
205 .type = OperandType::TENSOR_BOOL8,
206 .dimensions = {3},
207 .numberOfConsumers = 0,
208 .scale = 0.0f,
209 .zeroPoint = 0,
210 .lifetime = OperandLifeTime::MODEL_OUTPUT,
211 .location = {.poolIndex = 0, .offset = 0, .length = 0},
212 }
213 };
214
215 const std::vector<Operation> operations = {
216 {
217 .type = OperationType::NOT_EQUAL,
218 .inputs = {0, 1},
219 .outputs = {2},
220 }
221 };
222
223 const std::vector<uint32_t> inputIndexes = {0, 1};
224 const std::vector<uint32_t> outputIndexes = {2};
225 std::vector<uint8_t> operandValues = {};
226 const std::vector<hidl_memory> pools = {};
227
228 return {
229 .operands = operands,
230 .operations = operations,
231 .inputIndexes = inputIndexes,
232 .outputIndexes = outputIndexes,
233 .operandValues = operandValues,
234 .pools = pools,
235 .relaxComputationFloat32toFloat16 = true,
236 };
237 }
238
is_ignored_relaxed(int i)239 inline bool is_ignored_relaxed(int i) {
240 static std::set<int> ignore = {};
241 return ignore.find(i) != ignore.end();
242 }
243
244 // Create the model
createTestModel_dynamic_output_shape()245 Model createTestModel_dynamic_output_shape() {
246 const std::vector<Operand> operands = {
247 {
248 .type = OperandType::TENSOR_FLOAT32,
249 .dimensions = {3},
250 .numberOfConsumers = 1,
251 .scale = 0.0f,
252 .zeroPoint = 0,
253 .lifetime = OperandLifeTime::MODEL_INPUT,
254 .location = {.poolIndex = 0, .offset = 0, .length = 0},
255 },
256 {
257 .type = OperandType::TENSOR_FLOAT32,
258 .dimensions = {3},
259 .numberOfConsumers = 1,
260 .scale = 0.0f,
261 .zeroPoint = 0,
262 .lifetime = OperandLifeTime::MODEL_INPUT,
263 .location = {.poolIndex = 0, .offset = 0, .length = 0},
264 },
265 {
266 .type = OperandType::TENSOR_BOOL8,
267 .dimensions = {0},
268 .numberOfConsumers = 0,
269 .scale = 0.0f,
270 .zeroPoint = 0,
271 .lifetime = OperandLifeTime::MODEL_OUTPUT,
272 .location = {.poolIndex = 0, .offset = 0, .length = 0},
273 }
274 };
275
276 const std::vector<Operation> operations = {
277 {
278 .type = OperationType::NOT_EQUAL,
279 .inputs = {0, 1},
280 .outputs = {2},
281 }
282 };
283
284 const std::vector<uint32_t> inputIndexes = {0, 1};
285 const std::vector<uint32_t> outputIndexes = {2};
286 std::vector<uint8_t> operandValues = {};
287 const std::vector<hidl_memory> pools = {};
288
289 return {
290 .operands = operands,
291 .operations = operations,
292 .inputIndexes = inputIndexes,
293 .outputIndexes = outputIndexes,
294 .operandValues = operandValues,
295 .pools = pools,
296 };
297 }
298
is_ignored_dynamic_output_shape(int i)299 inline bool is_ignored_dynamic_output_shape(int i) {
300 static std::set<int> ignore = {};
301 return ignore.find(i) != ignore.end();
302 }
303
304 // Create the model
createTestModel_dynamic_output_shape_int32()305 Model createTestModel_dynamic_output_shape_int32() {
306 const std::vector<Operand> operands = {
307 {
308 .type = OperandType::TENSOR_INT32,
309 .dimensions = {3},
310 .numberOfConsumers = 1,
311 .scale = 0.0f,
312 .zeroPoint = 0,
313 .lifetime = OperandLifeTime::MODEL_INPUT,
314 .location = {.poolIndex = 0, .offset = 0, .length = 0},
315 },
316 {
317 .type = OperandType::TENSOR_INT32,
318 .dimensions = {3},
319 .numberOfConsumers = 1,
320 .scale = 0.0f,
321 .zeroPoint = 0,
322 .lifetime = OperandLifeTime::MODEL_INPUT,
323 .location = {.poolIndex = 0, .offset = 0, .length = 0},
324 },
325 {
326 .type = OperandType::TENSOR_BOOL8,
327 .dimensions = {0},
328 .numberOfConsumers = 0,
329 .scale = 0.0f,
330 .zeroPoint = 0,
331 .lifetime = OperandLifeTime::MODEL_OUTPUT,
332 .location = {.poolIndex = 0, .offset = 0, .length = 0},
333 }
334 };
335
336 const std::vector<Operation> operations = {
337 {
338 .type = OperationType::NOT_EQUAL,
339 .inputs = {0, 1},
340 .outputs = {2},
341 }
342 };
343
344 const std::vector<uint32_t> inputIndexes = {0, 1};
345 const std::vector<uint32_t> outputIndexes = {2};
346 std::vector<uint8_t> operandValues = {};
347 const std::vector<hidl_memory> pools = {};
348
349 return {
350 .operands = operands,
351 .operations = operations,
352 .inputIndexes = inputIndexes,
353 .outputIndexes = outputIndexes,
354 .operandValues = operandValues,
355 .pools = pools,
356 };
357 }
358
is_ignored_dynamic_output_shape_int32(int i)359 inline bool is_ignored_dynamic_output_shape_int32(int i) {
360 static std::set<int> ignore = {};
361 return ignore.find(i) != ignore.end();
362 }
363
364 // Create the model
createTestModel_dynamic_output_shape_float16()365 Model createTestModel_dynamic_output_shape_float16() {
366 const std::vector<Operand> operands = {
367 {
368 .type = OperandType::TENSOR_FLOAT16,
369 .dimensions = {3},
370 .numberOfConsumers = 1,
371 .scale = 0.0f,
372 .zeroPoint = 0,
373 .lifetime = OperandLifeTime::MODEL_INPUT,
374 .location = {.poolIndex = 0, .offset = 0, .length = 0},
375 },
376 {
377 .type = OperandType::TENSOR_FLOAT16,
378 .dimensions = {3},
379 .numberOfConsumers = 1,
380 .scale = 0.0f,
381 .zeroPoint = 0,
382 .lifetime = OperandLifeTime::MODEL_INPUT,
383 .location = {.poolIndex = 0, .offset = 0, .length = 0},
384 },
385 {
386 .type = OperandType::TENSOR_BOOL8,
387 .dimensions = {0},
388 .numberOfConsumers = 0,
389 .scale = 0.0f,
390 .zeroPoint = 0,
391 .lifetime = OperandLifeTime::MODEL_OUTPUT,
392 .location = {.poolIndex = 0, .offset = 0, .length = 0},
393 }
394 };
395
396 const std::vector<Operation> operations = {
397 {
398 .type = OperationType::NOT_EQUAL,
399 .inputs = {0, 1},
400 .outputs = {2},
401 }
402 };
403
404 const std::vector<uint32_t> inputIndexes = {0, 1};
405 const std::vector<uint32_t> outputIndexes = {2};
406 std::vector<uint8_t> operandValues = {};
407 const std::vector<hidl_memory> pools = {};
408
409 return {
410 .operands = operands,
411 .operations = operations,
412 .inputIndexes = inputIndexes,
413 .outputIndexes = outputIndexes,
414 .operandValues = operandValues,
415 .pools = pools,
416 };
417 }
418
is_ignored_dynamic_output_shape_float16(int i)419 inline bool is_ignored_dynamic_output_shape_float16(int i) {
420 static std::set<int> ignore = {};
421 return ignore.find(i) != ignore.end();
422 }
423
424 // Create the model
createTestModel_dynamic_output_shape_relaxed()425 Model createTestModel_dynamic_output_shape_relaxed() {
426 const std::vector<Operand> operands = {
427 {
428 .type = OperandType::TENSOR_FLOAT32,
429 .dimensions = {3},
430 .numberOfConsumers = 1,
431 .scale = 0.0f,
432 .zeroPoint = 0,
433 .lifetime = OperandLifeTime::MODEL_INPUT,
434 .location = {.poolIndex = 0, .offset = 0, .length = 0},
435 },
436 {
437 .type = OperandType::TENSOR_FLOAT32,
438 .dimensions = {3},
439 .numberOfConsumers = 1,
440 .scale = 0.0f,
441 .zeroPoint = 0,
442 .lifetime = OperandLifeTime::MODEL_INPUT,
443 .location = {.poolIndex = 0, .offset = 0, .length = 0},
444 },
445 {
446 .type = OperandType::TENSOR_BOOL8,
447 .dimensions = {0},
448 .numberOfConsumers = 0,
449 .scale = 0.0f,
450 .zeroPoint = 0,
451 .lifetime = OperandLifeTime::MODEL_OUTPUT,
452 .location = {.poolIndex = 0, .offset = 0, .length = 0},
453 }
454 };
455
456 const std::vector<Operation> operations = {
457 {
458 .type = OperationType::NOT_EQUAL,
459 .inputs = {0, 1},
460 .outputs = {2},
461 }
462 };
463
464 const std::vector<uint32_t> inputIndexes = {0, 1};
465 const std::vector<uint32_t> outputIndexes = {2};
466 std::vector<uint8_t> operandValues = {};
467 const std::vector<hidl_memory> pools = {};
468
469 return {
470 .operands = operands,
471 .operations = operations,
472 .inputIndexes = inputIndexes,
473 .outputIndexes = outputIndexes,
474 .operandValues = operandValues,
475 .pools = pools,
476 .relaxComputationFloat32toFloat16 = true,
477 };
478 }
479
is_ignored_dynamic_output_shape_relaxed(int i)480 inline bool is_ignored_dynamic_output_shape_relaxed(int i) {
481 static std::set<int> ignore = {};
482 return ignore.find(i) != ignore.end();
483 }
484
485 // Create the model
createTestModel_2()486 Model createTestModel_2() {
487 const std::vector<Operand> operands = {
488 {
489 .type = OperandType::TENSOR_FLOAT32,
490 .dimensions = {2, 1},
491 .numberOfConsumers = 1,
492 .scale = 0.0f,
493 .zeroPoint = 0,
494 .lifetime = OperandLifeTime::MODEL_INPUT,
495 .location = {.poolIndex = 0, .offset = 0, .length = 0},
496 },
497 {
498 .type = OperandType::TENSOR_FLOAT32,
499 .dimensions = {2},
500 .numberOfConsumers = 1,
501 .scale = 0.0f,
502 .zeroPoint = 0,
503 .lifetime = OperandLifeTime::MODEL_INPUT,
504 .location = {.poolIndex = 0, .offset = 0, .length = 0},
505 },
506 {
507 .type = OperandType::TENSOR_BOOL8,
508 .dimensions = {2, 2},
509 .numberOfConsumers = 0,
510 .scale = 0.0f,
511 .zeroPoint = 0,
512 .lifetime = OperandLifeTime::MODEL_OUTPUT,
513 .location = {.poolIndex = 0, .offset = 0, .length = 0},
514 }
515 };
516
517 const std::vector<Operation> operations = {
518 {
519 .type = OperationType::NOT_EQUAL,
520 .inputs = {0, 1},
521 .outputs = {2},
522 }
523 };
524
525 const std::vector<uint32_t> inputIndexes = {0, 1};
526 const std::vector<uint32_t> outputIndexes = {2};
527 std::vector<uint8_t> operandValues = {};
528 const std::vector<hidl_memory> pools = {};
529
530 return {
531 .operands = operands,
532 .operations = operations,
533 .inputIndexes = inputIndexes,
534 .outputIndexes = outputIndexes,
535 .operandValues = operandValues,
536 .pools = pools,
537 };
538 }
539
is_ignored_2(int i)540 inline bool is_ignored_2(int i) {
541 static std::set<int> ignore = {};
542 return ignore.find(i) != ignore.end();
543 }
544
545 // Create the model
createTestModel_int32_2()546 Model createTestModel_int32_2() {
547 const std::vector<Operand> operands = {
548 {
549 .type = OperandType::TENSOR_INT32,
550 .dimensions = {2, 1},
551 .numberOfConsumers = 1,
552 .scale = 0.0f,
553 .zeroPoint = 0,
554 .lifetime = OperandLifeTime::MODEL_INPUT,
555 .location = {.poolIndex = 0, .offset = 0, .length = 0},
556 },
557 {
558 .type = OperandType::TENSOR_INT32,
559 .dimensions = {2},
560 .numberOfConsumers = 1,
561 .scale = 0.0f,
562 .zeroPoint = 0,
563 .lifetime = OperandLifeTime::MODEL_INPUT,
564 .location = {.poolIndex = 0, .offset = 0, .length = 0},
565 },
566 {
567 .type = OperandType::TENSOR_BOOL8,
568 .dimensions = {2, 2},
569 .numberOfConsumers = 0,
570 .scale = 0.0f,
571 .zeroPoint = 0,
572 .lifetime = OperandLifeTime::MODEL_OUTPUT,
573 .location = {.poolIndex = 0, .offset = 0, .length = 0},
574 }
575 };
576
577 const std::vector<Operation> operations = {
578 {
579 .type = OperationType::NOT_EQUAL,
580 .inputs = {0, 1},
581 .outputs = {2},
582 }
583 };
584
585 const std::vector<uint32_t> inputIndexes = {0, 1};
586 const std::vector<uint32_t> outputIndexes = {2};
587 std::vector<uint8_t> operandValues = {};
588 const std::vector<hidl_memory> pools = {};
589
590 return {
591 .operands = operands,
592 .operations = operations,
593 .inputIndexes = inputIndexes,
594 .outputIndexes = outputIndexes,
595 .operandValues = operandValues,
596 .pools = pools,
597 };
598 }
599
is_ignored_int32_2(int i)600 inline bool is_ignored_int32_2(int i) {
601 static std::set<int> ignore = {};
602 return ignore.find(i) != ignore.end();
603 }
604
605 // Create the model
createTestModel_float16_2()606 Model createTestModel_float16_2() {
607 const std::vector<Operand> operands = {
608 {
609 .type = OperandType::TENSOR_FLOAT16,
610 .dimensions = {2, 1},
611 .numberOfConsumers = 1,
612 .scale = 0.0f,
613 .zeroPoint = 0,
614 .lifetime = OperandLifeTime::MODEL_INPUT,
615 .location = {.poolIndex = 0, .offset = 0, .length = 0},
616 },
617 {
618 .type = OperandType::TENSOR_FLOAT16,
619 .dimensions = {2},
620 .numberOfConsumers = 1,
621 .scale = 0.0f,
622 .zeroPoint = 0,
623 .lifetime = OperandLifeTime::MODEL_INPUT,
624 .location = {.poolIndex = 0, .offset = 0, .length = 0},
625 },
626 {
627 .type = OperandType::TENSOR_BOOL8,
628 .dimensions = {2, 2},
629 .numberOfConsumers = 0,
630 .scale = 0.0f,
631 .zeroPoint = 0,
632 .lifetime = OperandLifeTime::MODEL_OUTPUT,
633 .location = {.poolIndex = 0, .offset = 0, .length = 0},
634 }
635 };
636
637 const std::vector<Operation> operations = {
638 {
639 .type = OperationType::NOT_EQUAL,
640 .inputs = {0, 1},
641 .outputs = {2},
642 }
643 };
644
645 const std::vector<uint32_t> inputIndexes = {0, 1};
646 const std::vector<uint32_t> outputIndexes = {2};
647 std::vector<uint8_t> operandValues = {};
648 const std::vector<hidl_memory> pools = {};
649
650 return {
651 .operands = operands,
652 .operations = operations,
653 .inputIndexes = inputIndexes,
654 .outputIndexes = outputIndexes,
655 .operandValues = operandValues,
656 .pools = pools,
657 };
658 }
659
is_ignored_float16_2(int i)660 inline bool is_ignored_float16_2(int i) {
661 static std::set<int> ignore = {};
662 return ignore.find(i) != ignore.end();
663 }
664
665 // Create the model
createTestModel_relaxed_2()666 Model createTestModel_relaxed_2() {
667 const std::vector<Operand> operands = {
668 {
669 .type = OperandType::TENSOR_FLOAT32,
670 .dimensions = {2, 1},
671 .numberOfConsumers = 1,
672 .scale = 0.0f,
673 .zeroPoint = 0,
674 .lifetime = OperandLifeTime::MODEL_INPUT,
675 .location = {.poolIndex = 0, .offset = 0, .length = 0},
676 },
677 {
678 .type = OperandType::TENSOR_FLOAT32,
679 .dimensions = {2},
680 .numberOfConsumers = 1,
681 .scale = 0.0f,
682 .zeroPoint = 0,
683 .lifetime = OperandLifeTime::MODEL_INPUT,
684 .location = {.poolIndex = 0, .offset = 0, .length = 0},
685 },
686 {
687 .type = OperandType::TENSOR_BOOL8,
688 .dimensions = {2, 2},
689 .numberOfConsumers = 0,
690 .scale = 0.0f,
691 .zeroPoint = 0,
692 .lifetime = OperandLifeTime::MODEL_OUTPUT,
693 .location = {.poolIndex = 0, .offset = 0, .length = 0},
694 }
695 };
696
697 const std::vector<Operation> operations = {
698 {
699 .type = OperationType::NOT_EQUAL,
700 .inputs = {0, 1},
701 .outputs = {2},
702 }
703 };
704
705 const std::vector<uint32_t> inputIndexes = {0, 1};
706 const std::vector<uint32_t> outputIndexes = {2};
707 std::vector<uint8_t> operandValues = {};
708 const std::vector<hidl_memory> pools = {};
709
710 return {
711 .operands = operands,
712 .operations = operations,
713 .inputIndexes = inputIndexes,
714 .outputIndexes = outputIndexes,
715 .operandValues = operandValues,
716 .pools = pools,
717 .relaxComputationFloat32toFloat16 = true,
718 };
719 }
720
is_ignored_relaxed_2(int i)721 inline bool is_ignored_relaxed_2(int i) {
722 static std::set<int> ignore = {};
723 return ignore.find(i) != ignore.end();
724 }
725
726 // Create the model
createTestModel_dynamic_output_shape_2()727 Model createTestModel_dynamic_output_shape_2() {
728 const std::vector<Operand> operands = {
729 {
730 .type = OperandType::TENSOR_FLOAT32,
731 .dimensions = {2, 1},
732 .numberOfConsumers = 1,
733 .scale = 0.0f,
734 .zeroPoint = 0,
735 .lifetime = OperandLifeTime::MODEL_INPUT,
736 .location = {.poolIndex = 0, .offset = 0, .length = 0},
737 },
738 {
739 .type = OperandType::TENSOR_FLOAT32,
740 .dimensions = {2},
741 .numberOfConsumers = 1,
742 .scale = 0.0f,
743 .zeroPoint = 0,
744 .lifetime = OperandLifeTime::MODEL_INPUT,
745 .location = {.poolIndex = 0, .offset = 0, .length = 0},
746 },
747 {
748 .type = OperandType::TENSOR_BOOL8,
749 .dimensions = {0, 0},
750 .numberOfConsumers = 0,
751 .scale = 0.0f,
752 .zeroPoint = 0,
753 .lifetime = OperandLifeTime::MODEL_OUTPUT,
754 .location = {.poolIndex = 0, .offset = 0, .length = 0},
755 }
756 };
757
758 const std::vector<Operation> operations = {
759 {
760 .type = OperationType::NOT_EQUAL,
761 .inputs = {0, 1},
762 .outputs = {2},
763 }
764 };
765
766 const std::vector<uint32_t> inputIndexes = {0, 1};
767 const std::vector<uint32_t> outputIndexes = {2};
768 std::vector<uint8_t> operandValues = {};
769 const std::vector<hidl_memory> pools = {};
770
771 return {
772 .operands = operands,
773 .operations = operations,
774 .inputIndexes = inputIndexes,
775 .outputIndexes = outputIndexes,
776 .operandValues = operandValues,
777 .pools = pools,
778 };
779 }
780
is_ignored_dynamic_output_shape_2(int i)781 inline bool is_ignored_dynamic_output_shape_2(int i) {
782 static std::set<int> ignore = {};
783 return ignore.find(i) != ignore.end();
784 }
785
786 // Create the model
createTestModel_dynamic_output_shape_int32_2()787 Model createTestModel_dynamic_output_shape_int32_2() {
788 const std::vector<Operand> operands = {
789 {
790 .type = OperandType::TENSOR_INT32,
791 .dimensions = {2, 1},
792 .numberOfConsumers = 1,
793 .scale = 0.0f,
794 .zeroPoint = 0,
795 .lifetime = OperandLifeTime::MODEL_INPUT,
796 .location = {.poolIndex = 0, .offset = 0, .length = 0},
797 },
798 {
799 .type = OperandType::TENSOR_INT32,
800 .dimensions = {2},
801 .numberOfConsumers = 1,
802 .scale = 0.0f,
803 .zeroPoint = 0,
804 .lifetime = OperandLifeTime::MODEL_INPUT,
805 .location = {.poolIndex = 0, .offset = 0, .length = 0},
806 },
807 {
808 .type = OperandType::TENSOR_BOOL8,
809 .dimensions = {0, 0},
810 .numberOfConsumers = 0,
811 .scale = 0.0f,
812 .zeroPoint = 0,
813 .lifetime = OperandLifeTime::MODEL_OUTPUT,
814 .location = {.poolIndex = 0, .offset = 0, .length = 0},
815 }
816 };
817
818 const std::vector<Operation> operations = {
819 {
820 .type = OperationType::NOT_EQUAL,
821 .inputs = {0, 1},
822 .outputs = {2},
823 }
824 };
825
826 const std::vector<uint32_t> inputIndexes = {0, 1};
827 const std::vector<uint32_t> outputIndexes = {2};
828 std::vector<uint8_t> operandValues = {};
829 const std::vector<hidl_memory> pools = {};
830
831 return {
832 .operands = operands,
833 .operations = operations,
834 .inputIndexes = inputIndexes,
835 .outputIndexes = outputIndexes,
836 .operandValues = operandValues,
837 .pools = pools,
838 };
839 }
840
is_ignored_dynamic_output_shape_int32_2(int i)841 inline bool is_ignored_dynamic_output_shape_int32_2(int i) {
842 static std::set<int> ignore = {};
843 return ignore.find(i) != ignore.end();
844 }
845
846 // Create the model
createTestModel_dynamic_output_shape_float16_2()847 Model createTestModel_dynamic_output_shape_float16_2() {
848 const std::vector<Operand> operands = {
849 {
850 .type = OperandType::TENSOR_FLOAT16,
851 .dimensions = {2, 1},
852 .numberOfConsumers = 1,
853 .scale = 0.0f,
854 .zeroPoint = 0,
855 .lifetime = OperandLifeTime::MODEL_INPUT,
856 .location = {.poolIndex = 0, .offset = 0, .length = 0},
857 },
858 {
859 .type = OperandType::TENSOR_FLOAT16,
860 .dimensions = {2},
861 .numberOfConsumers = 1,
862 .scale = 0.0f,
863 .zeroPoint = 0,
864 .lifetime = OperandLifeTime::MODEL_INPUT,
865 .location = {.poolIndex = 0, .offset = 0, .length = 0},
866 },
867 {
868 .type = OperandType::TENSOR_BOOL8,
869 .dimensions = {0, 0},
870 .numberOfConsumers = 0,
871 .scale = 0.0f,
872 .zeroPoint = 0,
873 .lifetime = OperandLifeTime::MODEL_OUTPUT,
874 .location = {.poolIndex = 0, .offset = 0, .length = 0},
875 }
876 };
877
878 const std::vector<Operation> operations = {
879 {
880 .type = OperationType::NOT_EQUAL,
881 .inputs = {0, 1},
882 .outputs = {2},
883 }
884 };
885
886 const std::vector<uint32_t> inputIndexes = {0, 1};
887 const std::vector<uint32_t> outputIndexes = {2};
888 std::vector<uint8_t> operandValues = {};
889 const std::vector<hidl_memory> pools = {};
890
891 return {
892 .operands = operands,
893 .operations = operations,
894 .inputIndexes = inputIndexes,
895 .outputIndexes = outputIndexes,
896 .operandValues = operandValues,
897 .pools = pools,
898 };
899 }
900
is_ignored_dynamic_output_shape_float16_2(int i)901 inline bool is_ignored_dynamic_output_shape_float16_2(int i) {
902 static std::set<int> ignore = {};
903 return ignore.find(i) != ignore.end();
904 }
905
906 // Create the model
createTestModel_dynamic_output_shape_relaxed_2()907 Model createTestModel_dynamic_output_shape_relaxed_2() {
908 const std::vector<Operand> operands = {
909 {
910 .type = OperandType::TENSOR_FLOAT32,
911 .dimensions = {2, 1},
912 .numberOfConsumers = 1,
913 .scale = 0.0f,
914 .zeroPoint = 0,
915 .lifetime = OperandLifeTime::MODEL_INPUT,
916 .location = {.poolIndex = 0, .offset = 0, .length = 0},
917 },
918 {
919 .type = OperandType::TENSOR_FLOAT32,
920 .dimensions = {2},
921 .numberOfConsumers = 1,
922 .scale = 0.0f,
923 .zeroPoint = 0,
924 .lifetime = OperandLifeTime::MODEL_INPUT,
925 .location = {.poolIndex = 0, .offset = 0, .length = 0},
926 },
927 {
928 .type = OperandType::TENSOR_BOOL8,
929 .dimensions = {0, 0},
930 .numberOfConsumers = 0,
931 .scale = 0.0f,
932 .zeroPoint = 0,
933 .lifetime = OperandLifeTime::MODEL_OUTPUT,
934 .location = {.poolIndex = 0, .offset = 0, .length = 0},
935 }
936 };
937
938 const std::vector<Operation> operations = {
939 {
940 .type = OperationType::NOT_EQUAL,
941 .inputs = {0, 1},
942 .outputs = {2},
943 }
944 };
945
946 const std::vector<uint32_t> inputIndexes = {0, 1};
947 const std::vector<uint32_t> outputIndexes = {2};
948 std::vector<uint8_t> operandValues = {};
949 const std::vector<hidl_memory> pools = {};
950
951 return {
952 .operands = operands,
953 .operations = operations,
954 .inputIndexes = inputIndexes,
955 .outputIndexes = outputIndexes,
956 .operandValues = operandValues,
957 .pools = pools,
958 .relaxComputationFloat32toFloat16 = true,
959 };
960 }
961
is_ignored_dynamic_output_shape_relaxed_2(int i)962 inline bool is_ignored_dynamic_output_shape_relaxed_2(int i) {
963 static std::set<int> ignore = {};
964 return ignore.find(i) != ignore.end();
965 }
966
967 // Create the model
createTestModel_3()968 Model createTestModel_3() {
969 const std::vector<Operand> operands = {
970 {
971 .type = OperandType::TENSOR_QUANT8_ASYMM,
972 .dimensions = {3},
973 .numberOfConsumers = 1,
974 .scale = 1.0f,
975 .zeroPoint = 128,
976 .lifetime = OperandLifeTime::MODEL_INPUT,
977 .location = {.poolIndex = 0, .offset = 0, .length = 0},
978 },
979 {
980 .type = OperandType::TENSOR_QUANT8_ASYMM,
981 .dimensions = {1},
982 .numberOfConsumers = 1,
983 .scale = 2.0f,
984 .zeroPoint = 128,
985 .lifetime = OperandLifeTime::MODEL_INPUT,
986 .location = {.poolIndex = 0, .offset = 0, .length = 0},
987 },
988 {
989 .type = OperandType::TENSOR_BOOL8,
990 .dimensions = {3},
991 .numberOfConsumers = 0,
992 .scale = 0.0f,
993 .zeroPoint = 0,
994 .lifetime = OperandLifeTime::MODEL_OUTPUT,
995 .location = {.poolIndex = 0, .offset = 0, .length = 0},
996 }
997 };
998
999 const std::vector<Operation> operations = {
1000 {
1001 .type = OperationType::NOT_EQUAL,
1002 .inputs = {0, 1},
1003 .outputs = {2},
1004 }
1005 };
1006
1007 const std::vector<uint32_t> inputIndexes = {0, 1};
1008 const std::vector<uint32_t> outputIndexes = {2};
1009 std::vector<uint8_t> operandValues = {};
1010 const std::vector<hidl_memory> pools = {};
1011
1012 return {
1013 .operands = operands,
1014 .operations = operations,
1015 .inputIndexes = inputIndexes,
1016 .outputIndexes = outputIndexes,
1017 .operandValues = operandValues,
1018 .pools = pools,
1019 };
1020 }
1021
is_ignored_3(int i)1022 inline bool is_ignored_3(int i) {
1023 static std::set<int> ignore = {};
1024 return ignore.find(i) != ignore.end();
1025 }
1026
1027 // Create the model
createTestModel_dynamic_output_shape_3()1028 Model createTestModel_dynamic_output_shape_3() {
1029 const std::vector<Operand> operands = {
1030 {
1031 .type = OperandType::TENSOR_QUANT8_ASYMM,
1032 .dimensions = {3},
1033 .numberOfConsumers = 1,
1034 .scale = 1.0f,
1035 .zeroPoint = 128,
1036 .lifetime = OperandLifeTime::MODEL_INPUT,
1037 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1038 },
1039 {
1040 .type = OperandType::TENSOR_QUANT8_ASYMM,
1041 .dimensions = {1},
1042 .numberOfConsumers = 1,
1043 .scale = 2.0f,
1044 .zeroPoint = 128,
1045 .lifetime = OperandLifeTime::MODEL_INPUT,
1046 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1047 },
1048 {
1049 .type = OperandType::TENSOR_BOOL8,
1050 .dimensions = {0},
1051 .numberOfConsumers = 0,
1052 .scale = 0.0f,
1053 .zeroPoint = 0,
1054 .lifetime = OperandLifeTime::MODEL_OUTPUT,
1055 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1056 }
1057 };
1058
1059 const std::vector<Operation> operations = {
1060 {
1061 .type = OperationType::NOT_EQUAL,
1062 .inputs = {0, 1},
1063 .outputs = {2},
1064 }
1065 };
1066
1067 const std::vector<uint32_t> inputIndexes = {0, 1};
1068 const std::vector<uint32_t> outputIndexes = {2};
1069 std::vector<uint8_t> operandValues = {};
1070 const std::vector<hidl_memory> pools = {};
1071
1072 return {
1073 .operands = operands,
1074 .operations = operations,
1075 .inputIndexes = inputIndexes,
1076 .outputIndexes = outputIndexes,
1077 .operandValues = operandValues,
1078 .pools = pools,
1079 };
1080 }
1081
is_ignored_dynamic_output_shape_3(int i)1082 inline bool is_ignored_dynamic_output_shape_3(int i) {
1083 static std::set<int> ignore = {};
1084 return ignore.find(i) != ignore.end();
1085 }
1086
1087 // Create the model
createTestModel_4()1088 Model createTestModel_4() {
1089 const std::vector<Operand> operands = {
1090 {
1091 .type = OperandType::TENSOR_QUANT8_ASYMM,
1092 .dimensions = {3},
1093 .numberOfConsumers = 1,
1094 .scale = 1.0f,
1095 .zeroPoint = 128,
1096 .lifetime = OperandLifeTime::MODEL_INPUT,
1097 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1098 },
1099 {
1100 .type = OperandType::TENSOR_QUANT8_ASYMM,
1101 .dimensions = {1},
1102 .numberOfConsumers = 1,
1103 .scale = 1.0f,
1104 .zeroPoint = 129,
1105 .lifetime = OperandLifeTime::MODEL_INPUT,
1106 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1107 },
1108 {
1109 .type = OperandType::TENSOR_BOOL8,
1110 .dimensions = {3},
1111 .numberOfConsumers = 0,
1112 .scale = 0.0f,
1113 .zeroPoint = 0,
1114 .lifetime = OperandLifeTime::MODEL_OUTPUT,
1115 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1116 }
1117 };
1118
1119 const std::vector<Operation> operations = {
1120 {
1121 .type = OperationType::NOT_EQUAL,
1122 .inputs = {0, 1},
1123 .outputs = {2},
1124 }
1125 };
1126
1127 const std::vector<uint32_t> inputIndexes = {0, 1};
1128 const std::vector<uint32_t> outputIndexes = {2};
1129 std::vector<uint8_t> operandValues = {};
1130 const std::vector<hidl_memory> pools = {};
1131
1132 return {
1133 .operands = operands,
1134 .operations = operations,
1135 .inputIndexes = inputIndexes,
1136 .outputIndexes = outputIndexes,
1137 .operandValues = operandValues,
1138 .pools = pools,
1139 };
1140 }
1141
is_ignored_4(int i)1142 inline bool is_ignored_4(int i) {
1143 static std::set<int> ignore = {};
1144 return ignore.find(i) != ignore.end();
1145 }
1146
1147 // Create the model
createTestModel_dynamic_output_shape_4()1148 Model createTestModel_dynamic_output_shape_4() {
1149 const std::vector<Operand> operands = {
1150 {
1151 .type = OperandType::TENSOR_QUANT8_ASYMM,
1152 .dimensions = {3},
1153 .numberOfConsumers = 1,
1154 .scale = 1.0f,
1155 .zeroPoint = 128,
1156 .lifetime = OperandLifeTime::MODEL_INPUT,
1157 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1158 },
1159 {
1160 .type = OperandType::TENSOR_QUANT8_ASYMM,
1161 .dimensions = {1},
1162 .numberOfConsumers = 1,
1163 .scale = 1.0f,
1164 .zeroPoint = 129,
1165 .lifetime = OperandLifeTime::MODEL_INPUT,
1166 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1167 },
1168 {
1169 .type = OperandType::TENSOR_BOOL8,
1170 .dimensions = {0},
1171 .numberOfConsumers = 0,
1172 .scale = 0.0f,
1173 .zeroPoint = 0,
1174 .lifetime = OperandLifeTime::MODEL_OUTPUT,
1175 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1176 }
1177 };
1178
1179 const std::vector<Operation> operations = {
1180 {
1181 .type = OperationType::NOT_EQUAL,
1182 .inputs = {0, 1},
1183 .outputs = {2},
1184 }
1185 };
1186
1187 const std::vector<uint32_t> inputIndexes = {0, 1};
1188 const std::vector<uint32_t> outputIndexes = {2};
1189 std::vector<uint8_t> operandValues = {};
1190 const std::vector<hidl_memory> pools = {};
1191
1192 return {
1193 .operands = operands,
1194 .operations = operations,
1195 .inputIndexes = inputIndexes,
1196 .outputIndexes = outputIndexes,
1197 .operandValues = operandValues,
1198 .pools = pools,
1199 };
1200 }
1201
is_ignored_dynamic_output_shape_4(int i)1202 inline bool is_ignored_dynamic_output_shape_4(int i) {
1203 static std::set<int> ignore = {};
1204 return ignore.find(i) != ignore.end();
1205 }
1206
1207 // Create the model
createTestModel_5()1208 Model createTestModel_5() {
1209 const std::vector<Operand> operands = {
1210 {
1211 .type = OperandType::TENSOR_QUANT8_ASYMM,
1212 .dimensions = {1},
1213 .numberOfConsumers = 1,
1214 .scale = 1.64771f,
1215 .zeroPoint = 31,
1216 .lifetime = OperandLifeTime::MODEL_INPUT,
1217 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1218 },
1219 {
1220 .type = OperandType::TENSOR_QUANT8_ASYMM,
1221 .dimensions = {1},
1222 .numberOfConsumers = 1,
1223 .scale = 1.49725f,
1224 .zeroPoint = 240,
1225 .lifetime = OperandLifeTime::MODEL_INPUT,
1226 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1227 },
1228 {
1229 .type = OperandType::TENSOR_BOOL8,
1230 .dimensions = {1},
1231 .numberOfConsumers = 0,
1232 .scale = 0.0f,
1233 .zeroPoint = 0,
1234 .lifetime = OperandLifeTime::MODEL_OUTPUT,
1235 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1236 }
1237 };
1238
1239 const std::vector<Operation> operations = {
1240 {
1241 .type = OperationType::NOT_EQUAL,
1242 .inputs = {0, 1},
1243 .outputs = {2},
1244 }
1245 };
1246
1247 const std::vector<uint32_t> inputIndexes = {0, 1};
1248 const std::vector<uint32_t> outputIndexes = {2};
1249 std::vector<uint8_t> operandValues = {};
1250 const std::vector<hidl_memory> pools = {};
1251
1252 return {
1253 .operands = operands,
1254 .operations = operations,
1255 .inputIndexes = inputIndexes,
1256 .outputIndexes = outputIndexes,
1257 .operandValues = operandValues,
1258 .pools = pools,
1259 };
1260 }
1261
is_ignored_5(int i)1262 inline bool is_ignored_5(int i) {
1263 static std::set<int> ignore = {};
1264 return ignore.find(i) != ignore.end();
1265 }
1266
1267 // Create the model
createTestModel_dynamic_output_shape_5()1268 Model createTestModel_dynamic_output_shape_5() {
1269 const std::vector<Operand> operands = {
1270 {
1271 .type = OperandType::TENSOR_QUANT8_ASYMM,
1272 .dimensions = {1},
1273 .numberOfConsumers = 1,
1274 .scale = 1.64771f,
1275 .zeroPoint = 31,
1276 .lifetime = OperandLifeTime::MODEL_INPUT,
1277 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1278 },
1279 {
1280 .type = OperandType::TENSOR_QUANT8_ASYMM,
1281 .dimensions = {1},
1282 .numberOfConsumers = 1,
1283 .scale = 1.49725f,
1284 .zeroPoint = 240,
1285 .lifetime = OperandLifeTime::MODEL_INPUT,
1286 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1287 },
1288 {
1289 .type = OperandType::TENSOR_BOOL8,
1290 .dimensions = {0},
1291 .numberOfConsumers = 0,
1292 .scale = 0.0f,
1293 .zeroPoint = 0,
1294 .lifetime = OperandLifeTime::MODEL_OUTPUT,
1295 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1296 }
1297 };
1298
1299 const std::vector<Operation> operations = {
1300 {
1301 .type = OperationType::NOT_EQUAL,
1302 .inputs = {0, 1},
1303 .outputs = {2},
1304 }
1305 };
1306
1307 const std::vector<uint32_t> inputIndexes = {0, 1};
1308 const std::vector<uint32_t> outputIndexes = {2};
1309 std::vector<uint8_t> operandValues = {};
1310 const std::vector<hidl_memory> pools = {};
1311
1312 return {
1313 .operands = operands,
1314 .operations = operations,
1315 .inputIndexes = inputIndexes,
1316 .outputIndexes = outputIndexes,
1317 .operandValues = operandValues,
1318 .pools = pools,
1319 };
1320 }
1321
is_ignored_dynamic_output_shape_5(int i)1322 inline bool is_ignored_dynamic_output_shape_5(int i) {
1323 static std::set<int> ignore = {};
1324 return ignore.find(i) != ignore.end();
1325 }
1326
1327 // Create the model
createTestModel_6()1328 Model createTestModel_6() {
1329 const std::vector<Operand> operands = {
1330 {
1331 .type = OperandType::TENSOR_QUANT8_ASYMM,
1332 .dimensions = {1},
1333 .numberOfConsumers = 1,
1334 .scale = 1.49725f,
1335 .zeroPoint = 240,
1336 .lifetime = OperandLifeTime::MODEL_INPUT,
1337 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1338 },
1339 {
1340 .type = OperandType::TENSOR_QUANT8_ASYMM,
1341 .dimensions = {1},
1342 .numberOfConsumers = 1,
1343 .scale = 1.64771f,
1344 .zeroPoint = 31,
1345 .lifetime = OperandLifeTime::MODEL_INPUT,
1346 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1347 },
1348 {
1349 .type = OperandType::TENSOR_BOOL8,
1350 .dimensions = {1},
1351 .numberOfConsumers = 0,
1352 .scale = 0.0f,
1353 .zeroPoint = 0,
1354 .lifetime = OperandLifeTime::MODEL_OUTPUT,
1355 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1356 }
1357 };
1358
1359 const std::vector<Operation> operations = {
1360 {
1361 .type = OperationType::NOT_EQUAL,
1362 .inputs = {0, 1},
1363 .outputs = {2},
1364 }
1365 };
1366
1367 const std::vector<uint32_t> inputIndexes = {0, 1};
1368 const std::vector<uint32_t> outputIndexes = {2};
1369 std::vector<uint8_t> operandValues = {};
1370 const std::vector<hidl_memory> pools = {};
1371
1372 return {
1373 .operands = operands,
1374 .operations = operations,
1375 .inputIndexes = inputIndexes,
1376 .outputIndexes = outputIndexes,
1377 .operandValues = operandValues,
1378 .pools = pools,
1379 };
1380 }
1381
is_ignored_6(int i)1382 inline bool is_ignored_6(int i) {
1383 static std::set<int> ignore = {};
1384 return ignore.find(i) != ignore.end();
1385 }
1386
1387 // Create the model
createTestModel_dynamic_output_shape_6()1388 Model createTestModel_dynamic_output_shape_6() {
1389 const std::vector<Operand> operands = {
1390 {
1391 .type = OperandType::TENSOR_QUANT8_ASYMM,
1392 .dimensions = {1},
1393 .numberOfConsumers = 1,
1394 .scale = 1.49725f,
1395 .zeroPoint = 240,
1396 .lifetime = OperandLifeTime::MODEL_INPUT,
1397 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1398 },
1399 {
1400 .type = OperandType::TENSOR_QUANT8_ASYMM,
1401 .dimensions = {1},
1402 .numberOfConsumers = 1,
1403 .scale = 1.64771f,
1404 .zeroPoint = 31,
1405 .lifetime = OperandLifeTime::MODEL_INPUT,
1406 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1407 },
1408 {
1409 .type = OperandType::TENSOR_BOOL8,
1410 .dimensions = {0},
1411 .numberOfConsumers = 0,
1412 .scale = 0.0f,
1413 .zeroPoint = 0,
1414 .lifetime = OperandLifeTime::MODEL_OUTPUT,
1415 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1416 }
1417 };
1418
1419 const std::vector<Operation> operations = {
1420 {
1421 .type = OperationType::NOT_EQUAL,
1422 .inputs = {0, 1},
1423 .outputs = {2},
1424 }
1425 };
1426
1427 const std::vector<uint32_t> inputIndexes = {0, 1};
1428 const std::vector<uint32_t> outputIndexes = {2};
1429 std::vector<uint8_t> operandValues = {};
1430 const std::vector<hidl_memory> pools = {};
1431
1432 return {
1433 .operands = operands,
1434 .operations = operations,
1435 .inputIndexes = inputIndexes,
1436 .outputIndexes = outputIndexes,
1437 .operandValues = operandValues,
1438 .pools = pools,
1439 };
1440 }
1441
is_ignored_dynamic_output_shape_6(int i)1442 inline bool is_ignored_dynamic_output_shape_6(int i) {
1443 static std::set<int> ignore = {};
1444 return ignore.find(i) != ignore.end();
1445 }
1446
1447 // Create the model
createTestModel_7()1448 Model createTestModel_7() {
1449 const std::vector<Operand> operands = {
1450 {
1451 .type = OperandType::TENSOR_BOOL8,
1452 .dimensions = {4},
1453 .numberOfConsumers = 1,
1454 .scale = 0.0f,
1455 .zeroPoint = 0,
1456 .lifetime = OperandLifeTime::MODEL_INPUT,
1457 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1458 },
1459 {
1460 .type = OperandType::TENSOR_BOOL8,
1461 .dimensions = {4},
1462 .numberOfConsumers = 1,
1463 .scale = 0.0f,
1464 .zeroPoint = 0,
1465 .lifetime = OperandLifeTime::MODEL_INPUT,
1466 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1467 },
1468 {
1469 .type = OperandType::TENSOR_BOOL8,
1470 .dimensions = {4},
1471 .numberOfConsumers = 0,
1472 .scale = 0.0f,
1473 .zeroPoint = 0,
1474 .lifetime = OperandLifeTime::MODEL_OUTPUT,
1475 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1476 }
1477 };
1478
1479 const std::vector<Operation> operations = {
1480 {
1481 .type = OperationType::NOT_EQUAL,
1482 .inputs = {0, 1},
1483 .outputs = {2},
1484 }
1485 };
1486
1487 const std::vector<uint32_t> inputIndexes = {0, 1};
1488 const std::vector<uint32_t> outputIndexes = {2};
1489 std::vector<uint8_t> operandValues = {};
1490 const std::vector<hidl_memory> pools = {};
1491
1492 return {
1493 .operands = operands,
1494 .operations = operations,
1495 .inputIndexes = inputIndexes,
1496 .outputIndexes = outputIndexes,
1497 .operandValues = operandValues,
1498 .pools = pools,
1499 };
1500 }
1501
is_ignored_7(int i)1502 inline bool is_ignored_7(int i) {
1503 static std::set<int> ignore = {};
1504 return ignore.find(i) != ignore.end();
1505 }
1506
1507 // Create the model
createTestModel_dynamic_output_shape_7()1508 Model createTestModel_dynamic_output_shape_7() {
1509 const std::vector<Operand> operands = {
1510 {
1511 .type = OperandType::TENSOR_BOOL8,
1512 .dimensions = {4},
1513 .numberOfConsumers = 1,
1514 .scale = 0.0f,
1515 .zeroPoint = 0,
1516 .lifetime = OperandLifeTime::MODEL_INPUT,
1517 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1518 },
1519 {
1520 .type = OperandType::TENSOR_BOOL8,
1521 .dimensions = {4},
1522 .numberOfConsumers = 1,
1523 .scale = 0.0f,
1524 .zeroPoint = 0,
1525 .lifetime = OperandLifeTime::MODEL_INPUT,
1526 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1527 },
1528 {
1529 .type = OperandType::TENSOR_BOOL8,
1530 .dimensions = {0},
1531 .numberOfConsumers = 0,
1532 .scale = 0.0f,
1533 .zeroPoint = 0,
1534 .lifetime = OperandLifeTime::MODEL_OUTPUT,
1535 .location = {.poolIndex = 0, .offset = 0, .length = 0},
1536 }
1537 };
1538
1539 const std::vector<Operation> operations = {
1540 {
1541 .type = OperationType::NOT_EQUAL,
1542 .inputs = {0, 1},
1543 .outputs = {2},
1544 }
1545 };
1546
1547 const std::vector<uint32_t> inputIndexes = {0, 1};
1548 const std::vector<uint32_t> outputIndexes = {2};
1549 std::vector<uint8_t> operandValues = {};
1550 const std::vector<hidl_memory> pools = {};
1551
1552 return {
1553 .operands = operands,
1554 .operations = operations,
1555 .inputIndexes = inputIndexes,
1556 .outputIndexes = outputIndexes,
1557 .operandValues = operandValues,
1558 .pools = pools,
1559 };
1560 }
1561
is_ignored_dynamic_output_shape_7(int i)1562 inline bool is_ignored_dynamic_output_shape_7(int i) {
1563 static std::set<int> ignore = {};
1564 return ignore.find(i) != ignore.end();
1565 }
1566
1567