1 // Generated from pack.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::pack {
8
get_test_model_FLOAT32_unary_axis0()9 const TestModel& get_test_model_FLOAT32_unary_axis0() {
10 static TestModel model = {
11 .main = {
12 .operands = {{ // axis
13 .type = TestOperandType::INT32,
14 .dimensions = {},
15 .numberOfConsumers = 1,
16 .scale = 0.0f,
17 .zeroPoint = 0,
18 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
19 .channelQuant = {},
20 .isIgnored = false,
21 .data = TestBuffer::createFromVector<int32_t>({0})
22 }, { // in0
23 .type = TestOperandType::TENSOR_FLOAT32,
24 .dimensions = {2},
25 .numberOfConsumers = 1,
26 .scale = 0.0f,
27 .zeroPoint = 0,
28 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
29 .channelQuant = {},
30 .isIgnored = false,
31 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f})
32 }, { // out
33 .type = TestOperandType::TENSOR_FLOAT32,
34 .dimensions = {1, 2},
35 .numberOfConsumers = 0,
36 .scale = 0.0f,
37 .zeroPoint = 0,
38 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
39 .channelQuant = {},
40 .isIgnored = false,
41 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f})
42 }},
43 .operations = {{
44 .type = TestOperationType::PACK,
45 .inputs = {0, 1},
46 .outputs = {2}
47 }},
48 .inputIndexes = {1},
49 .outputIndexes = {2}
50 },
51 .referenced = {},
52 .isRelaxed = false,
53 .expectedMultinomialDistributionTolerance = 0,
54 .expectFailure = false,
55 .minSupportedVersion = TestHalVersion::AIDL_V2
56 };
57 return model;
58 }
59
60 const auto dummy_test_model_FLOAT32_unary_axis0 = TestModelManager::get().add("pack_FLOAT32_unary_axis0", get_test_model_FLOAT32_unary_axis0());
61
62 } // namespace generated_tests::pack
63
64 namespace generated_tests::pack {
65
get_test_model_FLOAT32_unary_axis0_all_inputs_as_internal()66 const TestModel& get_test_model_FLOAT32_unary_axis0_all_inputs_as_internal() {
67 static TestModel model = {
68 .main = {
69 .operands = {{ // axis
70 .type = TestOperandType::INT32,
71 .dimensions = {},
72 .numberOfConsumers = 1,
73 .scale = 0.0f,
74 .zeroPoint = 0,
75 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
76 .channelQuant = {},
77 .isIgnored = false,
78 .data = TestBuffer::createFromVector<int32_t>({0})
79 }, { // in0
80 .type = TestOperandType::TENSOR_FLOAT32,
81 .dimensions = {2},
82 .numberOfConsumers = 1,
83 .scale = 0.0f,
84 .zeroPoint = 0,
85 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
86 .channelQuant = {},
87 .isIgnored = false,
88 .data = TestBuffer::createFromVector<float>({})
89 }, { // out
90 .type = TestOperandType::TENSOR_FLOAT32,
91 .dimensions = {1, 2},
92 .numberOfConsumers = 0,
93 .scale = 0.0f,
94 .zeroPoint = 0,
95 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
96 .channelQuant = {},
97 .isIgnored = false,
98 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f})
99 }, { // in0_new
100 .type = TestOperandType::TENSOR_FLOAT32,
101 .dimensions = {2},
102 .numberOfConsumers = 1,
103 .scale = 0.0f,
104 .zeroPoint = 0,
105 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
106 .channelQuant = {},
107 .isIgnored = false,
108 .data = TestBuffer::createFromVector<float>({3.0f, 4.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 }},
130 .operations = {{
131 .type = TestOperationType::ADD,
132 .inputs = {3, 4, 5},
133 .outputs = {1}
134 }, {
135 .type = TestOperationType::PACK,
136 .inputs = {0, 1},
137 .outputs = {2}
138 }},
139 .inputIndexes = {3},
140 .outputIndexes = {2}
141 },
142 .referenced = {},
143 .isRelaxed = false,
144 .expectedMultinomialDistributionTolerance = 0,
145 .expectFailure = false,
146 .minSupportedVersion = TestHalVersion::AIDL_V2
147 };
148 return model;
149 }
150
151 const auto dummy_test_model_FLOAT32_unary_axis0_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_unary_axis0_all_inputs_as_internal", get_test_model_FLOAT32_unary_axis0_all_inputs_as_internal());
152
153 } // namespace generated_tests::pack
154
155 namespace generated_tests::pack {
156
get_test_model_FLOAT32_unary_axis0_float16()157 const TestModel& get_test_model_FLOAT32_unary_axis0_float16() {
158 static TestModel model = {
159 .main = {
160 .operands = {{ // axis
161 .type = TestOperandType::INT32,
162 .dimensions = {},
163 .numberOfConsumers = 1,
164 .scale = 0.0f,
165 .zeroPoint = 0,
166 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
167 .channelQuant = {},
168 .isIgnored = false,
169 .data = TestBuffer::createFromVector<int32_t>({0})
170 }, { // in0
171 .type = TestOperandType::TENSOR_FLOAT16,
172 .dimensions = {2},
173 .numberOfConsumers = 1,
174 .scale = 0.0f,
175 .zeroPoint = 0,
176 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
177 .channelQuant = {},
178 .isIgnored = false,
179 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f})
180 }, { // out
181 .type = TestOperandType::TENSOR_FLOAT16,
182 .dimensions = {1, 2},
183 .numberOfConsumers = 0,
184 .scale = 0.0f,
185 .zeroPoint = 0,
186 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
187 .channelQuant = {},
188 .isIgnored = false,
189 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f})
190 }},
191 .operations = {{
192 .type = TestOperationType::PACK,
193 .inputs = {0, 1},
194 .outputs = {2}
195 }},
196 .inputIndexes = {1},
197 .outputIndexes = {2}
198 },
199 .referenced = {},
200 .isRelaxed = false,
201 .expectedMultinomialDistributionTolerance = 0,
202 .expectFailure = false,
203 .minSupportedVersion = TestHalVersion::AIDL_V2
204 };
205 return model;
206 }
207
208 const auto dummy_test_model_FLOAT32_unary_axis0_float16 = TestModelManager::get().add("pack_FLOAT32_unary_axis0_float16", get_test_model_FLOAT32_unary_axis0_float16());
209
210 } // namespace generated_tests::pack
211
212 namespace generated_tests::pack {
213
get_test_model_FLOAT32_unary_axis0_float16_all_inputs_as_internal()214 const TestModel& get_test_model_FLOAT32_unary_axis0_float16_all_inputs_as_internal() {
215 static TestModel model = {
216 .main = {
217 .operands = {{ // axis
218 .type = TestOperandType::INT32,
219 .dimensions = {},
220 .numberOfConsumers = 1,
221 .scale = 0.0f,
222 .zeroPoint = 0,
223 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
224 .channelQuant = {},
225 .isIgnored = false,
226 .data = TestBuffer::createFromVector<int32_t>({0})
227 }, { // in0
228 .type = TestOperandType::TENSOR_FLOAT16,
229 .dimensions = {2},
230 .numberOfConsumers = 1,
231 .scale = 0.0f,
232 .zeroPoint = 0,
233 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
234 .channelQuant = {},
235 .isIgnored = false,
236 .data = TestBuffer::createFromVector<_Float16>({})
237 }, { // out
238 .type = TestOperandType::TENSOR_FLOAT16,
239 .dimensions = {1, 2},
240 .numberOfConsumers = 0,
241 .scale = 0.0f,
242 .zeroPoint = 0,
243 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
244 .channelQuant = {},
245 .isIgnored = false,
246 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f})
247 }, { // in0_new
248 .type = TestOperandType::TENSOR_FLOAT16,
249 .dimensions = {2},
250 .numberOfConsumers = 1,
251 .scale = 0.0f,
252 .zeroPoint = 0,
253 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
254 .channelQuant = {},
255 .isIgnored = false,
256 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f})
257 }, { // placeholder1
258 .type = TestOperandType::TENSOR_FLOAT16,
259 .dimensions = {1},
260 .numberOfConsumers = 1,
261 .scale = 0.0f,
262 .zeroPoint = 0,
263 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
264 .channelQuant = {},
265 .isIgnored = false,
266 .data = TestBuffer::createFromVector<_Float16>({0.0f})
267 }, { // param1
268 .type = TestOperandType::INT32,
269 .dimensions = {},
270 .numberOfConsumers = 1,
271 .scale = 0.0f,
272 .zeroPoint = 0,
273 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
274 .channelQuant = {},
275 .isIgnored = false,
276 .data = TestBuffer::createFromVector<int32_t>({0})
277 }},
278 .operations = {{
279 .type = TestOperationType::ADD,
280 .inputs = {3, 4, 5},
281 .outputs = {1}
282 }, {
283 .type = TestOperationType::PACK,
284 .inputs = {0, 1},
285 .outputs = {2}
286 }},
287 .inputIndexes = {3},
288 .outputIndexes = {2}
289 },
290 .referenced = {},
291 .isRelaxed = false,
292 .expectedMultinomialDistributionTolerance = 0,
293 .expectFailure = false,
294 .minSupportedVersion = TestHalVersion::AIDL_V2
295 };
296 return model;
297 }
298
299 const auto dummy_test_model_FLOAT32_unary_axis0_float16_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_unary_axis0_float16_all_inputs_as_internal", get_test_model_FLOAT32_unary_axis0_float16_all_inputs_as_internal());
300
301 } // namespace generated_tests::pack
302
303 namespace generated_tests::pack {
304
get_test_model_FLOAT32_unary_axis0_quant8_asymm()305 const TestModel& get_test_model_FLOAT32_unary_axis0_quant8_asymm() {
306 static TestModel model = {
307 .main = {
308 .operands = {{ // axis
309 .type = TestOperandType::INT32,
310 .dimensions = {},
311 .numberOfConsumers = 1,
312 .scale = 0.0f,
313 .zeroPoint = 0,
314 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
315 .channelQuant = {},
316 .isIgnored = false,
317 .data = TestBuffer::createFromVector<int32_t>({0})
318 }, { // in0
319 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
320 .dimensions = {2},
321 .numberOfConsumers = 1,
322 .scale = 0.5f,
323 .zeroPoint = 4,
324 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
325 .channelQuant = {},
326 .isIgnored = false,
327 .data = TestBuffer::createFromVector<uint8_t>({10, 12})
328 }, { // out
329 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
330 .dimensions = {1, 2},
331 .numberOfConsumers = 0,
332 .scale = 0.5f,
333 .zeroPoint = 4,
334 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
335 .channelQuant = {},
336 .isIgnored = false,
337 .data = TestBuffer::createFromVector<uint8_t>({10, 12})
338 }},
339 .operations = {{
340 .type = TestOperationType::PACK,
341 .inputs = {0, 1},
342 .outputs = {2}
343 }},
344 .inputIndexes = {1},
345 .outputIndexes = {2}
346 },
347 .referenced = {},
348 .isRelaxed = false,
349 .expectedMultinomialDistributionTolerance = 0,
350 .expectFailure = false,
351 .minSupportedVersion = TestHalVersion::AIDL_V2
352 };
353 return model;
354 }
355
356 const auto dummy_test_model_FLOAT32_unary_axis0_quant8_asymm = TestModelManager::get().add("pack_FLOAT32_unary_axis0_quant8_asymm", get_test_model_FLOAT32_unary_axis0_quant8_asymm());
357
358 } // namespace generated_tests::pack
359
360 namespace generated_tests::pack {
361
get_test_model_FLOAT32_unary_axis0_quant8_asymm_all_inputs_as_internal()362 const TestModel& get_test_model_FLOAT32_unary_axis0_quant8_asymm_all_inputs_as_internal() {
363 static TestModel model = {
364 .main = {
365 .operands = {{ // axis
366 .type = TestOperandType::INT32,
367 .dimensions = {},
368 .numberOfConsumers = 1,
369 .scale = 0.0f,
370 .zeroPoint = 0,
371 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
372 .channelQuant = {},
373 .isIgnored = false,
374 .data = TestBuffer::createFromVector<int32_t>({0})
375 }, { // in0
376 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
377 .dimensions = {2},
378 .numberOfConsumers = 1,
379 .scale = 0.5f,
380 .zeroPoint = 4,
381 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
382 .channelQuant = {},
383 .isIgnored = false,
384 .data = TestBuffer::createFromVector<uint8_t>({})
385 }, { // out
386 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
387 .dimensions = {1, 2},
388 .numberOfConsumers = 0,
389 .scale = 0.5f,
390 .zeroPoint = 4,
391 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
392 .channelQuant = {},
393 .isIgnored = false,
394 .data = TestBuffer::createFromVector<uint8_t>({10, 12})
395 }, { // in0_new
396 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
397 .dimensions = {2},
398 .numberOfConsumers = 1,
399 .scale = 0.5f,
400 .zeroPoint = 4,
401 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
402 .channelQuant = {},
403 .isIgnored = false,
404 .data = TestBuffer::createFromVector<uint8_t>({10, 12})
405 }, { // placeholder2
406 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
407 .dimensions = {1},
408 .numberOfConsumers = 1,
409 .scale = 0.5f,
410 .zeroPoint = 4,
411 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
412 .channelQuant = {},
413 .isIgnored = false,
414 .data = TestBuffer::createFromVector<uint8_t>({4})
415 }, { // param2
416 .type = TestOperandType::INT32,
417 .dimensions = {},
418 .numberOfConsumers = 1,
419 .scale = 0.0f,
420 .zeroPoint = 0,
421 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
422 .channelQuant = {},
423 .isIgnored = false,
424 .data = TestBuffer::createFromVector<int32_t>({0})
425 }},
426 .operations = {{
427 .type = TestOperationType::ADD,
428 .inputs = {3, 4, 5},
429 .outputs = {1}
430 }, {
431 .type = TestOperationType::PACK,
432 .inputs = {0, 1},
433 .outputs = {2}
434 }},
435 .inputIndexes = {3},
436 .outputIndexes = {2}
437 },
438 .referenced = {},
439 .isRelaxed = false,
440 .expectedMultinomialDistributionTolerance = 0,
441 .expectFailure = false,
442 .minSupportedVersion = TestHalVersion::AIDL_V2
443 };
444 return model;
445 }
446
447 const auto dummy_test_model_FLOAT32_unary_axis0_quant8_asymm_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_unary_axis0_quant8_asymm_all_inputs_as_internal", get_test_model_FLOAT32_unary_axis0_quant8_asymm_all_inputs_as_internal());
448
449 } // namespace generated_tests::pack
450
451 namespace generated_tests::pack {
452
get_test_model_FLOAT32_unary_axis0_quant8_asymm_signed()453 const TestModel& get_test_model_FLOAT32_unary_axis0_quant8_asymm_signed() {
454 static TestModel model = {
455 .main = {
456 .operands = {{ // axis
457 .type = TestOperandType::INT32,
458 .dimensions = {},
459 .numberOfConsumers = 1,
460 .scale = 0.0f,
461 .zeroPoint = 0,
462 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
463 .channelQuant = {},
464 .isIgnored = false,
465 .data = TestBuffer::createFromVector<int32_t>({0})
466 }, { // in0
467 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
468 .dimensions = {2},
469 .numberOfConsumers = 1,
470 .scale = 0.25f,
471 .zeroPoint = -9,
472 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
473 .channelQuant = {},
474 .isIgnored = false,
475 .data = TestBuffer::createFromVector<int8_t>({3, 7})
476 }, { // out
477 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
478 .dimensions = {1, 2},
479 .numberOfConsumers = 0,
480 .scale = 0.25f,
481 .zeroPoint = -9,
482 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
483 .channelQuant = {},
484 .isIgnored = false,
485 .data = TestBuffer::createFromVector<int8_t>({3, 7})
486 }},
487 .operations = {{
488 .type = TestOperationType::PACK,
489 .inputs = {0, 1},
490 .outputs = {2}
491 }},
492 .inputIndexes = {1},
493 .outputIndexes = {2}
494 },
495 .referenced = {},
496 .isRelaxed = false,
497 .expectedMultinomialDistributionTolerance = 0,
498 .expectFailure = false,
499 .minSupportedVersion = TestHalVersion::AIDL_V2
500 };
501 return model;
502 }
503
504 const auto dummy_test_model_FLOAT32_unary_axis0_quant8_asymm_signed = TestModelManager::get().add("pack_FLOAT32_unary_axis0_quant8_asymm_signed", get_test_model_FLOAT32_unary_axis0_quant8_asymm_signed());
505
506 } // namespace generated_tests::pack
507
508 namespace generated_tests::pack {
509
get_test_model_FLOAT32_unary_axis0_quant8_asymm_signed_all_inputs_as_internal()510 const TestModel& get_test_model_FLOAT32_unary_axis0_quant8_asymm_signed_all_inputs_as_internal() {
511 static TestModel model = {
512 .main = {
513 .operands = {{ // axis
514 .type = TestOperandType::INT32,
515 .dimensions = {},
516 .numberOfConsumers = 1,
517 .scale = 0.0f,
518 .zeroPoint = 0,
519 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
520 .channelQuant = {},
521 .isIgnored = false,
522 .data = TestBuffer::createFromVector<int32_t>({0})
523 }, { // in0
524 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
525 .dimensions = {2},
526 .numberOfConsumers = 1,
527 .scale = 0.25f,
528 .zeroPoint = -9,
529 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
530 .channelQuant = {},
531 .isIgnored = false,
532 .data = TestBuffer::createFromVector<int8_t>({})
533 }, { // out
534 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
535 .dimensions = {1, 2},
536 .numberOfConsumers = 0,
537 .scale = 0.25f,
538 .zeroPoint = -9,
539 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
540 .channelQuant = {},
541 .isIgnored = false,
542 .data = TestBuffer::createFromVector<int8_t>({3, 7})
543 }, { // in0_new
544 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
545 .dimensions = {2},
546 .numberOfConsumers = 1,
547 .scale = 0.25f,
548 .zeroPoint = -9,
549 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
550 .channelQuant = {},
551 .isIgnored = false,
552 .data = TestBuffer::createFromVector<int8_t>({3, 7})
553 }, { // placeholder3
554 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
555 .dimensions = {1},
556 .numberOfConsumers = 1,
557 .scale = 0.25f,
558 .zeroPoint = -9,
559 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
560 .channelQuant = {},
561 .isIgnored = false,
562 .data = TestBuffer::createFromVector<int8_t>({-9})
563 }, { // param3
564 .type = TestOperandType::INT32,
565 .dimensions = {},
566 .numberOfConsumers = 1,
567 .scale = 0.0f,
568 .zeroPoint = 0,
569 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
570 .channelQuant = {},
571 .isIgnored = false,
572 .data = TestBuffer::createFromVector<int32_t>({0})
573 }},
574 .operations = {{
575 .type = TestOperationType::ADD,
576 .inputs = {3, 4, 5},
577 .outputs = {1}
578 }, {
579 .type = TestOperationType::PACK,
580 .inputs = {0, 1},
581 .outputs = {2}
582 }},
583 .inputIndexes = {3},
584 .outputIndexes = {2}
585 },
586 .referenced = {},
587 .isRelaxed = false,
588 .expectedMultinomialDistributionTolerance = 0,
589 .expectFailure = false,
590 .minSupportedVersion = TestHalVersion::AIDL_V2
591 };
592 return model;
593 }
594
595 const auto dummy_test_model_FLOAT32_unary_axis0_quant8_asymm_signed_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_unary_axis0_quant8_asymm_signed_all_inputs_as_internal", get_test_model_FLOAT32_unary_axis0_quant8_asymm_signed_all_inputs_as_internal());
596
597 } // namespace generated_tests::pack
598
599 namespace generated_tests::pack {
600
get_test_model_FLOAT32_unary_axis0_int32()601 const TestModel& get_test_model_FLOAT32_unary_axis0_int32() {
602 static TestModel model = {
603 .main = {
604 .operands = {{ // axis
605 .type = TestOperandType::INT32,
606 .dimensions = {},
607 .numberOfConsumers = 1,
608 .scale = 0.0f,
609 .zeroPoint = 0,
610 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
611 .channelQuant = {},
612 .isIgnored = false,
613 .data = TestBuffer::createFromVector<int32_t>({0})
614 }, { // in0
615 .type = TestOperandType::TENSOR_INT32,
616 .dimensions = {2},
617 .numberOfConsumers = 1,
618 .scale = 0.0f,
619 .zeroPoint = 0,
620 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
621 .channelQuant = {},
622 .isIgnored = false,
623 .data = TestBuffer::createFromVector<int32_t>({3, 4})
624 }, { // out
625 .type = TestOperandType::TENSOR_INT32,
626 .dimensions = {1, 2},
627 .numberOfConsumers = 0,
628 .scale = 0.0f,
629 .zeroPoint = 0,
630 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
631 .channelQuant = {},
632 .isIgnored = false,
633 .data = TestBuffer::createFromVector<int32_t>({3, 4})
634 }},
635 .operations = {{
636 .type = TestOperationType::PACK,
637 .inputs = {0, 1},
638 .outputs = {2}
639 }},
640 .inputIndexes = {1},
641 .outputIndexes = {2}
642 },
643 .referenced = {},
644 .isRelaxed = false,
645 .expectedMultinomialDistributionTolerance = 0,
646 .expectFailure = false,
647 .minSupportedVersion = TestHalVersion::AIDL_V2
648 };
649 return model;
650 }
651
652 const auto dummy_test_model_FLOAT32_unary_axis0_int32 = TestModelManager::get().add("pack_FLOAT32_unary_axis0_int32", get_test_model_FLOAT32_unary_axis0_int32());
653
654 } // namespace generated_tests::pack
655
656 namespace generated_tests::pack {
657
get_test_model_FLOAT32_unary_axis1()658 const TestModel& get_test_model_FLOAT32_unary_axis1() {
659 static TestModel model = {
660 .main = {
661 .operands = {{ // axis1
662 .type = TestOperandType::INT32,
663 .dimensions = {},
664 .numberOfConsumers = 1,
665 .scale = 0.0f,
666 .zeroPoint = 0,
667 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
668 .channelQuant = {},
669 .isIgnored = false,
670 .data = TestBuffer::createFromVector<int32_t>({1})
671 }, { // in01
672 .type = TestOperandType::TENSOR_FLOAT32,
673 .dimensions = {2},
674 .numberOfConsumers = 1,
675 .scale = 0.0f,
676 .zeroPoint = 0,
677 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
678 .channelQuant = {},
679 .isIgnored = false,
680 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f})
681 }, { // out1
682 .type = TestOperandType::TENSOR_FLOAT32,
683 .dimensions = {2, 1},
684 .numberOfConsumers = 0,
685 .scale = 0.0f,
686 .zeroPoint = 0,
687 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
688 .channelQuant = {},
689 .isIgnored = false,
690 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f})
691 }},
692 .operations = {{
693 .type = TestOperationType::PACK,
694 .inputs = {0, 1},
695 .outputs = {2}
696 }},
697 .inputIndexes = {1},
698 .outputIndexes = {2}
699 },
700 .referenced = {},
701 .isRelaxed = false,
702 .expectedMultinomialDistributionTolerance = 0,
703 .expectFailure = false,
704 .minSupportedVersion = TestHalVersion::AIDL_V2
705 };
706 return model;
707 }
708
709 const auto dummy_test_model_FLOAT32_unary_axis1 = TestModelManager::get().add("pack_FLOAT32_unary_axis1", get_test_model_FLOAT32_unary_axis1());
710
711 } // namespace generated_tests::pack
712
713 namespace generated_tests::pack {
714
get_test_model_FLOAT32_unary_axis1_all_inputs_as_internal()715 const TestModel& get_test_model_FLOAT32_unary_axis1_all_inputs_as_internal() {
716 static TestModel model = {
717 .main = {
718 .operands = {{ // axis1
719 .type = TestOperandType::INT32,
720 .dimensions = {},
721 .numberOfConsumers = 1,
722 .scale = 0.0f,
723 .zeroPoint = 0,
724 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
725 .channelQuant = {},
726 .isIgnored = false,
727 .data = TestBuffer::createFromVector<int32_t>({1})
728 }, { // in01
729 .type = TestOperandType::TENSOR_FLOAT32,
730 .dimensions = {2},
731 .numberOfConsumers = 1,
732 .scale = 0.0f,
733 .zeroPoint = 0,
734 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
735 .channelQuant = {},
736 .isIgnored = false,
737 .data = TestBuffer::createFromVector<float>({})
738 }, { // out1
739 .type = TestOperandType::TENSOR_FLOAT32,
740 .dimensions = {2, 1},
741 .numberOfConsumers = 0,
742 .scale = 0.0f,
743 .zeroPoint = 0,
744 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
745 .channelQuant = {},
746 .isIgnored = false,
747 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f})
748 }, { // in01_new
749 .type = TestOperandType::TENSOR_FLOAT32,
750 .dimensions = {2},
751 .numberOfConsumers = 1,
752 .scale = 0.0f,
753 .zeroPoint = 0,
754 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
755 .channelQuant = {},
756 .isIgnored = false,
757 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f})
758 }, { // placeholder4
759 .type = TestOperandType::TENSOR_FLOAT32,
760 .dimensions = {1},
761 .numberOfConsumers = 1,
762 .scale = 0.0f,
763 .zeroPoint = 0,
764 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
765 .channelQuant = {},
766 .isIgnored = false,
767 .data = TestBuffer::createFromVector<float>({0.0f})
768 }, { // param4
769 .type = TestOperandType::INT32,
770 .dimensions = {},
771 .numberOfConsumers = 1,
772 .scale = 0.0f,
773 .zeroPoint = 0,
774 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
775 .channelQuant = {},
776 .isIgnored = false,
777 .data = TestBuffer::createFromVector<int32_t>({0})
778 }},
779 .operations = {{
780 .type = TestOperationType::ADD,
781 .inputs = {3, 4, 5},
782 .outputs = {1}
783 }, {
784 .type = TestOperationType::PACK,
785 .inputs = {0, 1},
786 .outputs = {2}
787 }},
788 .inputIndexes = {3},
789 .outputIndexes = {2}
790 },
791 .referenced = {},
792 .isRelaxed = false,
793 .expectedMultinomialDistributionTolerance = 0,
794 .expectFailure = false,
795 .minSupportedVersion = TestHalVersion::AIDL_V2
796 };
797 return model;
798 }
799
800 const auto dummy_test_model_FLOAT32_unary_axis1_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_unary_axis1_all_inputs_as_internal", get_test_model_FLOAT32_unary_axis1_all_inputs_as_internal());
801
802 } // namespace generated_tests::pack
803
804 namespace generated_tests::pack {
805
get_test_model_FLOAT32_unary_axis1_float16()806 const TestModel& get_test_model_FLOAT32_unary_axis1_float16() {
807 static TestModel model = {
808 .main = {
809 .operands = {{ // axis1
810 .type = TestOperandType::INT32,
811 .dimensions = {},
812 .numberOfConsumers = 1,
813 .scale = 0.0f,
814 .zeroPoint = 0,
815 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
816 .channelQuant = {},
817 .isIgnored = false,
818 .data = TestBuffer::createFromVector<int32_t>({1})
819 }, { // in01
820 .type = TestOperandType::TENSOR_FLOAT16,
821 .dimensions = {2},
822 .numberOfConsumers = 1,
823 .scale = 0.0f,
824 .zeroPoint = 0,
825 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
826 .channelQuant = {},
827 .isIgnored = false,
828 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f})
829 }, { // out1
830 .type = TestOperandType::TENSOR_FLOAT16,
831 .dimensions = {2, 1},
832 .numberOfConsumers = 0,
833 .scale = 0.0f,
834 .zeroPoint = 0,
835 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
836 .channelQuant = {},
837 .isIgnored = false,
838 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f})
839 }},
840 .operations = {{
841 .type = TestOperationType::PACK,
842 .inputs = {0, 1},
843 .outputs = {2}
844 }},
845 .inputIndexes = {1},
846 .outputIndexes = {2}
847 },
848 .referenced = {},
849 .isRelaxed = false,
850 .expectedMultinomialDistributionTolerance = 0,
851 .expectFailure = false,
852 .minSupportedVersion = TestHalVersion::AIDL_V2
853 };
854 return model;
855 }
856
857 const auto dummy_test_model_FLOAT32_unary_axis1_float16 = TestModelManager::get().add("pack_FLOAT32_unary_axis1_float16", get_test_model_FLOAT32_unary_axis1_float16());
858
859 } // namespace generated_tests::pack
860
861 namespace generated_tests::pack {
862
get_test_model_FLOAT32_unary_axis1_float16_all_inputs_as_internal()863 const TestModel& get_test_model_FLOAT32_unary_axis1_float16_all_inputs_as_internal() {
864 static TestModel model = {
865 .main = {
866 .operands = {{ // axis1
867 .type = TestOperandType::INT32,
868 .dimensions = {},
869 .numberOfConsumers = 1,
870 .scale = 0.0f,
871 .zeroPoint = 0,
872 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
873 .channelQuant = {},
874 .isIgnored = false,
875 .data = TestBuffer::createFromVector<int32_t>({1})
876 }, { // in01
877 .type = TestOperandType::TENSOR_FLOAT16,
878 .dimensions = {2},
879 .numberOfConsumers = 1,
880 .scale = 0.0f,
881 .zeroPoint = 0,
882 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
883 .channelQuant = {},
884 .isIgnored = false,
885 .data = TestBuffer::createFromVector<_Float16>({})
886 }, { // out1
887 .type = TestOperandType::TENSOR_FLOAT16,
888 .dimensions = {2, 1},
889 .numberOfConsumers = 0,
890 .scale = 0.0f,
891 .zeroPoint = 0,
892 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
893 .channelQuant = {},
894 .isIgnored = false,
895 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f})
896 }, { // in01_new
897 .type = TestOperandType::TENSOR_FLOAT16,
898 .dimensions = {2},
899 .numberOfConsumers = 1,
900 .scale = 0.0f,
901 .zeroPoint = 0,
902 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
903 .channelQuant = {},
904 .isIgnored = false,
905 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f})
906 }, { // placeholder5
907 .type = TestOperandType::TENSOR_FLOAT16,
908 .dimensions = {1},
909 .numberOfConsumers = 1,
910 .scale = 0.0f,
911 .zeroPoint = 0,
912 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
913 .channelQuant = {},
914 .isIgnored = false,
915 .data = TestBuffer::createFromVector<_Float16>({0.0f})
916 }, { // param5
917 .type = TestOperandType::INT32,
918 .dimensions = {},
919 .numberOfConsumers = 1,
920 .scale = 0.0f,
921 .zeroPoint = 0,
922 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
923 .channelQuant = {},
924 .isIgnored = false,
925 .data = TestBuffer::createFromVector<int32_t>({0})
926 }},
927 .operations = {{
928 .type = TestOperationType::ADD,
929 .inputs = {3, 4, 5},
930 .outputs = {1}
931 }, {
932 .type = TestOperationType::PACK,
933 .inputs = {0, 1},
934 .outputs = {2}
935 }},
936 .inputIndexes = {3},
937 .outputIndexes = {2}
938 },
939 .referenced = {},
940 .isRelaxed = false,
941 .expectedMultinomialDistributionTolerance = 0,
942 .expectFailure = false,
943 .minSupportedVersion = TestHalVersion::AIDL_V2
944 };
945 return model;
946 }
947
948 const auto dummy_test_model_FLOAT32_unary_axis1_float16_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_unary_axis1_float16_all_inputs_as_internal", get_test_model_FLOAT32_unary_axis1_float16_all_inputs_as_internal());
949
950 } // namespace generated_tests::pack
951
952 namespace generated_tests::pack {
953
get_test_model_FLOAT32_unary_axis1_quant8_asymm()954 const TestModel& get_test_model_FLOAT32_unary_axis1_quant8_asymm() {
955 static TestModel model = {
956 .main = {
957 .operands = {{ // axis1
958 .type = TestOperandType::INT32,
959 .dimensions = {},
960 .numberOfConsumers = 1,
961 .scale = 0.0f,
962 .zeroPoint = 0,
963 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
964 .channelQuant = {},
965 .isIgnored = false,
966 .data = TestBuffer::createFromVector<int32_t>({1})
967 }, { // in01
968 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
969 .dimensions = {2},
970 .numberOfConsumers = 1,
971 .scale = 0.5f,
972 .zeroPoint = 4,
973 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
974 .channelQuant = {},
975 .isIgnored = false,
976 .data = TestBuffer::createFromVector<uint8_t>({10, 12})
977 }, { // out1
978 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
979 .dimensions = {2, 1},
980 .numberOfConsumers = 0,
981 .scale = 0.5f,
982 .zeroPoint = 4,
983 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
984 .channelQuant = {},
985 .isIgnored = false,
986 .data = TestBuffer::createFromVector<uint8_t>({10, 12})
987 }},
988 .operations = {{
989 .type = TestOperationType::PACK,
990 .inputs = {0, 1},
991 .outputs = {2}
992 }},
993 .inputIndexes = {1},
994 .outputIndexes = {2}
995 },
996 .referenced = {},
997 .isRelaxed = false,
998 .expectedMultinomialDistributionTolerance = 0,
999 .expectFailure = false,
1000 .minSupportedVersion = TestHalVersion::AIDL_V2
1001 };
1002 return model;
1003 }
1004
1005 const auto dummy_test_model_FLOAT32_unary_axis1_quant8_asymm = TestModelManager::get().add("pack_FLOAT32_unary_axis1_quant8_asymm", get_test_model_FLOAT32_unary_axis1_quant8_asymm());
1006
1007 } // namespace generated_tests::pack
1008
1009 namespace generated_tests::pack {
1010
get_test_model_FLOAT32_unary_axis1_quant8_asymm_all_inputs_as_internal()1011 const TestModel& get_test_model_FLOAT32_unary_axis1_quant8_asymm_all_inputs_as_internal() {
1012 static TestModel model = {
1013 .main = {
1014 .operands = {{ // axis1
1015 .type = TestOperandType::INT32,
1016 .dimensions = {},
1017 .numberOfConsumers = 1,
1018 .scale = 0.0f,
1019 .zeroPoint = 0,
1020 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1021 .channelQuant = {},
1022 .isIgnored = false,
1023 .data = TestBuffer::createFromVector<int32_t>({1})
1024 }, { // in01
1025 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1026 .dimensions = {2},
1027 .numberOfConsumers = 1,
1028 .scale = 0.5f,
1029 .zeroPoint = 4,
1030 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1031 .channelQuant = {},
1032 .isIgnored = false,
1033 .data = TestBuffer::createFromVector<uint8_t>({})
1034 }, { // out1
1035 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1036 .dimensions = {2, 1},
1037 .numberOfConsumers = 0,
1038 .scale = 0.5f,
1039 .zeroPoint = 4,
1040 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1041 .channelQuant = {},
1042 .isIgnored = false,
1043 .data = TestBuffer::createFromVector<uint8_t>({10, 12})
1044 }, { // in01_new
1045 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1046 .dimensions = {2},
1047 .numberOfConsumers = 1,
1048 .scale = 0.5f,
1049 .zeroPoint = 4,
1050 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1051 .channelQuant = {},
1052 .isIgnored = false,
1053 .data = TestBuffer::createFromVector<uint8_t>({10, 12})
1054 }, { // placeholder6
1055 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1056 .dimensions = {1},
1057 .numberOfConsumers = 1,
1058 .scale = 0.5f,
1059 .zeroPoint = 4,
1060 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1061 .channelQuant = {},
1062 .isIgnored = false,
1063 .data = TestBuffer::createFromVector<uint8_t>({4})
1064 }, { // param6
1065 .type = TestOperandType::INT32,
1066 .dimensions = {},
1067 .numberOfConsumers = 1,
1068 .scale = 0.0f,
1069 .zeroPoint = 0,
1070 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1071 .channelQuant = {},
1072 .isIgnored = false,
1073 .data = TestBuffer::createFromVector<int32_t>({0})
1074 }},
1075 .operations = {{
1076 .type = TestOperationType::ADD,
1077 .inputs = {3, 4, 5},
1078 .outputs = {1}
1079 }, {
1080 .type = TestOperationType::PACK,
1081 .inputs = {0, 1},
1082 .outputs = {2}
1083 }},
1084 .inputIndexes = {3},
1085 .outputIndexes = {2}
1086 },
1087 .referenced = {},
1088 .isRelaxed = false,
1089 .expectedMultinomialDistributionTolerance = 0,
1090 .expectFailure = false,
1091 .minSupportedVersion = TestHalVersion::AIDL_V2
1092 };
1093 return model;
1094 }
1095
1096 const auto dummy_test_model_FLOAT32_unary_axis1_quant8_asymm_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_unary_axis1_quant8_asymm_all_inputs_as_internal", get_test_model_FLOAT32_unary_axis1_quant8_asymm_all_inputs_as_internal());
1097
1098 } // namespace generated_tests::pack
1099
1100 namespace generated_tests::pack {
1101
get_test_model_FLOAT32_unary_axis1_quant8_asymm_signed()1102 const TestModel& get_test_model_FLOAT32_unary_axis1_quant8_asymm_signed() {
1103 static TestModel model = {
1104 .main = {
1105 .operands = {{ // axis1
1106 .type = TestOperandType::INT32,
1107 .dimensions = {},
1108 .numberOfConsumers = 1,
1109 .scale = 0.0f,
1110 .zeroPoint = 0,
1111 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1112 .channelQuant = {},
1113 .isIgnored = false,
1114 .data = TestBuffer::createFromVector<int32_t>({1})
1115 }, { // in01
1116 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
1117 .dimensions = {2},
1118 .numberOfConsumers = 1,
1119 .scale = 0.25f,
1120 .zeroPoint = -9,
1121 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1122 .channelQuant = {},
1123 .isIgnored = false,
1124 .data = TestBuffer::createFromVector<int8_t>({3, 7})
1125 }, { // out1
1126 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
1127 .dimensions = {2, 1},
1128 .numberOfConsumers = 0,
1129 .scale = 0.25f,
1130 .zeroPoint = -9,
1131 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1132 .channelQuant = {},
1133 .isIgnored = false,
1134 .data = TestBuffer::createFromVector<int8_t>({3, 7})
1135 }},
1136 .operations = {{
1137 .type = TestOperationType::PACK,
1138 .inputs = {0, 1},
1139 .outputs = {2}
1140 }},
1141 .inputIndexes = {1},
1142 .outputIndexes = {2}
1143 },
1144 .referenced = {},
1145 .isRelaxed = false,
1146 .expectedMultinomialDistributionTolerance = 0,
1147 .expectFailure = false,
1148 .minSupportedVersion = TestHalVersion::AIDL_V2
1149 };
1150 return model;
1151 }
1152
1153 const auto dummy_test_model_FLOAT32_unary_axis1_quant8_asymm_signed = TestModelManager::get().add("pack_FLOAT32_unary_axis1_quant8_asymm_signed", get_test_model_FLOAT32_unary_axis1_quant8_asymm_signed());
1154
1155 } // namespace generated_tests::pack
1156
1157 namespace generated_tests::pack {
1158
get_test_model_FLOAT32_unary_axis1_quant8_asymm_signed_all_inputs_as_internal()1159 const TestModel& get_test_model_FLOAT32_unary_axis1_quant8_asymm_signed_all_inputs_as_internal() {
1160 static TestModel model = {
1161 .main = {
1162 .operands = {{ // axis1
1163 .type = TestOperandType::INT32,
1164 .dimensions = {},
1165 .numberOfConsumers = 1,
1166 .scale = 0.0f,
1167 .zeroPoint = 0,
1168 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1169 .channelQuant = {},
1170 .isIgnored = false,
1171 .data = TestBuffer::createFromVector<int32_t>({1})
1172 }, { // in01
1173 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
1174 .dimensions = {2},
1175 .numberOfConsumers = 1,
1176 .scale = 0.25f,
1177 .zeroPoint = -9,
1178 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1179 .channelQuant = {},
1180 .isIgnored = false,
1181 .data = TestBuffer::createFromVector<int8_t>({})
1182 }, { // out1
1183 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
1184 .dimensions = {2, 1},
1185 .numberOfConsumers = 0,
1186 .scale = 0.25f,
1187 .zeroPoint = -9,
1188 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1189 .channelQuant = {},
1190 .isIgnored = false,
1191 .data = TestBuffer::createFromVector<int8_t>({3, 7})
1192 }, { // in01_new
1193 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
1194 .dimensions = {2},
1195 .numberOfConsumers = 1,
1196 .scale = 0.25f,
1197 .zeroPoint = -9,
1198 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1199 .channelQuant = {},
1200 .isIgnored = false,
1201 .data = TestBuffer::createFromVector<int8_t>({3, 7})
1202 }, { // placeholder7
1203 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
1204 .dimensions = {1},
1205 .numberOfConsumers = 1,
1206 .scale = 0.25f,
1207 .zeroPoint = -9,
1208 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1209 .channelQuant = {},
1210 .isIgnored = false,
1211 .data = TestBuffer::createFromVector<int8_t>({-9})
1212 }, { // param7
1213 .type = TestOperandType::INT32,
1214 .dimensions = {},
1215 .numberOfConsumers = 1,
1216 .scale = 0.0f,
1217 .zeroPoint = 0,
1218 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1219 .channelQuant = {},
1220 .isIgnored = false,
1221 .data = TestBuffer::createFromVector<int32_t>({0})
1222 }},
1223 .operations = {{
1224 .type = TestOperationType::ADD,
1225 .inputs = {3, 4, 5},
1226 .outputs = {1}
1227 }, {
1228 .type = TestOperationType::PACK,
1229 .inputs = {0, 1},
1230 .outputs = {2}
1231 }},
1232 .inputIndexes = {3},
1233 .outputIndexes = {2}
1234 },
1235 .referenced = {},
1236 .isRelaxed = false,
1237 .expectedMultinomialDistributionTolerance = 0,
1238 .expectFailure = false,
1239 .minSupportedVersion = TestHalVersion::AIDL_V2
1240 };
1241 return model;
1242 }
1243
1244 const auto dummy_test_model_FLOAT32_unary_axis1_quant8_asymm_signed_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_unary_axis1_quant8_asymm_signed_all_inputs_as_internal", get_test_model_FLOAT32_unary_axis1_quant8_asymm_signed_all_inputs_as_internal());
1245
1246 } // namespace generated_tests::pack
1247
1248 namespace generated_tests::pack {
1249
get_test_model_FLOAT32_unary_axis1_int32()1250 const TestModel& get_test_model_FLOAT32_unary_axis1_int32() {
1251 static TestModel model = {
1252 .main = {
1253 .operands = {{ // axis1
1254 .type = TestOperandType::INT32,
1255 .dimensions = {},
1256 .numberOfConsumers = 1,
1257 .scale = 0.0f,
1258 .zeroPoint = 0,
1259 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1260 .channelQuant = {},
1261 .isIgnored = false,
1262 .data = TestBuffer::createFromVector<int32_t>({1})
1263 }, { // in01
1264 .type = TestOperandType::TENSOR_INT32,
1265 .dimensions = {2},
1266 .numberOfConsumers = 1,
1267 .scale = 0.0f,
1268 .zeroPoint = 0,
1269 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1270 .channelQuant = {},
1271 .isIgnored = false,
1272 .data = TestBuffer::createFromVector<int32_t>({3, 4})
1273 }, { // out1
1274 .type = TestOperandType::TENSOR_INT32,
1275 .dimensions = {2, 1},
1276 .numberOfConsumers = 0,
1277 .scale = 0.0f,
1278 .zeroPoint = 0,
1279 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1280 .channelQuant = {},
1281 .isIgnored = false,
1282 .data = TestBuffer::createFromVector<int32_t>({3, 4})
1283 }},
1284 .operations = {{
1285 .type = TestOperationType::PACK,
1286 .inputs = {0, 1},
1287 .outputs = {2}
1288 }},
1289 .inputIndexes = {1},
1290 .outputIndexes = {2}
1291 },
1292 .referenced = {},
1293 .isRelaxed = false,
1294 .expectedMultinomialDistributionTolerance = 0,
1295 .expectFailure = false,
1296 .minSupportedVersion = TestHalVersion::AIDL_V2
1297 };
1298 return model;
1299 }
1300
1301 const auto dummy_test_model_FLOAT32_unary_axis1_int32 = TestModelManager::get().add("pack_FLOAT32_unary_axis1_int32", get_test_model_FLOAT32_unary_axis1_int32());
1302
1303 } // namespace generated_tests::pack
1304
1305 namespace generated_tests::pack {
1306
get_test_model_FLOAT32_binary_axis0()1307 const TestModel& get_test_model_FLOAT32_binary_axis0() {
1308 static TestModel model = {
1309 .main = {
1310 .operands = {{ // axis2
1311 .type = TestOperandType::INT32,
1312 .dimensions = {},
1313 .numberOfConsumers = 1,
1314 .scale = 0.0f,
1315 .zeroPoint = 0,
1316 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1317 .channelQuant = {},
1318 .isIgnored = false,
1319 .data = TestBuffer::createFromVector<int32_t>({0})
1320 }, { // in02
1321 .type = TestOperandType::TENSOR_FLOAT32,
1322 .dimensions = {3, 4},
1323 .numberOfConsumers = 1,
1324 .scale = 0.0f,
1325 .zeroPoint = 0,
1326 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1327 .channelQuant = {},
1328 .isIgnored = false,
1329 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f})
1330 }, { // in1
1331 .type = TestOperandType::TENSOR_FLOAT32,
1332 .dimensions = {3, 4},
1333 .numberOfConsumers = 1,
1334 .scale = 0.0f,
1335 .zeroPoint = 0,
1336 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1337 .channelQuant = {},
1338 .isIgnored = false,
1339 .data = TestBuffer::createFromVector<float>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
1340 }, { // out2
1341 .type = TestOperandType::TENSOR_FLOAT32,
1342 .dimensions = {2, 3, 4},
1343 .numberOfConsumers = 0,
1344 .scale = 0.0f,
1345 .zeroPoint = 0,
1346 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1347 .channelQuant = {},
1348 .isIgnored = false,
1349 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
1350 }},
1351 .operations = {{
1352 .type = TestOperationType::PACK,
1353 .inputs = {0, 1, 2},
1354 .outputs = {3}
1355 }},
1356 .inputIndexes = {1, 2},
1357 .outputIndexes = {3}
1358 },
1359 .referenced = {},
1360 .isRelaxed = false,
1361 .expectedMultinomialDistributionTolerance = 0,
1362 .expectFailure = false,
1363 .minSupportedVersion = TestHalVersion::AIDL_V2
1364 };
1365 return model;
1366 }
1367
1368 const auto dummy_test_model_FLOAT32_binary_axis0 = TestModelManager::get().add("pack_FLOAT32_binary_axis0", get_test_model_FLOAT32_binary_axis0());
1369
1370 } // namespace generated_tests::pack
1371
1372 namespace generated_tests::pack {
1373
get_test_model_FLOAT32_binary_axis0_all_inputs_as_internal()1374 const TestModel& get_test_model_FLOAT32_binary_axis0_all_inputs_as_internal() {
1375 static TestModel model = {
1376 .main = {
1377 .operands = {{ // axis2
1378 .type = TestOperandType::INT32,
1379 .dimensions = {},
1380 .numberOfConsumers = 1,
1381 .scale = 0.0f,
1382 .zeroPoint = 0,
1383 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1384 .channelQuant = {},
1385 .isIgnored = false,
1386 .data = TestBuffer::createFromVector<int32_t>({0})
1387 }, { // in02
1388 .type = TestOperandType::TENSOR_FLOAT32,
1389 .dimensions = {3, 4},
1390 .numberOfConsumers = 1,
1391 .scale = 0.0f,
1392 .zeroPoint = 0,
1393 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1394 .channelQuant = {},
1395 .isIgnored = false,
1396 .data = TestBuffer::createFromVector<float>({})
1397 }, { // in1
1398 .type = TestOperandType::TENSOR_FLOAT32,
1399 .dimensions = {3, 4},
1400 .numberOfConsumers = 1,
1401 .scale = 0.0f,
1402 .zeroPoint = 0,
1403 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1404 .channelQuant = {},
1405 .isIgnored = false,
1406 .data = TestBuffer::createFromVector<float>({})
1407 }, { // out2
1408 .type = TestOperandType::TENSOR_FLOAT32,
1409 .dimensions = {2, 3, 4},
1410 .numberOfConsumers = 0,
1411 .scale = 0.0f,
1412 .zeroPoint = 0,
1413 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1414 .channelQuant = {},
1415 .isIgnored = false,
1416 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
1417 }, { // in02_new
1418 .type = TestOperandType::TENSOR_FLOAT32,
1419 .dimensions = {3, 4},
1420 .numberOfConsumers = 1,
1421 .scale = 0.0f,
1422 .zeroPoint = 0,
1423 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1424 .channelQuant = {},
1425 .isIgnored = false,
1426 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f})
1427 }, { // placeholder8
1428 .type = TestOperandType::TENSOR_FLOAT32,
1429 .dimensions = {1},
1430 .numberOfConsumers = 1,
1431 .scale = 0.0f,
1432 .zeroPoint = 0,
1433 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1434 .channelQuant = {},
1435 .isIgnored = false,
1436 .data = TestBuffer::createFromVector<float>({0.0f})
1437 }, { // param8
1438 .type = TestOperandType::INT32,
1439 .dimensions = {},
1440 .numberOfConsumers = 1,
1441 .scale = 0.0f,
1442 .zeroPoint = 0,
1443 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1444 .channelQuant = {},
1445 .isIgnored = false,
1446 .data = TestBuffer::createFromVector<int32_t>({0})
1447 }, { // in1_new
1448 .type = TestOperandType::TENSOR_FLOAT32,
1449 .dimensions = {3, 4},
1450 .numberOfConsumers = 1,
1451 .scale = 0.0f,
1452 .zeroPoint = 0,
1453 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1454 .channelQuant = {},
1455 .isIgnored = false,
1456 .data = TestBuffer::createFromVector<float>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
1457 }, { // placeholder9
1458 .type = TestOperandType::TENSOR_FLOAT32,
1459 .dimensions = {1},
1460 .numberOfConsumers = 1,
1461 .scale = 0.0f,
1462 .zeroPoint = 0,
1463 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1464 .channelQuant = {},
1465 .isIgnored = false,
1466 .data = TestBuffer::createFromVector<float>({0.0f})
1467 }, { // param9
1468 .type = TestOperandType::INT32,
1469 .dimensions = {},
1470 .numberOfConsumers = 1,
1471 .scale = 0.0f,
1472 .zeroPoint = 0,
1473 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1474 .channelQuant = {},
1475 .isIgnored = false,
1476 .data = TestBuffer::createFromVector<int32_t>({0})
1477 }},
1478 .operations = {{
1479 .type = TestOperationType::ADD,
1480 .inputs = {4, 5, 6},
1481 .outputs = {1}
1482 }, {
1483 .type = TestOperationType::ADD,
1484 .inputs = {7, 8, 9},
1485 .outputs = {2}
1486 }, {
1487 .type = TestOperationType::PACK,
1488 .inputs = {0, 1, 2},
1489 .outputs = {3}
1490 }},
1491 .inputIndexes = {4, 7},
1492 .outputIndexes = {3}
1493 },
1494 .referenced = {},
1495 .isRelaxed = false,
1496 .expectedMultinomialDistributionTolerance = 0,
1497 .expectFailure = false,
1498 .minSupportedVersion = TestHalVersion::AIDL_V2
1499 };
1500 return model;
1501 }
1502
1503 const auto dummy_test_model_FLOAT32_binary_axis0_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_binary_axis0_all_inputs_as_internal", get_test_model_FLOAT32_binary_axis0_all_inputs_as_internal());
1504
1505 } // namespace generated_tests::pack
1506
1507 namespace generated_tests::pack {
1508
get_test_model_FLOAT32_binary_axis0_float16()1509 const TestModel& get_test_model_FLOAT32_binary_axis0_float16() {
1510 static TestModel model = {
1511 .main = {
1512 .operands = {{ // axis2
1513 .type = TestOperandType::INT32,
1514 .dimensions = {},
1515 .numberOfConsumers = 1,
1516 .scale = 0.0f,
1517 .zeroPoint = 0,
1518 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1519 .channelQuant = {},
1520 .isIgnored = false,
1521 .data = TestBuffer::createFromVector<int32_t>({0})
1522 }, { // in02
1523 .type = TestOperandType::TENSOR_FLOAT16,
1524 .dimensions = {3, 4},
1525 .numberOfConsumers = 1,
1526 .scale = 0.0f,
1527 .zeroPoint = 0,
1528 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1529 .channelQuant = {},
1530 .isIgnored = false,
1531 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f})
1532 }, { // in1
1533 .type = TestOperandType::TENSOR_FLOAT16,
1534 .dimensions = {3, 4},
1535 .numberOfConsumers = 1,
1536 .scale = 0.0f,
1537 .zeroPoint = 0,
1538 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1539 .channelQuant = {},
1540 .isIgnored = false,
1541 .data = TestBuffer::createFromVector<_Float16>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
1542 }, { // out2
1543 .type = TestOperandType::TENSOR_FLOAT16,
1544 .dimensions = {2, 3, 4},
1545 .numberOfConsumers = 0,
1546 .scale = 0.0f,
1547 .zeroPoint = 0,
1548 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1549 .channelQuant = {},
1550 .isIgnored = false,
1551 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
1552 }},
1553 .operations = {{
1554 .type = TestOperationType::PACK,
1555 .inputs = {0, 1, 2},
1556 .outputs = {3}
1557 }},
1558 .inputIndexes = {1, 2},
1559 .outputIndexes = {3}
1560 },
1561 .referenced = {},
1562 .isRelaxed = false,
1563 .expectedMultinomialDistributionTolerance = 0,
1564 .expectFailure = false,
1565 .minSupportedVersion = TestHalVersion::AIDL_V2
1566 };
1567 return model;
1568 }
1569
1570 const auto dummy_test_model_FLOAT32_binary_axis0_float16 = TestModelManager::get().add("pack_FLOAT32_binary_axis0_float16", get_test_model_FLOAT32_binary_axis0_float16());
1571
1572 } // namespace generated_tests::pack
1573
1574 namespace generated_tests::pack {
1575
get_test_model_FLOAT32_binary_axis0_float16_all_inputs_as_internal()1576 const TestModel& get_test_model_FLOAT32_binary_axis0_float16_all_inputs_as_internal() {
1577 static TestModel model = {
1578 .main = {
1579 .operands = {{ // axis2
1580 .type = TestOperandType::INT32,
1581 .dimensions = {},
1582 .numberOfConsumers = 1,
1583 .scale = 0.0f,
1584 .zeroPoint = 0,
1585 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1586 .channelQuant = {},
1587 .isIgnored = false,
1588 .data = TestBuffer::createFromVector<int32_t>({0})
1589 }, { // in02
1590 .type = TestOperandType::TENSOR_FLOAT16,
1591 .dimensions = {3, 4},
1592 .numberOfConsumers = 1,
1593 .scale = 0.0f,
1594 .zeroPoint = 0,
1595 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1596 .channelQuant = {},
1597 .isIgnored = false,
1598 .data = TestBuffer::createFromVector<_Float16>({})
1599 }, { // in1
1600 .type = TestOperandType::TENSOR_FLOAT16,
1601 .dimensions = {3, 4},
1602 .numberOfConsumers = 1,
1603 .scale = 0.0f,
1604 .zeroPoint = 0,
1605 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1606 .channelQuant = {},
1607 .isIgnored = false,
1608 .data = TestBuffer::createFromVector<_Float16>({})
1609 }, { // out2
1610 .type = TestOperandType::TENSOR_FLOAT16,
1611 .dimensions = {2, 3, 4},
1612 .numberOfConsumers = 0,
1613 .scale = 0.0f,
1614 .zeroPoint = 0,
1615 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1616 .channelQuant = {},
1617 .isIgnored = false,
1618 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
1619 }, { // in02_new
1620 .type = TestOperandType::TENSOR_FLOAT16,
1621 .dimensions = {3, 4},
1622 .numberOfConsumers = 1,
1623 .scale = 0.0f,
1624 .zeroPoint = 0,
1625 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1626 .channelQuant = {},
1627 .isIgnored = false,
1628 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f})
1629 }, { // placeholder10
1630 .type = TestOperandType::TENSOR_FLOAT16,
1631 .dimensions = {1},
1632 .numberOfConsumers = 1,
1633 .scale = 0.0f,
1634 .zeroPoint = 0,
1635 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1636 .channelQuant = {},
1637 .isIgnored = false,
1638 .data = TestBuffer::createFromVector<_Float16>({0.0f})
1639 }, { // param10
1640 .type = TestOperandType::INT32,
1641 .dimensions = {},
1642 .numberOfConsumers = 1,
1643 .scale = 0.0f,
1644 .zeroPoint = 0,
1645 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1646 .channelQuant = {},
1647 .isIgnored = false,
1648 .data = TestBuffer::createFromVector<int32_t>({0})
1649 }, { // in1_new
1650 .type = TestOperandType::TENSOR_FLOAT16,
1651 .dimensions = {3, 4},
1652 .numberOfConsumers = 1,
1653 .scale = 0.0f,
1654 .zeroPoint = 0,
1655 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1656 .channelQuant = {},
1657 .isIgnored = false,
1658 .data = TestBuffer::createFromVector<_Float16>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
1659 }, { // placeholder11
1660 .type = TestOperandType::TENSOR_FLOAT16,
1661 .dimensions = {1},
1662 .numberOfConsumers = 1,
1663 .scale = 0.0f,
1664 .zeroPoint = 0,
1665 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1666 .channelQuant = {},
1667 .isIgnored = false,
1668 .data = TestBuffer::createFromVector<_Float16>({0.0f})
1669 }, { // param11
1670 .type = TestOperandType::INT32,
1671 .dimensions = {},
1672 .numberOfConsumers = 1,
1673 .scale = 0.0f,
1674 .zeroPoint = 0,
1675 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1676 .channelQuant = {},
1677 .isIgnored = false,
1678 .data = TestBuffer::createFromVector<int32_t>({0})
1679 }},
1680 .operations = {{
1681 .type = TestOperationType::ADD,
1682 .inputs = {4, 5, 6},
1683 .outputs = {1}
1684 }, {
1685 .type = TestOperationType::ADD,
1686 .inputs = {7, 8, 9},
1687 .outputs = {2}
1688 }, {
1689 .type = TestOperationType::PACK,
1690 .inputs = {0, 1, 2},
1691 .outputs = {3}
1692 }},
1693 .inputIndexes = {4, 7},
1694 .outputIndexes = {3}
1695 },
1696 .referenced = {},
1697 .isRelaxed = false,
1698 .expectedMultinomialDistributionTolerance = 0,
1699 .expectFailure = false,
1700 .minSupportedVersion = TestHalVersion::AIDL_V2
1701 };
1702 return model;
1703 }
1704
1705 const auto dummy_test_model_FLOAT32_binary_axis0_float16_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_binary_axis0_float16_all_inputs_as_internal", get_test_model_FLOAT32_binary_axis0_float16_all_inputs_as_internal());
1706
1707 } // namespace generated_tests::pack
1708
1709 namespace generated_tests::pack {
1710
get_test_model_FLOAT32_binary_axis0_quant8_asymm()1711 const TestModel& get_test_model_FLOAT32_binary_axis0_quant8_asymm() {
1712 static TestModel model = {
1713 .main = {
1714 .operands = {{ // axis2
1715 .type = TestOperandType::INT32,
1716 .dimensions = {},
1717 .numberOfConsumers = 1,
1718 .scale = 0.0f,
1719 .zeroPoint = 0,
1720 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1721 .channelQuant = {},
1722 .isIgnored = false,
1723 .data = TestBuffer::createFromVector<int32_t>({0})
1724 }, { // in02
1725 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1726 .dimensions = {3, 4},
1727 .numberOfConsumers = 1,
1728 .scale = 0.5f,
1729 .zeroPoint = 4,
1730 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1731 .channelQuant = {},
1732 .isIgnored = false,
1733 .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26})
1734 }, { // in1
1735 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1736 .dimensions = {3, 4},
1737 .numberOfConsumers = 1,
1738 .scale = 0.5f,
1739 .zeroPoint = 4,
1740 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1741 .channelQuant = {},
1742 .isIgnored = false,
1743 .data = TestBuffer::createFromVector<uint8_t>({28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50})
1744 }, { // out2
1745 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1746 .dimensions = {2, 3, 4},
1747 .numberOfConsumers = 0,
1748 .scale = 0.5f,
1749 .zeroPoint = 4,
1750 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1751 .channelQuant = {},
1752 .isIgnored = false,
1753 .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50})
1754 }},
1755 .operations = {{
1756 .type = TestOperationType::PACK,
1757 .inputs = {0, 1, 2},
1758 .outputs = {3}
1759 }},
1760 .inputIndexes = {1, 2},
1761 .outputIndexes = {3}
1762 },
1763 .referenced = {},
1764 .isRelaxed = false,
1765 .expectedMultinomialDistributionTolerance = 0,
1766 .expectFailure = false,
1767 .minSupportedVersion = TestHalVersion::AIDL_V2
1768 };
1769 return model;
1770 }
1771
1772 const auto dummy_test_model_FLOAT32_binary_axis0_quant8_asymm = TestModelManager::get().add("pack_FLOAT32_binary_axis0_quant8_asymm", get_test_model_FLOAT32_binary_axis0_quant8_asymm());
1773
1774 } // namespace generated_tests::pack
1775
1776 namespace generated_tests::pack {
1777
get_test_model_FLOAT32_binary_axis0_quant8_asymm_all_inputs_as_internal()1778 const TestModel& get_test_model_FLOAT32_binary_axis0_quant8_asymm_all_inputs_as_internal() {
1779 static TestModel model = {
1780 .main = {
1781 .operands = {{ // axis2
1782 .type = TestOperandType::INT32,
1783 .dimensions = {},
1784 .numberOfConsumers = 1,
1785 .scale = 0.0f,
1786 .zeroPoint = 0,
1787 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1788 .channelQuant = {},
1789 .isIgnored = false,
1790 .data = TestBuffer::createFromVector<int32_t>({0})
1791 }, { // in02
1792 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1793 .dimensions = {3, 4},
1794 .numberOfConsumers = 1,
1795 .scale = 0.5f,
1796 .zeroPoint = 4,
1797 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1798 .channelQuant = {},
1799 .isIgnored = false,
1800 .data = TestBuffer::createFromVector<uint8_t>({})
1801 }, { // in1
1802 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1803 .dimensions = {3, 4},
1804 .numberOfConsumers = 1,
1805 .scale = 0.5f,
1806 .zeroPoint = 4,
1807 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1808 .channelQuant = {},
1809 .isIgnored = false,
1810 .data = TestBuffer::createFromVector<uint8_t>({})
1811 }, { // out2
1812 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1813 .dimensions = {2, 3, 4},
1814 .numberOfConsumers = 0,
1815 .scale = 0.5f,
1816 .zeroPoint = 4,
1817 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1818 .channelQuant = {},
1819 .isIgnored = false,
1820 .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50})
1821 }, { // in02_new
1822 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1823 .dimensions = {3, 4},
1824 .numberOfConsumers = 1,
1825 .scale = 0.5f,
1826 .zeroPoint = 4,
1827 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1828 .channelQuant = {},
1829 .isIgnored = false,
1830 .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26})
1831 }, { // placeholder12
1832 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1833 .dimensions = {1},
1834 .numberOfConsumers = 1,
1835 .scale = 0.5f,
1836 .zeroPoint = 4,
1837 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1838 .channelQuant = {},
1839 .isIgnored = false,
1840 .data = TestBuffer::createFromVector<uint8_t>({4})
1841 }, { // param12
1842 .type = TestOperandType::INT32,
1843 .dimensions = {},
1844 .numberOfConsumers = 1,
1845 .scale = 0.0f,
1846 .zeroPoint = 0,
1847 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1848 .channelQuant = {},
1849 .isIgnored = false,
1850 .data = TestBuffer::createFromVector<int32_t>({0})
1851 }, { // in1_new
1852 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1853 .dimensions = {3, 4},
1854 .numberOfConsumers = 1,
1855 .scale = 0.5f,
1856 .zeroPoint = 4,
1857 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1858 .channelQuant = {},
1859 .isIgnored = false,
1860 .data = TestBuffer::createFromVector<uint8_t>({28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50})
1861 }, { // placeholder13
1862 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1863 .dimensions = {1},
1864 .numberOfConsumers = 1,
1865 .scale = 0.5f,
1866 .zeroPoint = 4,
1867 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1868 .channelQuant = {},
1869 .isIgnored = false,
1870 .data = TestBuffer::createFromVector<uint8_t>({4})
1871 }, { // param13
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 }},
1882 .operations = {{
1883 .type = TestOperationType::ADD,
1884 .inputs = {4, 5, 6},
1885 .outputs = {1}
1886 }, {
1887 .type = TestOperationType::ADD,
1888 .inputs = {7, 8, 9},
1889 .outputs = {2}
1890 }, {
1891 .type = TestOperationType::PACK,
1892 .inputs = {0, 1, 2},
1893 .outputs = {3}
1894 }},
1895 .inputIndexes = {4, 7},
1896 .outputIndexes = {3}
1897 },
1898 .referenced = {},
1899 .isRelaxed = false,
1900 .expectedMultinomialDistributionTolerance = 0,
1901 .expectFailure = false,
1902 .minSupportedVersion = TestHalVersion::AIDL_V2
1903 };
1904 return model;
1905 }
1906
1907 const auto dummy_test_model_FLOAT32_binary_axis0_quant8_asymm_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_binary_axis0_quant8_asymm_all_inputs_as_internal", get_test_model_FLOAT32_binary_axis0_quant8_asymm_all_inputs_as_internal());
1908
1909 } // namespace generated_tests::pack
1910
1911 namespace generated_tests::pack {
1912
get_test_model_FLOAT32_binary_axis0_quant8_asymm_signed()1913 const TestModel& get_test_model_FLOAT32_binary_axis0_quant8_asymm_signed() {
1914 static TestModel model = {
1915 .main = {
1916 .operands = {{ // axis2
1917 .type = TestOperandType::INT32,
1918 .dimensions = {},
1919 .numberOfConsumers = 1,
1920 .scale = 0.0f,
1921 .zeroPoint = 0,
1922 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1923 .channelQuant = {},
1924 .isIgnored = false,
1925 .data = TestBuffer::createFromVector<int32_t>({0})
1926 }, { // in02
1927 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
1928 .dimensions = {3, 4},
1929 .numberOfConsumers = 1,
1930 .scale = 0.25f,
1931 .zeroPoint = -9,
1932 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1933 .channelQuant = {},
1934 .isIgnored = false,
1935 .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35})
1936 }, { // in1
1937 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
1938 .dimensions = {3, 4},
1939 .numberOfConsumers = 1,
1940 .scale = 0.25f,
1941 .zeroPoint = -9,
1942 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1943 .channelQuant = {},
1944 .isIgnored = false,
1945 .data = TestBuffer::createFromVector<int8_t>({39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83})
1946 }, { // out2
1947 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
1948 .dimensions = {2, 3, 4},
1949 .numberOfConsumers = 0,
1950 .scale = 0.25f,
1951 .zeroPoint = -9,
1952 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1953 .channelQuant = {},
1954 .isIgnored = false,
1955 .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83})
1956 }},
1957 .operations = {{
1958 .type = TestOperationType::PACK,
1959 .inputs = {0, 1, 2},
1960 .outputs = {3}
1961 }},
1962 .inputIndexes = {1, 2},
1963 .outputIndexes = {3}
1964 },
1965 .referenced = {},
1966 .isRelaxed = false,
1967 .expectedMultinomialDistributionTolerance = 0,
1968 .expectFailure = false,
1969 .minSupportedVersion = TestHalVersion::AIDL_V2
1970 };
1971 return model;
1972 }
1973
1974 const auto dummy_test_model_FLOAT32_binary_axis0_quant8_asymm_signed = TestModelManager::get().add("pack_FLOAT32_binary_axis0_quant8_asymm_signed", get_test_model_FLOAT32_binary_axis0_quant8_asymm_signed());
1975
1976 } // namespace generated_tests::pack
1977
1978 namespace generated_tests::pack {
1979
get_test_model_FLOAT32_binary_axis0_quant8_asymm_signed_all_inputs_as_internal()1980 const TestModel& get_test_model_FLOAT32_binary_axis0_quant8_asymm_signed_all_inputs_as_internal() {
1981 static TestModel model = {
1982 .main = {
1983 .operands = {{ // axis2
1984 .type = TestOperandType::INT32,
1985 .dimensions = {},
1986 .numberOfConsumers = 1,
1987 .scale = 0.0f,
1988 .zeroPoint = 0,
1989 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1990 .channelQuant = {},
1991 .isIgnored = false,
1992 .data = TestBuffer::createFromVector<int32_t>({0})
1993 }, { // in02
1994 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
1995 .dimensions = {3, 4},
1996 .numberOfConsumers = 1,
1997 .scale = 0.25f,
1998 .zeroPoint = -9,
1999 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2000 .channelQuant = {},
2001 .isIgnored = false,
2002 .data = TestBuffer::createFromVector<int8_t>({})
2003 }, { // in1
2004 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2005 .dimensions = {3, 4},
2006 .numberOfConsumers = 1,
2007 .scale = 0.25f,
2008 .zeroPoint = -9,
2009 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2010 .channelQuant = {},
2011 .isIgnored = false,
2012 .data = TestBuffer::createFromVector<int8_t>({})
2013 }, { // out2
2014 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2015 .dimensions = {2, 3, 4},
2016 .numberOfConsumers = 0,
2017 .scale = 0.25f,
2018 .zeroPoint = -9,
2019 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2020 .channelQuant = {},
2021 .isIgnored = false,
2022 .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83})
2023 }, { // in02_new
2024 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2025 .dimensions = {3, 4},
2026 .numberOfConsumers = 1,
2027 .scale = 0.25f,
2028 .zeroPoint = -9,
2029 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2030 .channelQuant = {},
2031 .isIgnored = false,
2032 .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35})
2033 }, { // placeholder14
2034 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2035 .dimensions = {1},
2036 .numberOfConsumers = 1,
2037 .scale = 0.25f,
2038 .zeroPoint = -9,
2039 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2040 .channelQuant = {},
2041 .isIgnored = false,
2042 .data = TestBuffer::createFromVector<int8_t>({-9})
2043 }, { // param14
2044 .type = TestOperandType::INT32,
2045 .dimensions = {},
2046 .numberOfConsumers = 1,
2047 .scale = 0.0f,
2048 .zeroPoint = 0,
2049 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2050 .channelQuant = {},
2051 .isIgnored = false,
2052 .data = TestBuffer::createFromVector<int32_t>({0})
2053 }, { // in1_new
2054 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2055 .dimensions = {3, 4},
2056 .numberOfConsumers = 1,
2057 .scale = 0.25f,
2058 .zeroPoint = -9,
2059 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2060 .channelQuant = {},
2061 .isIgnored = false,
2062 .data = TestBuffer::createFromVector<int8_t>({39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83})
2063 }, { // placeholder15
2064 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2065 .dimensions = {1},
2066 .numberOfConsumers = 1,
2067 .scale = 0.25f,
2068 .zeroPoint = -9,
2069 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2070 .channelQuant = {},
2071 .isIgnored = false,
2072 .data = TestBuffer::createFromVector<int8_t>({-9})
2073 }, { // param15
2074 .type = TestOperandType::INT32,
2075 .dimensions = {},
2076 .numberOfConsumers = 1,
2077 .scale = 0.0f,
2078 .zeroPoint = 0,
2079 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2080 .channelQuant = {},
2081 .isIgnored = false,
2082 .data = TestBuffer::createFromVector<int32_t>({0})
2083 }},
2084 .operations = {{
2085 .type = TestOperationType::ADD,
2086 .inputs = {4, 5, 6},
2087 .outputs = {1}
2088 }, {
2089 .type = TestOperationType::ADD,
2090 .inputs = {7, 8, 9},
2091 .outputs = {2}
2092 }, {
2093 .type = TestOperationType::PACK,
2094 .inputs = {0, 1, 2},
2095 .outputs = {3}
2096 }},
2097 .inputIndexes = {4, 7},
2098 .outputIndexes = {3}
2099 },
2100 .referenced = {},
2101 .isRelaxed = false,
2102 .expectedMultinomialDistributionTolerance = 0,
2103 .expectFailure = false,
2104 .minSupportedVersion = TestHalVersion::AIDL_V2
2105 };
2106 return model;
2107 }
2108
2109 const auto dummy_test_model_FLOAT32_binary_axis0_quant8_asymm_signed_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_binary_axis0_quant8_asymm_signed_all_inputs_as_internal", get_test_model_FLOAT32_binary_axis0_quant8_asymm_signed_all_inputs_as_internal());
2110
2111 } // namespace generated_tests::pack
2112
2113 namespace generated_tests::pack {
2114
get_test_model_FLOAT32_binary_axis0_int32()2115 const TestModel& get_test_model_FLOAT32_binary_axis0_int32() {
2116 static TestModel model = {
2117 .main = {
2118 .operands = {{ // axis2
2119 .type = TestOperandType::INT32,
2120 .dimensions = {},
2121 .numberOfConsumers = 1,
2122 .scale = 0.0f,
2123 .zeroPoint = 0,
2124 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2125 .channelQuant = {},
2126 .isIgnored = false,
2127 .data = TestBuffer::createFromVector<int32_t>({0})
2128 }, { // in02
2129 .type = TestOperandType::TENSOR_INT32,
2130 .dimensions = {3, 4},
2131 .numberOfConsumers = 1,
2132 .scale = 0.0f,
2133 .zeroPoint = 0,
2134 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2135 .channelQuant = {},
2136 .isIgnored = false,
2137 .data = TestBuffer::createFromVector<int32_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11})
2138 }, { // in1
2139 .type = TestOperandType::TENSOR_INT32,
2140 .dimensions = {3, 4},
2141 .numberOfConsumers = 1,
2142 .scale = 0.0f,
2143 .zeroPoint = 0,
2144 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2145 .channelQuant = {},
2146 .isIgnored = false,
2147 .data = TestBuffer::createFromVector<int32_t>({12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23})
2148 }, { // out2
2149 .type = TestOperandType::TENSOR_INT32,
2150 .dimensions = {2, 3, 4},
2151 .numberOfConsumers = 0,
2152 .scale = 0.0f,
2153 .zeroPoint = 0,
2154 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2155 .channelQuant = {},
2156 .isIgnored = false,
2157 .data = TestBuffer::createFromVector<int32_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23})
2158 }},
2159 .operations = {{
2160 .type = TestOperationType::PACK,
2161 .inputs = {0, 1, 2},
2162 .outputs = {3}
2163 }},
2164 .inputIndexes = {1, 2},
2165 .outputIndexes = {3}
2166 },
2167 .referenced = {},
2168 .isRelaxed = false,
2169 .expectedMultinomialDistributionTolerance = 0,
2170 .expectFailure = false,
2171 .minSupportedVersion = TestHalVersion::AIDL_V2
2172 };
2173 return model;
2174 }
2175
2176 const auto dummy_test_model_FLOAT32_binary_axis0_int32 = TestModelManager::get().add("pack_FLOAT32_binary_axis0_int32", get_test_model_FLOAT32_binary_axis0_int32());
2177
2178 } // namespace generated_tests::pack
2179
2180 namespace generated_tests::pack {
2181
get_test_model_FLOAT32_binary_axis1()2182 const TestModel& get_test_model_FLOAT32_binary_axis1() {
2183 static TestModel model = {
2184 .main = {
2185 .operands = {{ // axis3
2186 .type = TestOperandType::INT32,
2187 .dimensions = {},
2188 .numberOfConsumers = 1,
2189 .scale = 0.0f,
2190 .zeroPoint = 0,
2191 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2192 .channelQuant = {},
2193 .isIgnored = false,
2194 .data = TestBuffer::createFromVector<int32_t>({1})
2195 }, { // in03
2196 .type = TestOperandType::TENSOR_FLOAT32,
2197 .dimensions = {3, 4},
2198 .numberOfConsumers = 1,
2199 .scale = 0.0f,
2200 .zeroPoint = 0,
2201 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2202 .channelQuant = {},
2203 .isIgnored = false,
2204 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f})
2205 }, { // in11
2206 .type = TestOperandType::TENSOR_FLOAT32,
2207 .dimensions = {3, 4},
2208 .numberOfConsumers = 1,
2209 .scale = 0.0f,
2210 .zeroPoint = 0,
2211 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2212 .channelQuant = {},
2213 .isIgnored = false,
2214 .data = TestBuffer::createFromVector<float>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
2215 }, { // out3
2216 .type = TestOperandType::TENSOR_FLOAT32,
2217 .dimensions = {3, 2, 4},
2218 .numberOfConsumers = 0,
2219 .scale = 0.0f,
2220 .zeroPoint = 0,
2221 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2222 .channelQuant = {},
2223 .isIgnored = false,
2224 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 12.0f, 13.0f, 14.0f, 15.0f, 4.0f, 5.0f, 6.0f, 7.0f, 16.0f, 17.0f, 18.0f, 19.0f, 8.0f, 9.0f, 10.0f, 11.0f, 20.0f, 21.0f, 22.0f, 23.0f})
2225 }},
2226 .operations = {{
2227 .type = TestOperationType::PACK,
2228 .inputs = {0, 1, 2},
2229 .outputs = {3}
2230 }},
2231 .inputIndexes = {1, 2},
2232 .outputIndexes = {3}
2233 },
2234 .referenced = {},
2235 .isRelaxed = false,
2236 .expectedMultinomialDistributionTolerance = 0,
2237 .expectFailure = false,
2238 .minSupportedVersion = TestHalVersion::AIDL_V2
2239 };
2240 return model;
2241 }
2242
2243 const auto dummy_test_model_FLOAT32_binary_axis1 = TestModelManager::get().add("pack_FLOAT32_binary_axis1", get_test_model_FLOAT32_binary_axis1());
2244
2245 } // namespace generated_tests::pack
2246
2247 namespace generated_tests::pack {
2248
get_test_model_FLOAT32_binary_axis1_all_inputs_as_internal()2249 const TestModel& get_test_model_FLOAT32_binary_axis1_all_inputs_as_internal() {
2250 static TestModel model = {
2251 .main = {
2252 .operands = {{ // axis3
2253 .type = TestOperandType::INT32,
2254 .dimensions = {},
2255 .numberOfConsumers = 1,
2256 .scale = 0.0f,
2257 .zeroPoint = 0,
2258 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2259 .channelQuant = {},
2260 .isIgnored = false,
2261 .data = TestBuffer::createFromVector<int32_t>({1})
2262 }, { // in03
2263 .type = TestOperandType::TENSOR_FLOAT32,
2264 .dimensions = {3, 4},
2265 .numberOfConsumers = 1,
2266 .scale = 0.0f,
2267 .zeroPoint = 0,
2268 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2269 .channelQuant = {},
2270 .isIgnored = false,
2271 .data = TestBuffer::createFromVector<float>({})
2272 }, { // in11
2273 .type = TestOperandType::TENSOR_FLOAT32,
2274 .dimensions = {3, 4},
2275 .numberOfConsumers = 1,
2276 .scale = 0.0f,
2277 .zeroPoint = 0,
2278 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2279 .channelQuant = {},
2280 .isIgnored = false,
2281 .data = TestBuffer::createFromVector<float>({})
2282 }, { // out3
2283 .type = TestOperandType::TENSOR_FLOAT32,
2284 .dimensions = {3, 2, 4},
2285 .numberOfConsumers = 0,
2286 .scale = 0.0f,
2287 .zeroPoint = 0,
2288 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2289 .channelQuant = {},
2290 .isIgnored = false,
2291 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 12.0f, 13.0f, 14.0f, 15.0f, 4.0f, 5.0f, 6.0f, 7.0f, 16.0f, 17.0f, 18.0f, 19.0f, 8.0f, 9.0f, 10.0f, 11.0f, 20.0f, 21.0f, 22.0f, 23.0f})
2292 }, { // in03_new
2293 .type = TestOperandType::TENSOR_FLOAT32,
2294 .dimensions = {3, 4},
2295 .numberOfConsumers = 1,
2296 .scale = 0.0f,
2297 .zeroPoint = 0,
2298 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2299 .channelQuant = {},
2300 .isIgnored = false,
2301 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f})
2302 }, { // placeholder16
2303 .type = TestOperandType::TENSOR_FLOAT32,
2304 .dimensions = {1},
2305 .numberOfConsumers = 1,
2306 .scale = 0.0f,
2307 .zeroPoint = 0,
2308 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2309 .channelQuant = {},
2310 .isIgnored = false,
2311 .data = TestBuffer::createFromVector<float>({0.0f})
2312 }, { // param16
2313 .type = TestOperandType::INT32,
2314 .dimensions = {},
2315 .numberOfConsumers = 1,
2316 .scale = 0.0f,
2317 .zeroPoint = 0,
2318 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2319 .channelQuant = {},
2320 .isIgnored = false,
2321 .data = TestBuffer::createFromVector<int32_t>({0})
2322 }, { // in11_new
2323 .type = TestOperandType::TENSOR_FLOAT32,
2324 .dimensions = {3, 4},
2325 .numberOfConsumers = 1,
2326 .scale = 0.0f,
2327 .zeroPoint = 0,
2328 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2329 .channelQuant = {},
2330 .isIgnored = false,
2331 .data = TestBuffer::createFromVector<float>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
2332 }, { // placeholder17
2333 .type = TestOperandType::TENSOR_FLOAT32,
2334 .dimensions = {1},
2335 .numberOfConsumers = 1,
2336 .scale = 0.0f,
2337 .zeroPoint = 0,
2338 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2339 .channelQuant = {},
2340 .isIgnored = false,
2341 .data = TestBuffer::createFromVector<float>({0.0f})
2342 }, { // param17
2343 .type = TestOperandType::INT32,
2344 .dimensions = {},
2345 .numberOfConsumers = 1,
2346 .scale = 0.0f,
2347 .zeroPoint = 0,
2348 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2349 .channelQuant = {},
2350 .isIgnored = false,
2351 .data = TestBuffer::createFromVector<int32_t>({0})
2352 }},
2353 .operations = {{
2354 .type = TestOperationType::ADD,
2355 .inputs = {4, 5, 6},
2356 .outputs = {1}
2357 }, {
2358 .type = TestOperationType::ADD,
2359 .inputs = {7, 8, 9},
2360 .outputs = {2}
2361 }, {
2362 .type = TestOperationType::PACK,
2363 .inputs = {0, 1, 2},
2364 .outputs = {3}
2365 }},
2366 .inputIndexes = {4, 7},
2367 .outputIndexes = {3}
2368 },
2369 .referenced = {},
2370 .isRelaxed = false,
2371 .expectedMultinomialDistributionTolerance = 0,
2372 .expectFailure = false,
2373 .minSupportedVersion = TestHalVersion::AIDL_V2
2374 };
2375 return model;
2376 }
2377
2378 const auto dummy_test_model_FLOAT32_binary_axis1_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_binary_axis1_all_inputs_as_internal", get_test_model_FLOAT32_binary_axis1_all_inputs_as_internal());
2379
2380 } // namespace generated_tests::pack
2381
2382 namespace generated_tests::pack {
2383
get_test_model_FLOAT32_binary_axis1_float16()2384 const TestModel& get_test_model_FLOAT32_binary_axis1_float16() {
2385 static TestModel model = {
2386 .main = {
2387 .operands = {{ // axis3
2388 .type = TestOperandType::INT32,
2389 .dimensions = {},
2390 .numberOfConsumers = 1,
2391 .scale = 0.0f,
2392 .zeroPoint = 0,
2393 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2394 .channelQuant = {},
2395 .isIgnored = false,
2396 .data = TestBuffer::createFromVector<int32_t>({1})
2397 }, { // in03
2398 .type = TestOperandType::TENSOR_FLOAT16,
2399 .dimensions = {3, 4},
2400 .numberOfConsumers = 1,
2401 .scale = 0.0f,
2402 .zeroPoint = 0,
2403 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2404 .channelQuant = {},
2405 .isIgnored = false,
2406 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f})
2407 }, { // in11
2408 .type = TestOperandType::TENSOR_FLOAT16,
2409 .dimensions = {3, 4},
2410 .numberOfConsumers = 1,
2411 .scale = 0.0f,
2412 .zeroPoint = 0,
2413 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2414 .channelQuant = {},
2415 .isIgnored = false,
2416 .data = TestBuffer::createFromVector<_Float16>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
2417 }, { // out3
2418 .type = TestOperandType::TENSOR_FLOAT16,
2419 .dimensions = {3, 2, 4},
2420 .numberOfConsumers = 0,
2421 .scale = 0.0f,
2422 .zeroPoint = 0,
2423 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2424 .channelQuant = {},
2425 .isIgnored = false,
2426 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 12.0f, 13.0f, 14.0f, 15.0f, 4.0f, 5.0f, 6.0f, 7.0f, 16.0f, 17.0f, 18.0f, 19.0f, 8.0f, 9.0f, 10.0f, 11.0f, 20.0f, 21.0f, 22.0f, 23.0f})
2427 }},
2428 .operations = {{
2429 .type = TestOperationType::PACK,
2430 .inputs = {0, 1, 2},
2431 .outputs = {3}
2432 }},
2433 .inputIndexes = {1, 2},
2434 .outputIndexes = {3}
2435 },
2436 .referenced = {},
2437 .isRelaxed = false,
2438 .expectedMultinomialDistributionTolerance = 0,
2439 .expectFailure = false,
2440 .minSupportedVersion = TestHalVersion::AIDL_V2
2441 };
2442 return model;
2443 }
2444
2445 const auto dummy_test_model_FLOAT32_binary_axis1_float16 = TestModelManager::get().add("pack_FLOAT32_binary_axis1_float16", get_test_model_FLOAT32_binary_axis1_float16());
2446
2447 } // namespace generated_tests::pack
2448
2449 namespace generated_tests::pack {
2450
get_test_model_FLOAT32_binary_axis1_float16_all_inputs_as_internal()2451 const TestModel& get_test_model_FLOAT32_binary_axis1_float16_all_inputs_as_internal() {
2452 static TestModel model = {
2453 .main = {
2454 .operands = {{ // axis3
2455 .type = TestOperandType::INT32,
2456 .dimensions = {},
2457 .numberOfConsumers = 1,
2458 .scale = 0.0f,
2459 .zeroPoint = 0,
2460 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2461 .channelQuant = {},
2462 .isIgnored = false,
2463 .data = TestBuffer::createFromVector<int32_t>({1})
2464 }, { // in03
2465 .type = TestOperandType::TENSOR_FLOAT16,
2466 .dimensions = {3, 4},
2467 .numberOfConsumers = 1,
2468 .scale = 0.0f,
2469 .zeroPoint = 0,
2470 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2471 .channelQuant = {},
2472 .isIgnored = false,
2473 .data = TestBuffer::createFromVector<_Float16>({})
2474 }, { // in11
2475 .type = TestOperandType::TENSOR_FLOAT16,
2476 .dimensions = {3, 4},
2477 .numberOfConsumers = 1,
2478 .scale = 0.0f,
2479 .zeroPoint = 0,
2480 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2481 .channelQuant = {},
2482 .isIgnored = false,
2483 .data = TestBuffer::createFromVector<_Float16>({})
2484 }, { // out3
2485 .type = TestOperandType::TENSOR_FLOAT16,
2486 .dimensions = {3, 2, 4},
2487 .numberOfConsumers = 0,
2488 .scale = 0.0f,
2489 .zeroPoint = 0,
2490 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2491 .channelQuant = {},
2492 .isIgnored = false,
2493 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 12.0f, 13.0f, 14.0f, 15.0f, 4.0f, 5.0f, 6.0f, 7.0f, 16.0f, 17.0f, 18.0f, 19.0f, 8.0f, 9.0f, 10.0f, 11.0f, 20.0f, 21.0f, 22.0f, 23.0f})
2494 }, { // in03_new
2495 .type = TestOperandType::TENSOR_FLOAT16,
2496 .dimensions = {3, 4},
2497 .numberOfConsumers = 1,
2498 .scale = 0.0f,
2499 .zeroPoint = 0,
2500 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2501 .channelQuant = {},
2502 .isIgnored = false,
2503 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f})
2504 }, { // placeholder18
2505 .type = TestOperandType::TENSOR_FLOAT16,
2506 .dimensions = {1},
2507 .numberOfConsumers = 1,
2508 .scale = 0.0f,
2509 .zeroPoint = 0,
2510 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2511 .channelQuant = {},
2512 .isIgnored = false,
2513 .data = TestBuffer::createFromVector<_Float16>({0.0f})
2514 }, { // param18
2515 .type = TestOperandType::INT32,
2516 .dimensions = {},
2517 .numberOfConsumers = 1,
2518 .scale = 0.0f,
2519 .zeroPoint = 0,
2520 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2521 .channelQuant = {},
2522 .isIgnored = false,
2523 .data = TestBuffer::createFromVector<int32_t>({0})
2524 }, { // in11_new
2525 .type = TestOperandType::TENSOR_FLOAT16,
2526 .dimensions = {3, 4},
2527 .numberOfConsumers = 1,
2528 .scale = 0.0f,
2529 .zeroPoint = 0,
2530 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2531 .channelQuant = {},
2532 .isIgnored = false,
2533 .data = TestBuffer::createFromVector<_Float16>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
2534 }, { // placeholder19
2535 .type = TestOperandType::TENSOR_FLOAT16,
2536 .dimensions = {1},
2537 .numberOfConsumers = 1,
2538 .scale = 0.0f,
2539 .zeroPoint = 0,
2540 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2541 .channelQuant = {},
2542 .isIgnored = false,
2543 .data = TestBuffer::createFromVector<_Float16>({0.0f})
2544 }, { // param19
2545 .type = TestOperandType::INT32,
2546 .dimensions = {},
2547 .numberOfConsumers = 1,
2548 .scale = 0.0f,
2549 .zeroPoint = 0,
2550 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2551 .channelQuant = {},
2552 .isIgnored = false,
2553 .data = TestBuffer::createFromVector<int32_t>({0})
2554 }},
2555 .operations = {{
2556 .type = TestOperationType::ADD,
2557 .inputs = {4, 5, 6},
2558 .outputs = {1}
2559 }, {
2560 .type = TestOperationType::ADD,
2561 .inputs = {7, 8, 9},
2562 .outputs = {2}
2563 }, {
2564 .type = TestOperationType::PACK,
2565 .inputs = {0, 1, 2},
2566 .outputs = {3}
2567 }},
2568 .inputIndexes = {4, 7},
2569 .outputIndexes = {3}
2570 },
2571 .referenced = {},
2572 .isRelaxed = false,
2573 .expectedMultinomialDistributionTolerance = 0,
2574 .expectFailure = false,
2575 .minSupportedVersion = TestHalVersion::AIDL_V2
2576 };
2577 return model;
2578 }
2579
2580 const auto dummy_test_model_FLOAT32_binary_axis1_float16_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_binary_axis1_float16_all_inputs_as_internal", get_test_model_FLOAT32_binary_axis1_float16_all_inputs_as_internal());
2581
2582 } // namespace generated_tests::pack
2583
2584 namespace generated_tests::pack {
2585
get_test_model_FLOAT32_binary_axis1_quant8_asymm()2586 const TestModel& get_test_model_FLOAT32_binary_axis1_quant8_asymm() {
2587 static TestModel model = {
2588 .main = {
2589 .operands = {{ // axis3
2590 .type = TestOperandType::INT32,
2591 .dimensions = {},
2592 .numberOfConsumers = 1,
2593 .scale = 0.0f,
2594 .zeroPoint = 0,
2595 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2596 .channelQuant = {},
2597 .isIgnored = false,
2598 .data = TestBuffer::createFromVector<int32_t>({1})
2599 }, { // in03
2600 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2601 .dimensions = {3, 4},
2602 .numberOfConsumers = 1,
2603 .scale = 0.5f,
2604 .zeroPoint = 4,
2605 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2606 .channelQuant = {},
2607 .isIgnored = false,
2608 .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26})
2609 }, { // in11
2610 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2611 .dimensions = {3, 4},
2612 .numberOfConsumers = 1,
2613 .scale = 0.5f,
2614 .zeroPoint = 4,
2615 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2616 .channelQuant = {},
2617 .isIgnored = false,
2618 .data = TestBuffer::createFromVector<uint8_t>({28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50})
2619 }, { // out3
2620 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2621 .dimensions = {3, 2, 4},
2622 .numberOfConsumers = 0,
2623 .scale = 0.5f,
2624 .zeroPoint = 4,
2625 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2626 .channelQuant = {},
2627 .isIgnored = false,
2628 .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 28, 30, 32, 34, 12, 14, 16, 18, 36, 38, 40, 42, 20, 22, 24, 26, 44, 46, 48, 50})
2629 }},
2630 .operations = {{
2631 .type = TestOperationType::PACK,
2632 .inputs = {0, 1, 2},
2633 .outputs = {3}
2634 }},
2635 .inputIndexes = {1, 2},
2636 .outputIndexes = {3}
2637 },
2638 .referenced = {},
2639 .isRelaxed = false,
2640 .expectedMultinomialDistributionTolerance = 0,
2641 .expectFailure = false,
2642 .minSupportedVersion = TestHalVersion::AIDL_V2
2643 };
2644 return model;
2645 }
2646
2647 const auto dummy_test_model_FLOAT32_binary_axis1_quant8_asymm = TestModelManager::get().add("pack_FLOAT32_binary_axis1_quant8_asymm", get_test_model_FLOAT32_binary_axis1_quant8_asymm());
2648
2649 } // namespace generated_tests::pack
2650
2651 namespace generated_tests::pack {
2652
get_test_model_FLOAT32_binary_axis1_quant8_asymm_all_inputs_as_internal()2653 const TestModel& get_test_model_FLOAT32_binary_axis1_quant8_asymm_all_inputs_as_internal() {
2654 static TestModel model = {
2655 .main = {
2656 .operands = {{ // axis3
2657 .type = TestOperandType::INT32,
2658 .dimensions = {},
2659 .numberOfConsumers = 1,
2660 .scale = 0.0f,
2661 .zeroPoint = 0,
2662 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2663 .channelQuant = {},
2664 .isIgnored = false,
2665 .data = TestBuffer::createFromVector<int32_t>({1})
2666 }, { // in03
2667 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2668 .dimensions = {3, 4},
2669 .numberOfConsumers = 1,
2670 .scale = 0.5f,
2671 .zeroPoint = 4,
2672 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2673 .channelQuant = {},
2674 .isIgnored = false,
2675 .data = TestBuffer::createFromVector<uint8_t>({})
2676 }, { // in11
2677 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2678 .dimensions = {3, 4},
2679 .numberOfConsumers = 1,
2680 .scale = 0.5f,
2681 .zeroPoint = 4,
2682 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2683 .channelQuant = {},
2684 .isIgnored = false,
2685 .data = TestBuffer::createFromVector<uint8_t>({})
2686 }, { // out3
2687 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2688 .dimensions = {3, 2, 4},
2689 .numberOfConsumers = 0,
2690 .scale = 0.5f,
2691 .zeroPoint = 4,
2692 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2693 .channelQuant = {},
2694 .isIgnored = false,
2695 .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 28, 30, 32, 34, 12, 14, 16, 18, 36, 38, 40, 42, 20, 22, 24, 26, 44, 46, 48, 50})
2696 }, { // in03_new
2697 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2698 .dimensions = {3, 4},
2699 .numberOfConsumers = 1,
2700 .scale = 0.5f,
2701 .zeroPoint = 4,
2702 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2703 .channelQuant = {},
2704 .isIgnored = false,
2705 .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26})
2706 }, { // placeholder20
2707 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2708 .dimensions = {1},
2709 .numberOfConsumers = 1,
2710 .scale = 0.5f,
2711 .zeroPoint = 4,
2712 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2713 .channelQuant = {},
2714 .isIgnored = false,
2715 .data = TestBuffer::createFromVector<uint8_t>({4})
2716 }, { // param20
2717 .type = TestOperandType::INT32,
2718 .dimensions = {},
2719 .numberOfConsumers = 1,
2720 .scale = 0.0f,
2721 .zeroPoint = 0,
2722 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2723 .channelQuant = {},
2724 .isIgnored = false,
2725 .data = TestBuffer::createFromVector<int32_t>({0})
2726 }, { // in11_new
2727 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2728 .dimensions = {3, 4},
2729 .numberOfConsumers = 1,
2730 .scale = 0.5f,
2731 .zeroPoint = 4,
2732 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2733 .channelQuant = {},
2734 .isIgnored = false,
2735 .data = TestBuffer::createFromVector<uint8_t>({28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50})
2736 }, { // placeholder21
2737 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2738 .dimensions = {1},
2739 .numberOfConsumers = 1,
2740 .scale = 0.5f,
2741 .zeroPoint = 4,
2742 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2743 .channelQuant = {},
2744 .isIgnored = false,
2745 .data = TestBuffer::createFromVector<uint8_t>({4})
2746 }, { // param21
2747 .type = TestOperandType::INT32,
2748 .dimensions = {},
2749 .numberOfConsumers = 1,
2750 .scale = 0.0f,
2751 .zeroPoint = 0,
2752 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2753 .channelQuant = {},
2754 .isIgnored = false,
2755 .data = TestBuffer::createFromVector<int32_t>({0})
2756 }},
2757 .operations = {{
2758 .type = TestOperationType::ADD,
2759 .inputs = {4, 5, 6},
2760 .outputs = {1}
2761 }, {
2762 .type = TestOperationType::ADD,
2763 .inputs = {7, 8, 9},
2764 .outputs = {2}
2765 }, {
2766 .type = TestOperationType::PACK,
2767 .inputs = {0, 1, 2},
2768 .outputs = {3}
2769 }},
2770 .inputIndexes = {4, 7},
2771 .outputIndexes = {3}
2772 },
2773 .referenced = {},
2774 .isRelaxed = false,
2775 .expectedMultinomialDistributionTolerance = 0,
2776 .expectFailure = false,
2777 .minSupportedVersion = TestHalVersion::AIDL_V2
2778 };
2779 return model;
2780 }
2781
2782 const auto dummy_test_model_FLOAT32_binary_axis1_quant8_asymm_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_binary_axis1_quant8_asymm_all_inputs_as_internal", get_test_model_FLOAT32_binary_axis1_quant8_asymm_all_inputs_as_internal());
2783
2784 } // namespace generated_tests::pack
2785
2786 namespace generated_tests::pack {
2787
get_test_model_FLOAT32_binary_axis1_quant8_asymm_signed()2788 const TestModel& get_test_model_FLOAT32_binary_axis1_quant8_asymm_signed() {
2789 static TestModel model = {
2790 .main = {
2791 .operands = {{ // axis3
2792 .type = TestOperandType::INT32,
2793 .dimensions = {},
2794 .numberOfConsumers = 1,
2795 .scale = 0.0f,
2796 .zeroPoint = 0,
2797 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2798 .channelQuant = {},
2799 .isIgnored = false,
2800 .data = TestBuffer::createFromVector<int32_t>({1})
2801 }, { // in03
2802 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2803 .dimensions = {3, 4},
2804 .numberOfConsumers = 1,
2805 .scale = 0.25f,
2806 .zeroPoint = -9,
2807 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2808 .channelQuant = {},
2809 .isIgnored = false,
2810 .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35})
2811 }, { // in11
2812 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2813 .dimensions = {3, 4},
2814 .numberOfConsumers = 1,
2815 .scale = 0.25f,
2816 .zeroPoint = -9,
2817 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2818 .channelQuant = {},
2819 .isIgnored = false,
2820 .data = TestBuffer::createFromVector<int8_t>({39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83})
2821 }, { // out3
2822 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2823 .dimensions = {3, 2, 4},
2824 .numberOfConsumers = 0,
2825 .scale = 0.25f,
2826 .zeroPoint = -9,
2827 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2828 .channelQuant = {},
2829 .isIgnored = false,
2830 .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 39, 43, 47, 51, 7, 11, 15, 19, 55, 59, 63, 67, 23, 27, 31, 35, 71, 75, 79, 83})
2831 }},
2832 .operations = {{
2833 .type = TestOperationType::PACK,
2834 .inputs = {0, 1, 2},
2835 .outputs = {3}
2836 }},
2837 .inputIndexes = {1, 2},
2838 .outputIndexes = {3}
2839 },
2840 .referenced = {},
2841 .isRelaxed = false,
2842 .expectedMultinomialDistributionTolerance = 0,
2843 .expectFailure = false,
2844 .minSupportedVersion = TestHalVersion::AIDL_V2
2845 };
2846 return model;
2847 }
2848
2849 const auto dummy_test_model_FLOAT32_binary_axis1_quant8_asymm_signed = TestModelManager::get().add("pack_FLOAT32_binary_axis1_quant8_asymm_signed", get_test_model_FLOAT32_binary_axis1_quant8_asymm_signed());
2850
2851 } // namespace generated_tests::pack
2852
2853 namespace generated_tests::pack {
2854
get_test_model_FLOAT32_binary_axis1_quant8_asymm_signed_all_inputs_as_internal()2855 const TestModel& get_test_model_FLOAT32_binary_axis1_quant8_asymm_signed_all_inputs_as_internal() {
2856 static TestModel model = {
2857 .main = {
2858 .operands = {{ // axis3
2859 .type = TestOperandType::INT32,
2860 .dimensions = {},
2861 .numberOfConsumers = 1,
2862 .scale = 0.0f,
2863 .zeroPoint = 0,
2864 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2865 .channelQuant = {},
2866 .isIgnored = false,
2867 .data = TestBuffer::createFromVector<int32_t>({1})
2868 }, { // in03
2869 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2870 .dimensions = {3, 4},
2871 .numberOfConsumers = 1,
2872 .scale = 0.25f,
2873 .zeroPoint = -9,
2874 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2875 .channelQuant = {},
2876 .isIgnored = false,
2877 .data = TestBuffer::createFromVector<int8_t>({})
2878 }, { // in11
2879 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2880 .dimensions = {3, 4},
2881 .numberOfConsumers = 1,
2882 .scale = 0.25f,
2883 .zeroPoint = -9,
2884 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2885 .channelQuant = {},
2886 .isIgnored = false,
2887 .data = TestBuffer::createFromVector<int8_t>({})
2888 }, { // out3
2889 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2890 .dimensions = {3, 2, 4},
2891 .numberOfConsumers = 0,
2892 .scale = 0.25f,
2893 .zeroPoint = -9,
2894 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2895 .channelQuant = {},
2896 .isIgnored = false,
2897 .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 39, 43, 47, 51, 7, 11, 15, 19, 55, 59, 63, 67, 23, 27, 31, 35, 71, 75, 79, 83})
2898 }, { // in03_new
2899 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2900 .dimensions = {3, 4},
2901 .numberOfConsumers = 1,
2902 .scale = 0.25f,
2903 .zeroPoint = -9,
2904 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2905 .channelQuant = {},
2906 .isIgnored = false,
2907 .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35})
2908 }, { // placeholder22
2909 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2910 .dimensions = {1},
2911 .numberOfConsumers = 1,
2912 .scale = 0.25f,
2913 .zeroPoint = -9,
2914 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2915 .channelQuant = {},
2916 .isIgnored = false,
2917 .data = TestBuffer::createFromVector<int8_t>({-9})
2918 }, { // param22
2919 .type = TestOperandType::INT32,
2920 .dimensions = {},
2921 .numberOfConsumers = 1,
2922 .scale = 0.0f,
2923 .zeroPoint = 0,
2924 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2925 .channelQuant = {},
2926 .isIgnored = false,
2927 .data = TestBuffer::createFromVector<int32_t>({0})
2928 }, { // in11_new
2929 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2930 .dimensions = {3, 4},
2931 .numberOfConsumers = 1,
2932 .scale = 0.25f,
2933 .zeroPoint = -9,
2934 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2935 .channelQuant = {},
2936 .isIgnored = false,
2937 .data = TestBuffer::createFromVector<int8_t>({39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83})
2938 }, { // placeholder23
2939 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
2940 .dimensions = {1},
2941 .numberOfConsumers = 1,
2942 .scale = 0.25f,
2943 .zeroPoint = -9,
2944 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2945 .channelQuant = {},
2946 .isIgnored = false,
2947 .data = TestBuffer::createFromVector<int8_t>({-9})
2948 }, { // param23
2949 .type = TestOperandType::INT32,
2950 .dimensions = {},
2951 .numberOfConsumers = 1,
2952 .scale = 0.0f,
2953 .zeroPoint = 0,
2954 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2955 .channelQuant = {},
2956 .isIgnored = false,
2957 .data = TestBuffer::createFromVector<int32_t>({0})
2958 }},
2959 .operations = {{
2960 .type = TestOperationType::ADD,
2961 .inputs = {4, 5, 6},
2962 .outputs = {1}
2963 }, {
2964 .type = TestOperationType::ADD,
2965 .inputs = {7, 8, 9},
2966 .outputs = {2}
2967 }, {
2968 .type = TestOperationType::PACK,
2969 .inputs = {0, 1, 2},
2970 .outputs = {3}
2971 }},
2972 .inputIndexes = {4, 7},
2973 .outputIndexes = {3}
2974 },
2975 .referenced = {},
2976 .isRelaxed = false,
2977 .expectedMultinomialDistributionTolerance = 0,
2978 .expectFailure = false,
2979 .minSupportedVersion = TestHalVersion::AIDL_V2
2980 };
2981 return model;
2982 }
2983
2984 const auto dummy_test_model_FLOAT32_binary_axis1_quant8_asymm_signed_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_binary_axis1_quant8_asymm_signed_all_inputs_as_internal", get_test_model_FLOAT32_binary_axis1_quant8_asymm_signed_all_inputs_as_internal());
2985
2986 } // namespace generated_tests::pack
2987
2988 namespace generated_tests::pack {
2989
get_test_model_FLOAT32_binary_axis1_int32()2990 const TestModel& get_test_model_FLOAT32_binary_axis1_int32() {
2991 static TestModel model = {
2992 .main = {
2993 .operands = {{ // axis3
2994 .type = TestOperandType::INT32,
2995 .dimensions = {},
2996 .numberOfConsumers = 1,
2997 .scale = 0.0f,
2998 .zeroPoint = 0,
2999 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3000 .channelQuant = {},
3001 .isIgnored = false,
3002 .data = TestBuffer::createFromVector<int32_t>({1})
3003 }, { // in03
3004 .type = TestOperandType::TENSOR_INT32,
3005 .dimensions = {3, 4},
3006 .numberOfConsumers = 1,
3007 .scale = 0.0f,
3008 .zeroPoint = 0,
3009 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3010 .channelQuant = {},
3011 .isIgnored = false,
3012 .data = TestBuffer::createFromVector<int32_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11})
3013 }, { // in11
3014 .type = TestOperandType::TENSOR_INT32,
3015 .dimensions = {3, 4},
3016 .numberOfConsumers = 1,
3017 .scale = 0.0f,
3018 .zeroPoint = 0,
3019 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3020 .channelQuant = {},
3021 .isIgnored = false,
3022 .data = TestBuffer::createFromVector<int32_t>({12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23})
3023 }, { // out3
3024 .type = TestOperandType::TENSOR_INT32,
3025 .dimensions = {3, 2, 4},
3026 .numberOfConsumers = 0,
3027 .scale = 0.0f,
3028 .zeroPoint = 0,
3029 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3030 .channelQuant = {},
3031 .isIgnored = false,
3032 .data = TestBuffer::createFromVector<int32_t>({0, 1, 2, 3, 12, 13, 14, 15, 4, 5, 6, 7, 16, 17, 18, 19, 8, 9, 10, 11, 20, 21, 22, 23})
3033 }},
3034 .operations = {{
3035 .type = TestOperationType::PACK,
3036 .inputs = {0, 1, 2},
3037 .outputs = {3}
3038 }},
3039 .inputIndexes = {1, 2},
3040 .outputIndexes = {3}
3041 },
3042 .referenced = {},
3043 .isRelaxed = false,
3044 .expectedMultinomialDistributionTolerance = 0,
3045 .expectFailure = false,
3046 .minSupportedVersion = TestHalVersion::AIDL_V2
3047 };
3048 return model;
3049 }
3050
3051 const auto dummy_test_model_FLOAT32_binary_axis1_int32 = TestModelManager::get().add("pack_FLOAT32_binary_axis1_int32", get_test_model_FLOAT32_binary_axis1_int32());
3052
3053 } // namespace generated_tests::pack
3054
3055 namespace generated_tests::pack {
3056
get_test_model_FLOAT32_binary_axis2()3057 const TestModel& get_test_model_FLOAT32_binary_axis2() {
3058 static TestModel model = {
3059 .main = {
3060 .operands = {{ // axis4
3061 .type = TestOperandType::INT32,
3062 .dimensions = {},
3063 .numberOfConsumers = 1,
3064 .scale = 0.0f,
3065 .zeroPoint = 0,
3066 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3067 .channelQuant = {},
3068 .isIgnored = false,
3069 .data = TestBuffer::createFromVector<int32_t>({2})
3070 }, { // in04
3071 .type = TestOperandType::TENSOR_FLOAT32,
3072 .dimensions = {3, 4},
3073 .numberOfConsumers = 1,
3074 .scale = 0.0f,
3075 .zeroPoint = 0,
3076 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3077 .channelQuant = {},
3078 .isIgnored = false,
3079 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f})
3080 }, { // in12
3081 .type = TestOperandType::TENSOR_FLOAT32,
3082 .dimensions = {3, 4},
3083 .numberOfConsumers = 1,
3084 .scale = 0.0f,
3085 .zeroPoint = 0,
3086 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3087 .channelQuant = {},
3088 .isIgnored = false,
3089 .data = TestBuffer::createFromVector<float>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
3090 }, { // out4
3091 .type = TestOperandType::TENSOR_FLOAT32,
3092 .dimensions = {3, 4, 2},
3093 .numberOfConsumers = 0,
3094 .scale = 0.0f,
3095 .zeroPoint = 0,
3096 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3097 .channelQuant = {},
3098 .isIgnored = false,
3099 .data = TestBuffer::createFromVector<float>({0.0f, 12.0f, 1.0f, 13.0f, 2.0f, 14.0f, 3.0f, 15.0f, 4.0f, 16.0f, 5.0f, 17.0f, 6.0f, 18.0f, 7.0f, 19.0f, 8.0f, 20.0f, 9.0f, 21.0f, 10.0f, 22.0f, 11.0f, 23.0f})
3100 }},
3101 .operations = {{
3102 .type = TestOperationType::PACK,
3103 .inputs = {0, 1, 2},
3104 .outputs = {3}
3105 }},
3106 .inputIndexes = {1, 2},
3107 .outputIndexes = {3}
3108 },
3109 .referenced = {},
3110 .isRelaxed = false,
3111 .expectedMultinomialDistributionTolerance = 0,
3112 .expectFailure = false,
3113 .minSupportedVersion = TestHalVersion::AIDL_V2
3114 };
3115 return model;
3116 }
3117
3118 const auto dummy_test_model_FLOAT32_binary_axis2 = TestModelManager::get().add("pack_FLOAT32_binary_axis2", get_test_model_FLOAT32_binary_axis2());
3119
3120 } // namespace generated_tests::pack
3121
3122 namespace generated_tests::pack {
3123
get_test_model_FLOAT32_binary_axis2_all_inputs_as_internal()3124 const TestModel& get_test_model_FLOAT32_binary_axis2_all_inputs_as_internal() {
3125 static TestModel model = {
3126 .main = {
3127 .operands = {{ // axis4
3128 .type = TestOperandType::INT32,
3129 .dimensions = {},
3130 .numberOfConsumers = 1,
3131 .scale = 0.0f,
3132 .zeroPoint = 0,
3133 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3134 .channelQuant = {},
3135 .isIgnored = false,
3136 .data = TestBuffer::createFromVector<int32_t>({2})
3137 }, { // in04
3138 .type = TestOperandType::TENSOR_FLOAT32,
3139 .dimensions = {3, 4},
3140 .numberOfConsumers = 1,
3141 .scale = 0.0f,
3142 .zeroPoint = 0,
3143 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3144 .channelQuant = {},
3145 .isIgnored = false,
3146 .data = TestBuffer::createFromVector<float>({})
3147 }, { // in12
3148 .type = TestOperandType::TENSOR_FLOAT32,
3149 .dimensions = {3, 4},
3150 .numberOfConsumers = 1,
3151 .scale = 0.0f,
3152 .zeroPoint = 0,
3153 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3154 .channelQuant = {},
3155 .isIgnored = false,
3156 .data = TestBuffer::createFromVector<float>({})
3157 }, { // out4
3158 .type = TestOperandType::TENSOR_FLOAT32,
3159 .dimensions = {3, 4, 2},
3160 .numberOfConsumers = 0,
3161 .scale = 0.0f,
3162 .zeroPoint = 0,
3163 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3164 .channelQuant = {},
3165 .isIgnored = false,
3166 .data = TestBuffer::createFromVector<float>({0.0f, 12.0f, 1.0f, 13.0f, 2.0f, 14.0f, 3.0f, 15.0f, 4.0f, 16.0f, 5.0f, 17.0f, 6.0f, 18.0f, 7.0f, 19.0f, 8.0f, 20.0f, 9.0f, 21.0f, 10.0f, 22.0f, 11.0f, 23.0f})
3167 }, { // in04_new
3168 .type = TestOperandType::TENSOR_FLOAT32,
3169 .dimensions = {3, 4},
3170 .numberOfConsumers = 1,
3171 .scale = 0.0f,
3172 .zeroPoint = 0,
3173 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3174 .channelQuant = {},
3175 .isIgnored = false,
3176 .data = TestBuffer::createFromVector<float>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f})
3177 }, { // placeholder24
3178 .type = TestOperandType::TENSOR_FLOAT32,
3179 .dimensions = {1},
3180 .numberOfConsumers = 1,
3181 .scale = 0.0f,
3182 .zeroPoint = 0,
3183 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3184 .channelQuant = {},
3185 .isIgnored = false,
3186 .data = TestBuffer::createFromVector<float>({0.0f})
3187 }, { // param24
3188 .type = TestOperandType::INT32,
3189 .dimensions = {},
3190 .numberOfConsumers = 1,
3191 .scale = 0.0f,
3192 .zeroPoint = 0,
3193 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3194 .channelQuant = {},
3195 .isIgnored = false,
3196 .data = TestBuffer::createFromVector<int32_t>({0})
3197 }, { // in12_new
3198 .type = TestOperandType::TENSOR_FLOAT32,
3199 .dimensions = {3, 4},
3200 .numberOfConsumers = 1,
3201 .scale = 0.0f,
3202 .zeroPoint = 0,
3203 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3204 .channelQuant = {},
3205 .isIgnored = false,
3206 .data = TestBuffer::createFromVector<float>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
3207 }, { // placeholder25
3208 .type = TestOperandType::TENSOR_FLOAT32,
3209 .dimensions = {1},
3210 .numberOfConsumers = 1,
3211 .scale = 0.0f,
3212 .zeroPoint = 0,
3213 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3214 .channelQuant = {},
3215 .isIgnored = false,
3216 .data = TestBuffer::createFromVector<float>({0.0f})
3217 }, { // param25
3218 .type = TestOperandType::INT32,
3219 .dimensions = {},
3220 .numberOfConsumers = 1,
3221 .scale = 0.0f,
3222 .zeroPoint = 0,
3223 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3224 .channelQuant = {},
3225 .isIgnored = false,
3226 .data = TestBuffer::createFromVector<int32_t>({0})
3227 }},
3228 .operations = {{
3229 .type = TestOperationType::ADD,
3230 .inputs = {4, 5, 6},
3231 .outputs = {1}
3232 }, {
3233 .type = TestOperationType::ADD,
3234 .inputs = {7, 8, 9},
3235 .outputs = {2}
3236 }, {
3237 .type = TestOperationType::PACK,
3238 .inputs = {0, 1, 2},
3239 .outputs = {3}
3240 }},
3241 .inputIndexes = {4, 7},
3242 .outputIndexes = {3}
3243 },
3244 .referenced = {},
3245 .isRelaxed = false,
3246 .expectedMultinomialDistributionTolerance = 0,
3247 .expectFailure = false,
3248 .minSupportedVersion = TestHalVersion::AIDL_V2
3249 };
3250 return model;
3251 }
3252
3253 const auto dummy_test_model_FLOAT32_binary_axis2_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_binary_axis2_all_inputs_as_internal", get_test_model_FLOAT32_binary_axis2_all_inputs_as_internal());
3254
3255 } // namespace generated_tests::pack
3256
3257 namespace generated_tests::pack {
3258
get_test_model_FLOAT32_binary_axis2_float16()3259 const TestModel& get_test_model_FLOAT32_binary_axis2_float16() {
3260 static TestModel model = {
3261 .main = {
3262 .operands = {{ // axis4
3263 .type = TestOperandType::INT32,
3264 .dimensions = {},
3265 .numberOfConsumers = 1,
3266 .scale = 0.0f,
3267 .zeroPoint = 0,
3268 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3269 .channelQuant = {},
3270 .isIgnored = false,
3271 .data = TestBuffer::createFromVector<int32_t>({2})
3272 }, { // in04
3273 .type = TestOperandType::TENSOR_FLOAT16,
3274 .dimensions = {3, 4},
3275 .numberOfConsumers = 1,
3276 .scale = 0.0f,
3277 .zeroPoint = 0,
3278 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3279 .channelQuant = {},
3280 .isIgnored = false,
3281 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f})
3282 }, { // in12
3283 .type = TestOperandType::TENSOR_FLOAT16,
3284 .dimensions = {3, 4},
3285 .numberOfConsumers = 1,
3286 .scale = 0.0f,
3287 .zeroPoint = 0,
3288 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3289 .channelQuant = {},
3290 .isIgnored = false,
3291 .data = TestBuffer::createFromVector<_Float16>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
3292 }, { // out4
3293 .type = TestOperandType::TENSOR_FLOAT16,
3294 .dimensions = {3, 4, 2},
3295 .numberOfConsumers = 0,
3296 .scale = 0.0f,
3297 .zeroPoint = 0,
3298 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3299 .channelQuant = {},
3300 .isIgnored = false,
3301 .data = TestBuffer::createFromVector<_Float16>({0.0f, 12.0f, 1.0f, 13.0f, 2.0f, 14.0f, 3.0f, 15.0f, 4.0f, 16.0f, 5.0f, 17.0f, 6.0f, 18.0f, 7.0f, 19.0f, 8.0f, 20.0f, 9.0f, 21.0f, 10.0f, 22.0f, 11.0f, 23.0f})
3302 }},
3303 .operations = {{
3304 .type = TestOperationType::PACK,
3305 .inputs = {0, 1, 2},
3306 .outputs = {3}
3307 }},
3308 .inputIndexes = {1, 2},
3309 .outputIndexes = {3}
3310 },
3311 .referenced = {},
3312 .isRelaxed = false,
3313 .expectedMultinomialDistributionTolerance = 0,
3314 .expectFailure = false,
3315 .minSupportedVersion = TestHalVersion::AIDL_V2
3316 };
3317 return model;
3318 }
3319
3320 const auto dummy_test_model_FLOAT32_binary_axis2_float16 = TestModelManager::get().add("pack_FLOAT32_binary_axis2_float16", get_test_model_FLOAT32_binary_axis2_float16());
3321
3322 } // namespace generated_tests::pack
3323
3324 namespace generated_tests::pack {
3325
get_test_model_FLOAT32_binary_axis2_float16_all_inputs_as_internal()3326 const TestModel& get_test_model_FLOAT32_binary_axis2_float16_all_inputs_as_internal() {
3327 static TestModel model = {
3328 .main = {
3329 .operands = {{ // axis4
3330 .type = TestOperandType::INT32,
3331 .dimensions = {},
3332 .numberOfConsumers = 1,
3333 .scale = 0.0f,
3334 .zeroPoint = 0,
3335 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3336 .channelQuant = {},
3337 .isIgnored = false,
3338 .data = TestBuffer::createFromVector<int32_t>({2})
3339 }, { // in04
3340 .type = TestOperandType::TENSOR_FLOAT16,
3341 .dimensions = {3, 4},
3342 .numberOfConsumers = 1,
3343 .scale = 0.0f,
3344 .zeroPoint = 0,
3345 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3346 .channelQuant = {},
3347 .isIgnored = false,
3348 .data = TestBuffer::createFromVector<_Float16>({})
3349 }, { // in12
3350 .type = TestOperandType::TENSOR_FLOAT16,
3351 .dimensions = {3, 4},
3352 .numberOfConsumers = 1,
3353 .scale = 0.0f,
3354 .zeroPoint = 0,
3355 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3356 .channelQuant = {},
3357 .isIgnored = false,
3358 .data = TestBuffer::createFromVector<_Float16>({})
3359 }, { // out4
3360 .type = TestOperandType::TENSOR_FLOAT16,
3361 .dimensions = {3, 4, 2},
3362 .numberOfConsumers = 0,
3363 .scale = 0.0f,
3364 .zeroPoint = 0,
3365 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3366 .channelQuant = {},
3367 .isIgnored = false,
3368 .data = TestBuffer::createFromVector<_Float16>({0.0f, 12.0f, 1.0f, 13.0f, 2.0f, 14.0f, 3.0f, 15.0f, 4.0f, 16.0f, 5.0f, 17.0f, 6.0f, 18.0f, 7.0f, 19.0f, 8.0f, 20.0f, 9.0f, 21.0f, 10.0f, 22.0f, 11.0f, 23.0f})
3369 }, { // in04_new
3370 .type = TestOperandType::TENSOR_FLOAT16,
3371 .dimensions = {3, 4},
3372 .numberOfConsumers = 1,
3373 .scale = 0.0f,
3374 .zeroPoint = 0,
3375 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3376 .channelQuant = {},
3377 .isIgnored = false,
3378 .data = TestBuffer::createFromVector<_Float16>({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f})
3379 }, { // placeholder26
3380 .type = TestOperandType::TENSOR_FLOAT16,
3381 .dimensions = {1},
3382 .numberOfConsumers = 1,
3383 .scale = 0.0f,
3384 .zeroPoint = 0,
3385 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3386 .channelQuant = {},
3387 .isIgnored = false,
3388 .data = TestBuffer::createFromVector<_Float16>({0.0f})
3389 }, { // param26
3390 .type = TestOperandType::INT32,
3391 .dimensions = {},
3392 .numberOfConsumers = 1,
3393 .scale = 0.0f,
3394 .zeroPoint = 0,
3395 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3396 .channelQuant = {},
3397 .isIgnored = false,
3398 .data = TestBuffer::createFromVector<int32_t>({0})
3399 }, { // in12_new
3400 .type = TestOperandType::TENSOR_FLOAT16,
3401 .dimensions = {3, 4},
3402 .numberOfConsumers = 1,
3403 .scale = 0.0f,
3404 .zeroPoint = 0,
3405 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3406 .channelQuant = {},
3407 .isIgnored = false,
3408 .data = TestBuffer::createFromVector<_Float16>({12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 20.0f, 21.0f, 22.0f, 23.0f})
3409 }, { // placeholder27
3410 .type = TestOperandType::TENSOR_FLOAT16,
3411 .dimensions = {1},
3412 .numberOfConsumers = 1,
3413 .scale = 0.0f,
3414 .zeroPoint = 0,
3415 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3416 .channelQuant = {},
3417 .isIgnored = false,
3418 .data = TestBuffer::createFromVector<_Float16>({0.0f})
3419 }, { // param27
3420 .type = TestOperandType::INT32,
3421 .dimensions = {},
3422 .numberOfConsumers = 1,
3423 .scale = 0.0f,
3424 .zeroPoint = 0,
3425 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3426 .channelQuant = {},
3427 .isIgnored = false,
3428 .data = TestBuffer::createFromVector<int32_t>({0})
3429 }},
3430 .operations = {{
3431 .type = TestOperationType::ADD,
3432 .inputs = {4, 5, 6},
3433 .outputs = {1}
3434 }, {
3435 .type = TestOperationType::ADD,
3436 .inputs = {7, 8, 9},
3437 .outputs = {2}
3438 }, {
3439 .type = TestOperationType::PACK,
3440 .inputs = {0, 1, 2},
3441 .outputs = {3}
3442 }},
3443 .inputIndexes = {4, 7},
3444 .outputIndexes = {3}
3445 },
3446 .referenced = {},
3447 .isRelaxed = false,
3448 .expectedMultinomialDistributionTolerance = 0,
3449 .expectFailure = false,
3450 .minSupportedVersion = TestHalVersion::AIDL_V2
3451 };
3452 return model;
3453 }
3454
3455 const auto dummy_test_model_FLOAT32_binary_axis2_float16_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_binary_axis2_float16_all_inputs_as_internal", get_test_model_FLOAT32_binary_axis2_float16_all_inputs_as_internal());
3456
3457 } // namespace generated_tests::pack
3458
3459 namespace generated_tests::pack {
3460
get_test_model_FLOAT32_binary_axis2_quant8_asymm()3461 const TestModel& get_test_model_FLOAT32_binary_axis2_quant8_asymm() {
3462 static TestModel model = {
3463 .main = {
3464 .operands = {{ // axis4
3465 .type = TestOperandType::INT32,
3466 .dimensions = {},
3467 .numberOfConsumers = 1,
3468 .scale = 0.0f,
3469 .zeroPoint = 0,
3470 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3471 .channelQuant = {},
3472 .isIgnored = false,
3473 .data = TestBuffer::createFromVector<int32_t>({2})
3474 }, { // in04
3475 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3476 .dimensions = {3, 4},
3477 .numberOfConsumers = 1,
3478 .scale = 0.5f,
3479 .zeroPoint = 4,
3480 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3481 .channelQuant = {},
3482 .isIgnored = false,
3483 .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26})
3484 }, { // in12
3485 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3486 .dimensions = {3, 4},
3487 .numberOfConsumers = 1,
3488 .scale = 0.5f,
3489 .zeroPoint = 4,
3490 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3491 .channelQuant = {},
3492 .isIgnored = false,
3493 .data = TestBuffer::createFromVector<uint8_t>({28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50})
3494 }, { // out4
3495 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3496 .dimensions = {3, 4, 2},
3497 .numberOfConsumers = 0,
3498 .scale = 0.5f,
3499 .zeroPoint = 4,
3500 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3501 .channelQuant = {},
3502 .isIgnored = false,
3503 .data = TestBuffer::createFromVector<uint8_t>({4, 28, 6, 30, 8, 32, 10, 34, 12, 36, 14, 38, 16, 40, 18, 42, 20, 44, 22, 46, 24, 48, 26, 50})
3504 }},
3505 .operations = {{
3506 .type = TestOperationType::PACK,
3507 .inputs = {0, 1, 2},
3508 .outputs = {3}
3509 }},
3510 .inputIndexes = {1, 2},
3511 .outputIndexes = {3}
3512 },
3513 .referenced = {},
3514 .isRelaxed = false,
3515 .expectedMultinomialDistributionTolerance = 0,
3516 .expectFailure = false,
3517 .minSupportedVersion = TestHalVersion::AIDL_V2
3518 };
3519 return model;
3520 }
3521
3522 const auto dummy_test_model_FLOAT32_binary_axis2_quant8_asymm = TestModelManager::get().add("pack_FLOAT32_binary_axis2_quant8_asymm", get_test_model_FLOAT32_binary_axis2_quant8_asymm());
3523
3524 } // namespace generated_tests::pack
3525
3526 namespace generated_tests::pack {
3527
get_test_model_FLOAT32_binary_axis2_quant8_asymm_all_inputs_as_internal()3528 const TestModel& get_test_model_FLOAT32_binary_axis2_quant8_asymm_all_inputs_as_internal() {
3529 static TestModel model = {
3530 .main = {
3531 .operands = {{ // axis4
3532 .type = TestOperandType::INT32,
3533 .dimensions = {},
3534 .numberOfConsumers = 1,
3535 .scale = 0.0f,
3536 .zeroPoint = 0,
3537 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3538 .channelQuant = {},
3539 .isIgnored = false,
3540 .data = TestBuffer::createFromVector<int32_t>({2})
3541 }, { // in04
3542 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3543 .dimensions = {3, 4},
3544 .numberOfConsumers = 1,
3545 .scale = 0.5f,
3546 .zeroPoint = 4,
3547 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3548 .channelQuant = {},
3549 .isIgnored = false,
3550 .data = TestBuffer::createFromVector<uint8_t>({})
3551 }, { // in12
3552 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3553 .dimensions = {3, 4},
3554 .numberOfConsumers = 1,
3555 .scale = 0.5f,
3556 .zeroPoint = 4,
3557 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3558 .channelQuant = {},
3559 .isIgnored = false,
3560 .data = TestBuffer::createFromVector<uint8_t>({})
3561 }, { // out4
3562 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3563 .dimensions = {3, 4, 2},
3564 .numberOfConsumers = 0,
3565 .scale = 0.5f,
3566 .zeroPoint = 4,
3567 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3568 .channelQuant = {},
3569 .isIgnored = false,
3570 .data = TestBuffer::createFromVector<uint8_t>({4, 28, 6, 30, 8, 32, 10, 34, 12, 36, 14, 38, 16, 40, 18, 42, 20, 44, 22, 46, 24, 48, 26, 50})
3571 }, { // in04_new
3572 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3573 .dimensions = {3, 4},
3574 .numberOfConsumers = 1,
3575 .scale = 0.5f,
3576 .zeroPoint = 4,
3577 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3578 .channelQuant = {},
3579 .isIgnored = false,
3580 .data = TestBuffer::createFromVector<uint8_t>({4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26})
3581 }, { // placeholder28
3582 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3583 .dimensions = {1},
3584 .numberOfConsumers = 1,
3585 .scale = 0.5f,
3586 .zeroPoint = 4,
3587 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3588 .channelQuant = {},
3589 .isIgnored = false,
3590 .data = TestBuffer::createFromVector<uint8_t>({4})
3591 }, { // param28
3592 .type = TestOperandType::INT32,
3593 .dimensions = {},
3594 .numberOfConsumers = 1,
3595 .scale = 0.0f,
3596 .zeroPoint = 0,
3597 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3598 .channelQuant = {},
3599 .isIgnored = false,
3600 .data = TestBuffer::createFromVector<int32_t>({0})
3601 }, { // in12_new
3602 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3603 .dimensions = {3, 4},
3604 .numberOfConsumers = 1,
3605 .scale = 0.5f,
3606 .zeroPoint = 4,
3607 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3608 .channelQuant = {},
3609 .isIgnored = false,
3610 .data = TestBuffer::createFromVector<uint8_t>({28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50})
3611 }, { // placeholder29
3612 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3613 .dimensions = {1},
3614 .numberOfConsumers = 1,
3615 .scale = 0.5f,
3616 .zeroPoint = 4,
3617 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3618 .channelQuant = {},
3619 .isIgnored = false,
3620 .data = TestBuffer::createFromVector<uint8_t>({4})
3621 }, { // param29
3622 .type = TestOperandType::INT32,
3623 .dimensions = {},
3624 .numberOfConsumers = 1,
3625 .scale = 0.0f,
3626 .zeroPoint = 0,
3627 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3628 .channelQuant = {},
3629 .isIgnored = false,
3630 .data = TestBuffer::createFromVector<int32_t>({0})
3631 }},
3632 .operations = {{
3633 .type = TestOperationType::ADD,
3634 .inputs = {4, 5, 6},
3635 .outputs = {1}
3636 }, {
3637 .type = TestOperationType::ADD,
3638 .inputs = {7, 8, 9},
3639 .outputs = {2}
3640 }, {
3641 .type = TestOperationType::PACK,
3642 .inputs = {0, 1, 2},
3643 .outputs = {3}
3644 }},
3645 .inputIndexes = {4, 7},
3646 .outputIndexes = {3}
3647 },
3648 .referenced = {},
3649 .isRelaxed = false,
3650 .expectedMultinomialDistributionTolerance = 0,
3651 .expectFailure = false,
3652 .minSupportedVersion = TestHalVersion::AIDL_V2
3653 };
3654 return model;
3655 }
3656
3657 const auto dummy_test_model_FLOAT32_binary_axis2_quant8_asymm_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_binary_axis2_quant8_asymm_all_inputs_as_internal", get_test_model_FLOAT32_binary_axis2_quant8_asymm_all_inputs_as_internal());
3658
3659 } // namespace generated_tests::pack
3660
3661 namespace generated_tests::pack {
3662
get_test_model_FLOAT32_binary_axis2_quant8_asymm_signed()3663 const TestModel& get_test_model_FLOAT32_binary_axis2_quant8_asymm_signed() {
3664 static TestModel model = {
3665 .main = {
3666 .operands = {{ // axis4
3667 .type = TestOperandType::INT32,
3668 .dimensions = {},
3669 .numberOfConsumers = 1,
3670 .scale = 0.0f,
3671 .zeroPoint = 0,
3672 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3673 .channelQuant = {},
3674 .isIgnored = false,
3675 .data = TestBuffer::createFromVector<int32_t>({2})
3676 }, { // in04
3677 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
3678 .dimensions = {3, 4},
3679 .numberOfConsumers = 1,
3680 .scale = 0.25f,
3681 .zeroPoint = -9,
3682 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3683 .channelQuant = {},
3684 .isIgnored = false,
3685 .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35})
3686 }, { // in12
3687 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
3688 .dimensions = {3, 4},
3689 .numberOfConsumers = 1,
3690 .scale = 0.25f,
3691 .zeroPoint = -9,
3692 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3693 .channelQuant = {},
3694 .isIgnored = false,
3695 .data = TestBuffer::createFromVector<int8_t>({39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83})
3696 }, { // out4
3697 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
3698 .dimensions = {3, 4, 2},
3699 .numberOfConsumers = 0,
3700 .scale = 0.25f,
3701 .zeroPoint = -9,
3702 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3703 .channelQuant = {},
3704 .isIgnored = false,
3705 .data = TestBuffer::createFromVector<int8_t>({-9, 39, -5, 43, -1, 47, 3, 51, 7, 55, 11, 59, 15, 63, 19, 67, 23, 71, 27, 75, 31, 79, 35, 83})
3706 }},
3707 .operations = {{
3708 .type = TestOperationType::PACK,
3709 .inputs = {0, 1, 2},
3710 .outputs = {3}
3711 }},
3712 .inputIndexes = {1, 2},
3713 .outputIndexes = {3}
3714 },
3715 .referenced = {},
3716 .isRelaxed = false,
3717 .expectedMultinomialDistributionTolerance = 0,
3718 .expectFailure = false,
3719 .minSupportedVersion = TestHalVersion::AIDL_V2
3720 };
3721 return model;
3722 }
3723
3724 const auto dummy_test_model_FLOAT32_binary_axis2_quant8_asymm_signed = TestModelManager::get().add("pack_FLOAT32_binary_axis2_quant8_asymm_signed", get_test_model_FLOAT32_binary_axis2_quant8_asymm_signed());
3725
3726 } // namespace generated_tests::pack
3727
3728 namespace generated_tests::pack {
3729
get_test_model_FLOAT32_binary_axis2_quant8_asymm_signed_all_inputs_as_internal()3730 const TestModel& get_test_model_FLOAT32_binary_axis2_quant8_asymm_signed_all_inputs_as_internal() {
3731 static TestModel model = {
3732 .main = {
3733 .operands = {{ // axis4
3734 .type = TestOperandType::INT32,
3735 .dimensions = {},
3736 .numberOfConsumers = 1,
3737 .scale = 0.0f,
3738 .zeroPoint = 0,
3739 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3740 .channelQuant = {},
3741 .isIgnored = false,
3742 .data = TestBuffer::createFromVector<int32_t>({2})
3743 }, { // in04
3744 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
3745 .dimensions = {3, 4},
3746 .numberOfConsumers = 1,
3747 .scale = 0.25f,
3748 .zeroPoint = -9,
3749 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3750 .channelQuant = {},
3751 .isIgnored = false,
3752 .data = TestBuffer::createFromVector<int8_t>({})
3753 }, { // in12
3754 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
3755 .dimensions = {3, 4},
3756 .numberOfConsumers = 1,
3757 .scale = 0.25f,
3758 .zeroPoint = -9,
3759 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3760 .channelQuant = {},
3761 .isIgnored = false,
3762 .data = TestBuffer::createFromVector<int8_t>({})
3763 }, { // out4
3764 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
3765 .dimensions = {3, 4, 2},
3766 .numberOfConsumers = 0,
3767 .scale = 0.25f,
3768 .zeroPoint = -9,
3769 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3770 .channelQuant = {},
3771 .isIgnored = false,
3772 .data = TestBuffer::createFromVector<int8_t>({-9, 39, -5, 43, -1, 47, 3, 51, 7, 55, 11, 59, 15, 63, 19, 67, 23, 71, 27, 75, 31, 79, 35, 83})
3773 }, { // in04_new
3774 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
3775 .dimensions = {3, 4},
3776 .numberOfConsumers = 1,
3777 .scale = 0.25f,
3778 .zeroPoint = -9,
3779 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3780 .channelQuant = {},
3781 .isIgnored = false,
3782 .data = TestBuffer::createFromVector<int8_t>({-9, -5, -1, 3, 7, 11, 15, 19, 23, 27, 31, 35})
3783 }, { // placeholder30
3784 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
3785 .dimensions = {1},
3786 .numberOfConsumers = 1,
3787 .scale = 0.25f,
3788 .zeroPoint = -9,
3789 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3790 .channelQuant = {},
3791 .isIgnored = false,
3792 .data = TestBuffer::createFromVector<int8_t>({-9})
3793 }, { // param30
3794 .type = TestOperandType::INT32,
3795 .dimensions = {},
3796 .numberOfConsumers = 1,
3797 .scale = 0.0f,
3798 .zeroPoint = 0,
3799 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3800 .channelQuant = {},
3801 .isIgnored = false,
3802 .data = TestBuffer::createFromVector<int32_t>({0})
3803 }, { // in12_new
3804 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
3805 .dimensions = {3, 4},
3806 .numberOfConsumers = 1,
3807 .scale = 0.25f,
3808 .zeroPoint = -9,
3809 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3810 .channelQuant = {},
3811 .isIgnored = false,
3812 .data = TestBuffer::createFromVector<int8_t>({39, 43, 47, 51, 55, 59, 63, 67, 71, 75, 79, 83})
3813 }, { // placeholder31
3814 .type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
3815 .dimensions = {1},
3816 .numberOfConsumers = 1,
3817 .scale = 0.25f,
3818 .zeroPoint = -9,
3819 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3820 .channelQuant = {},
3821 .isIgnored = false,
3822 .data = TestBuffer::createFromVector<int8_t>({-9})
3823 }, { // param31
3824 .type = TestOperandType::INT32,
3825 .dimensions = {},
3826 .numberOfConsumers = 1,
3827 .scale = 0.0f,
3828 .zeroPoint = 0,
3829 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3830 .channelQuant = {},
3831 .isIgnored = false,
3832 .data = TestBuffer::createFromVector<int32_t>({0})
3833 }},
3834 .operations = {{
3835 .type = TestOperationType::ADD,
3836 .inputs = {4, 5, 6},
3837 .outputs = {1}
3838 }, {
3839 .type = TestOperationType::ADD,
3840 .inputs = {7, 8, 9},
3841 .outputs = {2}
3842 }, {
3843 .type = TestOperationType::PACK,
3844 .inputs = {0, 1, 2},
3845 .outputs = {3}
3846 }},
3847 .inputIndexes = {4, 7},
3848 .outputIndexes = {3}
3849 },
3850 .referenced = {},
3851 .isRelaxed = false,
3852 .expectedMultinomialDistributionTolerance = 0,
3853 .expectFailure = false,
3854 .minSupportedVersion = TestHalVersion::AIDL_V2
3855 };
3856 return model;
3857 }
3858
3859 const auto dummy_test_model_FLOAT32_binary_axis2_quant8_asymm_signed_all_inputs_as_internal = TestModelManager::get().add("pack_FLOAT32_binary_axis2_quant8_asymm_signed_all_inputs_as_internal", get_test_model_FLOAT32_binary_axis2_quant8_asymm_signed_all_inputs_as_internal());
3860
3861 } // namespace generated_tests::pack
3862
3863 namespace generated_tests::pack {
3864
get_test_model_FLOAT32_binary_axis2_int32()3865 const TestModel& get_test_model_FLOAT32_binary_axis2_int32() {
3866 static TestModel model = {
3867 .main = {
3868 .operands = {{ // axis4
3869 .type = TestOperandType::INT32,
3870 .dimensions = {},
3871 .numberOfConsumers = 1,
3872 .scale = 0.0f,
3873 .zeroPoint = 0,
3874 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3875 .channelQuant = {},
3876 .isIgnored = false,
3877 .data = TestBuffer::createFromVector<int32_t>({2})
3878 }, { // in04
3879 .type = TestOperandType::TENSOR_INT32,
3880 .dimensions = {3, 4},
3881 .numberOfConsumers = 1,
3882 .scale = 0.0f,
3883 .zeroPoint = 0,
3884 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3885 .channelQuant = {},
3886 .isIgnored = false,
3887 .data = TestBuffer::createFromVector<int32_t>({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11})
3888 }, { // in12
3889 .type = TestOperandType::TENSOR_INT32,
3890 .dimensions = {3, 4},
3891 .numberOfConsumers = 1,
3892 .scale = 0.0f,
3893 .zeroPoint = 0,
3894 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3895 .channelQuant = {},
3896 .isIgnored = false,
3897 .data = TestBuffer::createFromVector<int32_t>({12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23})
3898 }, { // out4
3899 .type = TestOperandType::TENSOR_INT32,
3900 .dimensions = {3, 4, 2},
3901 .numberOfConsumers = 0,
3902 .scale = 0.0f,
3903 .zeroPoint = 0,
3904 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3905 .channelQuant = {},
3906 .isIgnored = false,
3907 .data = TestBuffer::createFromVector<int32_t>({0, 12, 1, 13, 2, 14, 3, 15, 4, 16, 5, 17, 6, 18, 7, 19, 8, 20, 9, 21, 10, 22, 11, 23})
3908 }},
3909 .operations = {{
3910 .type = TestOperationType::PACK,
3911 .inputs = {0, 1, 2},
3912 .outputs = {3}
3913 }},
3914 .inputIndexes = {1, 2},
3915 .outputIndexes = {3}
3916 },
3917 .referenced = {},
3918 .isRelaxed = false,
3919 .expectedMultinomialDistributionTolerance = 0,
3920 .expectFailure = false,
3921 .minSupportedVersion = TestHalVersion::AIDL_V2
3922 };
3923 return model;
3924 }
3925
3926 const auto dummy_test_model_FLOAT32_binary_axis2_int32 = TestModelManager::get().add("pack_FLOAT32_binary_axis2_int32", get_test_model_FLOAT32_binary_axis2_int32());
3927
3928 } // namespace generated_tests::pack
3929
3930