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