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