1 // Generated from resize_bilinear_v1_2.mod.py
2 // DO NOT EDIT
3 // clang-format off
4 #include "TestHarness.h"
5 using namespace test_helper;
6
7 namespace generated_tests::resize_bilinear_v1_2 {
8
get_test_model_shape_nhwc()9 const TestModel& get_test_model_shape_nhwc() {
10 static TestModel model = {
11 .expectFailure = false,
12 .expectedMultinomialDistributionTolerance = 0,
13 .isRelaxed = false,
14 .main = { // shape
15 .inputIndexes = {0},
16 .operands = {{ // op1
17 .channelQuant = {},
18 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
19 .dimensions = {1, 2, 2, 1},
20 .isIgnored = false,
21 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22 .numberOfConsumers = 1,
23 .scale = 0.0f,
24 .type = TestOperandType::TENSOR_FLOAT32,
25 .zeroPoint = 0
26 }, { // param
27 .channelQuant = {},
28 .data = TestBuffer::createFromVector<int32_t>({3}),
29 .dimensions = {},
30 .isIgnored = false,
31 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
32 .numberOfConsumers = 1,
33 .scale = 0.0f,
34 .type = TestOperandType::INT32,
35 .zeroPoint = 0
36 }, { // param1
37 .channelQuant = {},
38 .data = TestBuffer::createFromVector<int32_t>({3}),
39 .dimensions = {},
40 .isIgnored = false,
41 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
42 .numberOfConsumers = 1,
43 .scale = 0.0f,
44 .type = TestOperandType::INT32,
45 .zeroPoint = 0
46 }, { // layout
47 .channelQuant = {},
48 .data = TestBuffer::createFromVector<bool8>({false}),
49 .dimensions = {},
50 .isIgnored = false,
51 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
52 .numberOfConsumers = 1,
53 .scale = 0.0f,
54 .type = TestOperandType::BOOL,
55 .zeroPoint = 0
56 }, { // op4
57 .channelQuant = {},
58 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
59 .dimensions = {1, 3, 3, 1},
60 .isIgnored = false,
61 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
62 .numberOfConsumers = 0,
63 .scale = 0.0f,
64 .type = TestOperandType::TENSOR_FLOAT32,
65 .zeroPoint = 0
66 }},
67 .operations = {{
68 .inputs = {0, 1, 2, 3},
69 .outputs = {4},
70 .type = TestOperationType::RESIZE_BILINEAR
71 }},
72 .outputIndexes = {4}
73 },
74 .minSupportedVersion = TestHalVersion::V1_0,
75 .referenced = {}
76 };
77 return model;
78 }
79
80 const auto dummy_test_model_shape_nhwc = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc", get_test_model_shape_nhwc());
81
82 } // namespace generated_tests::resize_bilinear_v1_2
83
84 namespace generated_tests::resize_bilinear_v1_2 {
85
get_test_model_shape_nhwc_all_inputs_as_internal()86 const TestModel& get_test_model_shape_nhwc_all_inputs_as_internal() {
87 static TestModel model = {
88 .expectFailure = false,
89 .expectedMultinomialDistributionTolerance = 0,
90 .isRelaxed = false,
91 .main = { // shape
92 .inputIndexes = {5},
93 .operands = {{ // op1
94 .channelQuant = {},
95 .data = TestBuffer::createFromVector<float>({}),
96 .dimensions = {1, 2, 2, 1},
97 .isIgnored = false,
98 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
99 .numberOfConsumers = 1,
100 .scale = 0.0f,
101 .type = TestOperandType::TENSOR_FLOAT32,
102 .zeroPoint = 0
103 }, { // param
104 .channelQuant = {},
105 .data = TestBuffer::createFromVector<int32_t>({3}),
106 .dimensions = {},
107 .isIgnored = false,
108 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
109 .numberOfConsumers = 1,
110 .scale = 0.0f,
111 .type = TestOperandType::INT32,
112 .zeroPoint = 0
113 }, { // param1
114 .channelQuant = {},
115 .data = TestBuffer::createFromVector<int32_t>({3}),
116 .dimensions = {},
117 .isIgnored = false,
118 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
119 .numberOfConsumers = 1,
120 .scale = 0.0f,
121 .type = TestOperandType::INT32,
122 .zeroPoint = 0
123 }, { // layout
124 .channelQuant = {},
125 .data = TestBuffer::createFromVector<bool8>({false}),
126 .dimensions = {},
127 .isIgnored = false,
128 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
129 .numberOfConsumers = 1,
130 .scale = 0.0f,
131 .type = TestOperandType::BOOL,
132 .zeroPoint = 0
133 }, { // op4
134 .channelQuant = {},
135 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
136 .dimensions = {1, 3, 3, 1},
137 .isIgnored = false,
138 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
139 .numberOfConsumers = 0,
140 .scale = 0.0f,
141 .type = TestOperandType::TENSOR_FLOAT32,
142 .zeroPoint = 0
143 }, { // op1_new
144 .channelQuant = {},
145 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
146 .dimensions = {1, 2, 2, 1},
147 .isIgnored = false,
148 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
149 .numberOfConsumers = 1,
150 .scale = 0.0f,
151 .type = TestOperandType::TENSOR_FLOAT32,
152 .zeroPoint = 0
153 }, { // dummy
154 .channelQuant = {},
155 .data = TestBuffer::createFromVector<float>({0.0f}),
156 .dimensions = {1},
157 .isIgnored = false,
158 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
159 .numberOfConsumers = 1,
160 .scale = 0.0f,
161 .type = TestOperandType::TENSOR_FLOAT32,
162 .zeroPoint = 0
163 }, { // param42
164 .channelQuant = {},
165 .data = TestBuffer::createFromVector<int32_t>({0}),
166 .dimensions = {},
167 .isIgnored = false,
168 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
169 .numberOfConsumers = 1,
170 .scale = 0.0f,
171 .type = TestOperandType::INT32,
172 .zeroPoint = 0
173 }},
174 .operations = {{
175 .inputs = {5, 6, 7},
176 .outputs = {0},
177 .type = TestOperationType::ADD
178 }, {
179 .inputs = {0, 1, 2, 3},
180 .outputs = {4},
181 .type = TestOperationType::RESIZE_BILINEAR
182 }},
183 .outputIndexes = {4}
184 },
185 .minSupportedVersion = TestHalVersion::V1_0,
186 .referenced = {}
187 };
188 return model;
189 }
190
191 const auto dummy_test_model_shape_nhwc_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_all_inputs_as_internal", get_test_model_shape_nhwc_all_inputs_as_internal());
192
193 } // namespace generated_tests::resize_bilinear_v1_2
194
195 namespace generated_tests::resize_bilinear_v1_2 {
196
get_test_model_shape_nhwc_relaxed()197 const TestModel& get_test_model_shape_nhwc_relaxed() {
198 static TestModel model = {
199 .expectFailure = false,
200 .expectedMultinomialDistributionTolerance = 0,
201 .isRelaxed = true,
202 .main = { // shape
203 .inputIndexes = {0},
204 .operands = {{ // op1
205 .channelQuant = {},
206 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
207 .dimensions = {1, 2, 2, 1},
208 .isIgnored = false,
209 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
210 .numberOfConsumers = 1,
211 .scale = 0.0f,
212 .type = TestOperandType::TENSOR_FLOAT32,
213 .zeroPoint = 0
214 }, { // param
215 .channelQuant = {},
216 .data = TestBuffer::createFromVector<int32_t>({3}),
217 .dimensions = {},
218 .isIgnored = false,
219 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
220 .numberOfConsumers = 1,
221 .scale = 0.0f,
222 .type = TestOperandType::INT32,
223 .zeroPoint = 0
224 }, { // param1
225 .channelQuant = {},
226 .data = TestBuffer::createFromVector<int32_t>({3}),
227 .dimensions = {},
228 .isIgnored = false,
229 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
230 .numberOfConsumers = 1,
231 .scale = 0.0f,
232 .type = TestOperandType::INT32,
233 .zeroPoint = 0
234 }, { // layout
235 .channelQuant = {},
236 .data = TestBuffer::createFromVector<bool8>({false}),
237 .dimensions = {},
238 .isIgnored = false,
239 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
240 .numberOfConsumers = 1,
241 .scale = 0.0f,
242 .type = TestOperandType::BOOL,
243 .zeroPoint = 0
244 }, { // op4
245 .channelQuant = {},
246 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
247 .dimensions = {1, 3, 3, 1},
248 .isIgnored = false,
249 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
250 .numberOfConsumers = 0,
251 .scale = 0.0f,
252 .type = TestOperandType::TENSOR_FLOAT32,
253 .zeroPoint = 0
254 }},
255 .operations = {{
256 .inputs = {0, 1, 2, 3},
257 .outputs = {4},
258 .type = TestOperationType::RESIZE_BILINEAR
259 }},
260 .outputIndexes = {4}
261 },
262 .minSupportedVersion = TestHalVersion::UNKNOWN,
263 .referenced = {}
264 };
265 return model;
266 }
267
268 const auto dummy_test_model_shape_nhwc_relaxed = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_relaxed", get_test_model_shape_nhwc_relaxed());
269
270 } // namespace generated_tests::resize_bilinear_v1_2
271
272 namespace generated_tests::resize_bilinear_v1_2 {
273
get_test_model_shape_nhwc_relaxed_all_inputs_as_internal()274 const TestModel& get_test_model_shape_nhwc_relaxed_all_inputs_as_internal() {
275 static TestModel model = {
276 .expectFailure = false,
277 .expectedMultinomialDistributionTolerance = 0,
278 .isRelaxed = true,
279 .main = { // shape
280 .inputIndexes = {5},
281 .operands = {{ // op1
282 .channelQuant = {},
283 .data = TestBuffer::createFromVector<float>({}),
284 .dimensions = {1, 2, 2, 1},
285 .isIgnored = false,
286 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
287 .numberOfConsumers = 1,
288 .scale = 0.0f,
289 .type = TestOperandType::TENSOR_FLOAT32,
290 .zeroPoint = 0
291 }, { // param
292 .channelQuant = {},
293 .data = TestBuffer::createFromVector<int32_t>({3}),
294 .dimensions = {},
295 .isIgnored = false,
296 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
297 .numberOfConsumers = 1,
298 .scale = 0.0f,
299 .type = TestOperandType::INT32,
300 .zeroPoint = 0
301 }, { // param1
302 .channelQuant = {},
303 .data = TestBuffer::createFromVector<int32_t>({3}),
304 .dimensions = {},
305 .isIgnored = false,
306 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
307 .numberOfConsumers = 1,
308 .scale = 0.0f,
309 .type = TestOperandType::INT32,
310 .zeroPoint = 0
311 }, { // layout
312 .channelQuant = {},
313 .data = TestBuffer::createFromVector<bool8>({false}),
314 .dimensions = {},
315 .isIgnored = false,
316 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
317 .numberOfConsumers = 1,
318 .scale = 0.0f,
319 .type = TestOperandType::BOOL,
320 .zeroPoint = 0
321 }, { // op4
322 .channelQuant = {},
323 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
324 .dimensions = {1, 3, 3, 1},
325 .isIgnored = false,
326 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
327 .numberOfConsumers = 0,
328 .scale = 0.0f,
329 .type = TestOperandType::TENSOR_FLOAT32,
330 .zeroPoint = 0
331 }, { // op1_new
332 .channelQuant = {},
333 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
334 .dimensions = {1, 2, 2, 1},
335 .isIgnored = false,
336 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
337 .numberOfConsumers = 1,
338 .scale = 0.0f,
339 .type = TestOperandType::TENSOR_FLOAT32,
340 .zeroPoint = 0
341 }, { // dummy1
342 .channelQuant = {},
343 .data = TestBuffer::createFromVector<float>({0.0f}),
344 .dimensions = {1},
345 .isIgnored = false,
346 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
347 .numberOfConsumers = 1,
348 .scale = 0.0f,
349 .type = TestOperandType::TENSOR_FLOAT32,
350 .zeroPoint = 0
351 }, { // param43
352 .channelQuant = {},
353 .data = TestBuffer::createFromVector<int32_t>({0}),
354 .dimensions = {},
355 .isIgnored = false,
356 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
357 .numberOfConsumers = 1,
358 .scale = 0.0f,
359 .type = TestOperandType::INT32,
360 .zeroPoint = 0
361 }},
362 .operations = {{
363 .inputs = {5, 6, 7},
364 .outputs = {0},
365 .type = TestOperationType::ADD
366 }, {
367 .inputs = {0, 1, 2, 3},
368 .outputs = {4},
369 .type = TestOperationType::RESIZE_BILINEAR
370 }},
371 .outputIndexes = {4}
372 },
373 .minSupportedVersion = TestHalVersion::UNKNOWN,
374 .referenced = {}
375 };
376 return model;
377 }
378
379 const auto dummy_test_model_shape_nhwc_relaxed_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_relaxed_all_inputs_as_internal", get_test_model_shape_nhwc_relaxed_all_inputs_as_internal());
380
381 } // namespace generated_tests::resize_bilinear_v1_2
382
383 namespace generated_tests::resize_bilinear_v1_2 {
384
get_test_model_shape_nhwc_float16()385 const TestModel& get_test_model_shape_nhwc_float16() {
386 static TestModel model = {
387 .expectFailure = false,
388 .expectedMultinomialDistributionTolerance = 0,
389 .isRelaxed = false,
390 .main = { // shape
391 .inputIndexes = {0},
392 .operands = {{ // op1
393 .channelQuant = {},
394 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 2.0f, 2.0f}),
395 .dimensions = {1, 2, 2, 1},
396 .isIgnored = false,
397 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
398 .numberOfConsumers = 1,
399 .scale = 0.0f,
400 .type = TestOperandType::TENSOR_FLOAT16,
401 .zeroPoint = 0
402 }, { // param
403 .channelQuant = {},
404 .data = TestBuffer::createFromVector<int32_t>({3}),
405 .dimensions = {},
406 .isIgnored = false,
407 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
408 .numberOfConsumers = 1,
409 .scale = 0.0f,
410 .type = TestOperandType::INT32,
411 .zeroPoint = 0
412 }, { // param1
413 .channelQuant = {},
414 .data = TestBuffer::createFromVector<int32_t>({3}),
415 .dimensions = {},
416 .isIgnored = false,
417 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
418 .numberOfConsumers = 1,
419 .scale = 0.0f,
420 .type = TestOperandType::INT32,
421 .zeroPoint = 0
422 }, { // layout
423 .channelQuant = {},
424 .data = TestBuffer::createFromVector<bool8>({false}),
425 .dimensions = {},
426 .isIgnored = false,
427 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
428 .numberOfConsumers = 1,
429 .scale = 0.0f,
430 .type = TestOperandType::BOOL,
431 .zeroPoint = 0
432 }, { // op4
433 .channelQuant = {},
434 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 1.0f, 1.6666666269302368f, 1.6666666269302368f, 1.6666666269302368f, 2.0f, 2.0f, 2.0f}),
435 .dimensions = {1, 3, 3, 1},
436 .isIgnored = false,
437 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
438 .numberOfConsumers = 0,
439 .scale = 0.0f,
440 .type = TestOperandType::TENSOR_FLOAT16,
441 .zeroPoint = 0
442 }},
443 .operations = {{
444 .inputs = {0, 1, 2, 3},
445 .outputs = {4},
446 .type = TestOperationType::RESIZE_BILINEAR
447 }},
448 .outputIndexes = {4}
449 },
450 .minSupportedVersion = TestHalVersion::V1_2,
451 .referenced = {}
452 };
453 return model;
454 }
455
456 const auto dummy_test_model_shape_nhwc_float16 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_float16", get_test_model_shape_nhwc_float16());
457
458 } // namespace generated_tests::resize_bilinear_v1_2
459
460 namespace generated_tests::resize_bilinear_v1_2 {
461
get_test_model_shape_nhwc_float16_all_inputs_as_internal()462 const TestModel& get_test_model_shape_nhwc_float16_all_inputs_as_internal() {
463 static TestModel model = {
464 .expectFailure = false,
465 .expectedMultinomialDistributionTolerance = 0,
466 .isRelaxed = false,
467 .main = { // shape
468 .inputIndexes = {5},
469 .operands = {{ // op1
470 .channelQuant = {},
471 .data = TestBuffer::createFromVector<_Float16>({}),
472 .dimensions = {1, 2, 2, 1},
473 .isIgnored = false,
474 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
475 .numberOfConsumers = 1,
476 .scale = 0.0f,
477 .type = TestOperandType::TENSOR_FLOAT16,
478 .zeroPoint = 0
479 }, { // param
480 .channelQuant = {},
481 .data = TestBuffer::createFromVector<int32_t>({3}),
482 .dimensions = {},
483 .isIgnored = false,
484 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
485 .numberOfConsumers = 1,
486 .scale = 0.0f,
487 .type = TestOperandType::INT32,
488 .zeroPoint = 0
489 }, { // param1
490 .channelQuant = {},
491 .data = TestBuffer::createFromVector<int32_t>({3}),
492 .dimensions = {},
493 .isIgnored = false,
494 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
495 .numberOfConsumers = 1,
496 .scale = 0.0f,
497 .type = TestOperandType::INT32,
498 .zeroPoint = 0
499 }, { // layout
500 .channelQuant = {},
501 .data = TestBuffer::createFromVector<bool8>({false}),
502 .dimensions = {},
503 .isIgnored = false,
504 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
505 .numberOfConsumers = 1,
506 .scale = 0.0f,
507 .type = TestOperandType::BOOL,
508 .zeroPoint = 0
509 }, { // op4
510 .channelQuant = {},
511 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 1.0f, 1.6666666269302368f, 1.6666666269302368f, 1.6666666269302368f, 2.0f, 2.0f, 2.0f}),
512 .dimensions = {1, 3, 3, 1},
513 .isIgnored = false,
514 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
515 .numberOfConsumers = 0,
516 .scale = 0.0f,
517 .type = TestOperandType::TENSOR_FLOAT16,
518 .zeroPoint = 0
519 }, { // op1_new
520 .channelQuant = {},
521 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 2.0f, 2.0f}),
522 .dimensions = {1, 2, 2, 1},
523 .isIgnored = false,
524 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
525 .numberOfConsumers = 1,
526 .scale = 0.0f,
527 .type = TestOperandType::TENSOR_FLOAT16,
528 .zeroPoint = 0
529 }, { // dummy2
530 .channelQuant = {},
531 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
532 .dimensions = {1},
533 .isIgnored = false,
534 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
535 .numberOfConsumers = 1,
536 .scale = 0.0f,
537 .type = TestOperandType::TENSOR_FLOAT16,
538 .zeroPoint = 0
539 }, { // param44
540 .channelQuant = {},
541 .data = TestBuffer::createFromVector<int32_t>({0}),
542 .dimensions = {},
543 .isIgnored = false,
544 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
545 .numberOfConsumers = 1,
546 .scale = 0.0f,
547 .type = TestOperandType::INT32,
548 .zeroPoint = 0
549 }},
550 .operations = {{
551 .inputs = {5, 6, 7},
552 .outputs = {0},
553 .type = TestOperationType::ADD
554 }, {
555 .inputs = {0, 1, 2, 3},
556 .outputs = {4},
557 .type = TestOperationType::RESIZE_BILINEAR
558 }},
559 .outputIndexes = {4}
560 },
561 .minSupportedVersion = TestHalVersion::V1_2,
562 .referenced = {}
563 };
564 return model;
565 }
566
567 const auto dummy_test_model_shape_nhwc_float16_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_float16_all_inputs_as_internal", get_test_model_shape_nhwc_float16_all_inputs_as_internal());
568
569 } // namespace generated_tests::resize_bilinear_v1_2
570
571 namespace generated_tests::resize_bilinear_v1_2 {
572
get_test_model_shape_nhwc_quant8()573 const TestModel& get_test_model_shape_nhwc_quant8() {
574 static TestModel model = {
575 .expectFailure = false,
576 .expectedMultinomialDistributionTolerance = 0,
577 .isRelaxed = false,
578 .main = { // shape
579 .inputIndexes = {0},
580 .operands = {{ // op1
581 .channelQuant = {},
582 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 200, 200}),
583 .dimensions = {1, 2, 2, 1},
584 .isIgnored = false,
585 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
586 .numberOfConsumers = 1,
587 .scale = 0.01f,
588 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
589 .zeroPoint = 0
590 }, { // param
591 .channelQuant = {},
592 .data = TestBuffer::createFromVector<int32_t>({3}),
593 .dimensions = {},
594 .isIgnored = false,
595 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
596 .numberOfConsumers = 1,
597 .scale = 0.0f,
598 .type = TestOperandType::INT32,
599 .zeroPoint = 0
600 }, { // param1
601 .channelQuant = {},
602 .data = TestBuffer::createFromVector<int32_t>({3}),
603 .dimensions = {},
604 .isIgnored = false,
605 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
606 .numberOfConsumers = 1,
607 .scale = 0.0f,
608 .type = TestOperandType::INT32,
609 .zeroPoint = 0
610 }, { // layout
611 .channelQuant = {},
612 .data = TestBuffer::createFromVector<bool8>({false}),
613 .dimensions = {},
614 .isIgnored = false,
615 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
616 .numberOfConsumers = 1,
617 .scale = 0.0f,
618 .type = TestOperandType::BOOL,
619 .zeroPoint = 0
620 }, { // op4
621 .channelQuant = {},
622 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 100, 167, 167, 167, 200, 200, 200}),
623 .dimensions = {1, 3, 3, 1},
624 .isIgnored = false,
625 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
626 .numberOfConsumers = 0,
627 .scale = 0.01f,
628 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
629 .zeroPoint = 0
630 }},
631 .operations = {{
632 .inputs = {0, 1, 2, 3},
633 .outputs = {4},
634 .type = TestOperationType::RESIZE_BILINEAR
635 }},
636 .outputIndexes = {4}
637 },
638 .minSupportedVersion = TestHalVersion::V1_2,
639 .referenced = {}
640 };
641 return model;
642 }
643
644 const auto dummy_test_model_shape_nhwc_quant8 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_quant8", get_test_model_shape_nhwc_quant8());
645
646 } // namespace generated_tests::resize_bilinear_v1_2
647
648 namespace generated_tests::resize_bilinear_v1_2 {
649
get_test_model_shape_nhwc_quant8_all_inputs_as_internal()650 const TestModel& get_test_model_shape_nhwc_quant8_all_inputs_as_internal() {
651 static TestModel model = {
652 .expectFailure = false,
653 .expectedMultinomialDistributionTolerance = 0,
654 .isRelaxed = false,
655 .main = { // shape
656 .inputIndexes = {5},
657 .operands = {{ // op1
658 .channelQuant = {},
659 .data = TestBuffer::createFromVector<uint8_t>({}),
660 .dimensions = {1, 2, 2, 1},
661 .isIgnored = false,
662 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
663 .numberOfConsumers = 1,
664 .scale = 0.01f,
665 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
666 .zeroPoint = 0
667 }, { // param
668 .channelQuant = {},
669 .data = TestBuffer::createFromVector<int32_t>({3}),
670 .dimensions = {},
671 .isIgnored = false,
672 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
673 .numberOfConsumers = 1,
674 .scale = 0.0f,
675 .type = TestOperandType::INT32,
676 .zeroPoint = 0
677 }, { // param1
678 .channelQuant = {},
679 .data = TestBuffer::createFromVector<int32_t>({3}),
680 .dimensions = {},
681 .isIgnored = false,
682 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
683 .numberOfConsumers = 1,
684 .scale = 0.0f,
685 .type = TestOperandType::INT32,
686 .zeroPoint = 0
687 }, { // layout
688 .channelQuant = {},
689 .data = TestBuffer::createFromVector<bool8>({false}),
690 .dimensions = {},
691 .isIgnored = false,
692 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
693 .numberOfConsumers = 1,
694 .scale = 0.0f,
695 .type = TestOperandType::BOOL,
696 .zeroPoint = 0
697 }, { // op4
698 .channelQuant = {},
699 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 100, 167, 167, 167, 200, 200, 200}),
700 .dimensions = {1, 3, 3, 1},
701 .isIgnored = false,
702 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
703 .numberOfConsumers = 0,
704 .scale = 0.01f,
705 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
706 .zeroPoint = 0
707 }, { // op1_new
708 .channelQuant = {},
709 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 200, 200}),
710 .dimensions = {1, 2, 2, 1},
711 .isIgnored = false,
712 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
713 .numberOfConsumers = 1,
714 .scale = 0.01f,
715 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
716 .zeroPoint = 0
717 }, { // dummy3
718 .channelQuant = {},
719 .data = TestBuffer::createFromVector<uint8_t>({0}),
720 .dimensions = {1},
721 .isIgnored = false,
722 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
723 .numberOfConsumers = 1,
724 .scale = 0.01f,
725 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
726 .zeroPoint = 0
727 }, { // param45
728 .channelQuant = {},
729 .data = TestBuffer::createFromVector<int32_t>({0}),
730 .dimensions = {},
731 .isIgnored = false,
732 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
733 .numberOfConsumers = 1,
734 .scale = 0.0f,
735 .type = TestOperandType::INT32,
736 .zeroPoint = 0
737 }},
738 .operations = {{
739 .inputs = {5, 6, 7},
740 .outputs = {0},
741 .type = TestOperationType::ADD
742 }, {
743 .inputs = {0, 1, 2, 3},
744 .outputs = {4},
745 .type = TestOperationType::RESIZE_BILINEAR
746 }},
747 .outputIndexes = {4}
748 },
749 .minSupportedVersion = TestHalVersion::V1_2,
750 .referenced = {}
751 };
752 return model;
753 }
754
755 const auto dummy_test_model_shape_nhwc_quant8_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_quant8_all_inputs_as_internal", get_test_model_shape_nhwc_quant8_all_inputs_as_internal());
756
757 } // namespace generated_tests::resize_bilinear_v1_2
758
759 namespace generated_tests::resize_bilinear_v1_2 {
760
get_test_model_shape_nchw()761 const TestModel& get_test_model_shape_nchw() {
762 static TestModel model = {
763 .expectFailure = false,
764 .expectedMultinomialDistributionTolerance = 0,
765 .isRelaxed = false,
766 .main = { // shape
767 .inputIndexes = {0},
768 .operands = {{ // op1
769 .channelQuant = {},
770 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
771 .dimensions = {1, 1, 2, 2},
772 .isIgnored = false,
773 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
774 .numberOfConsumers = 1,
775 .scale = 0.0f,
776 .type = TestOperandType::TENSOR_FLOAT32,
777 .zeroPoint = 0
778 }, { // param
779 .channelQuant = {},
780 .data = TestBuffer::createFromVector<int32_t>({3}),
781 .dimensions = {},
782 .isIgnored = false,
783 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
784 .numberOfConsumers = 1,
785 .scale = 0.0f,
786 .type = TestOperandType::INT32,
787 .zeroPoint = 0
788 }, { // param1
789 .channelQuant = {},
790 .data = TestBuffer::createFromVector<int32_t>({3}),
791 .dimensions = {},
792 .isIgnored = false,
793 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
794 .numberOfConsumers = 1,
795 .scale = 0.0f,
796 .type = TestOperandType::INT32,
797 .zeroPoint = 0
798 }, { // layout
799 .channelQuant = {},
800 .data = TestBuffer::createFromVector<bool8>({true}),
801 .dimensions = {},
802 .isIgnored = false,
803 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
804 .numberOfConsumers = 1,
805 .scale = 0.0f,
806 .type = TestOperandType::BOOL,
807 .zeroPoint = 0
808 }, { // op4
809 .channelQuant = {},
810 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
811 .dimensions = {1, 1, 3, 3},
812 .isIgnored = false,
813 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
814 .numberOfConsumers = 0,
815 .scale = 0.0f,
816 .type = TestOperandType::TENSOR_FLOAT32,
817 .zeroPoint = 0
818 }},
819 .operations = {{
820 .inputs = {0, 1, 2, 3},
821 .outputs = {4},
822 .type = TestOperationType::RESIZE_BILINEAR
823 }},
824 .outputIndexes = {4}
825 },
826 .minSupportedVersion = TestHalVersion::V1_2,
827 .referenced = {}
828 };
829 return model;
830 }
831
832 const auto dummy_test_model_shape_nchw = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw", get_test_model_shape_nchw());
833
834 } // namespace generated_tests::resize_bilinear_v1_2
835
836 namespace generated_tests::resize_bilinear_v1_2 {
837
get_test_model_shape_nchw_all_inputs_as_internal()838 const TestModel& get_test_model_shape_nchw_all_inputs_as_internal() {
839 static TestModel model = {
840 .expectFailure = false,
841 .expectedMultinomialDistributionTolerance = 0,
842 .isRelaxed = false,
843 .main = { // shape
844 .inputIndexes = {5},
845 .operands = {{ // op1
846 .channelQuant = {},
847 .data = TestBuffer::createFromVector<float>({}),
848 .dimensions = {1, 1, 2, 2},
849 .isIgnored = false,
850 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
851 .numberOfConsumers = 1,
852 .scale = 0.0f,
853 .type = TestOperandType::TENSOR_FLOAT32,
854 .zeroPoint = 0
855 }, { // param
856 .channelQuant = {},
857 .data = TestBuffer::createFromVector<int32_t>({3}),
858 .dimensions = {},
859 .isIgnored = false,
860 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
861 .numberOfConsumers = 1,
862 .scale = 0.0f,
863 .type = TestOperandType::INT32,
864 .zeroPoint = 0
865 }, { // param1
866 .channelQuant = {},
867 .data = TestBuffer::createFromVector<int32_t>({3}),
868 .dimensions = {},
869 .isIgnored = false,
870 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
871 .numberOfConsumers = 1,
872 .scale = 0.0f,
873 .type = TestOperandType::INT32,
874 .zeroPoint = 0
875 }, { // layout
876 .channelQuant = {},
877 .data = TestBuffer::createFromVector<bool8>({true}),
878 .dimensions = {},
879 .isIgnored = false,
880 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
881 .numberOfConsumers = 1,
882 .scale = 0.0f,
883 .type = TestOperandType::BOOL,
884 .zeroPoint = 0
885 }, { // op4
886 .channelQuant = {},
887 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
888 .dimensions = {1, 1, 3, 3},
889 .isIgnored = false,
890 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
891 .numberOfConsumers = 0,
892 .scale = 0.0f,
893 .type = TestOperandType::TENSOR_FLOAT32,
894 .zeroPoint = 0
895 }, { // op1_new
896 .channelQuant = {},
897 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
898 .dimensions = {1, 1, 2, 2},
899 .isIgnored = false,
900 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
901 .numberOfConsumers = 1,
902 .scale = 0.0f,
903 .type = TestOperandType::TENSOR_FLOAT32,
904 .zeroPoint = 0
905 }, { // dummy4
906 .channelQuant = {},
907 .data = TestBuffer::createFromVector<float>({0.0f}),
908 .dimensions = {1},
909 .isIgnored = false,
910 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
911 .numberOfConsumers = 1,
912 .scale = 0.0f,
913 .type = TestOperandType::TENSOR_FLOAT32,
914 .zeroPoint = 0
915 }, { // param46
916 .channelQuant = {},
917 .data = TestBuffer::createFromVector<int32_t>({0}),
918 .dimensions = {},
919 .isIgnored = false,
920 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
921 .numberOfConsumers = 1,
922 .scale = 0.0f,
923 .type = TestOperandType::INT32,
924 .zeroPoint = 0
925 }},
926 .operations = {{
927 .inputs = {5, 6, 7},
928 .outputs = {0},
929 .type = TestOperationType::ADD
930 }, {
931 .inputs = {0, 1, 2, 3},
932 .outputs = {4},
933 .type = TestOperationType::RESIZE_BILINEAR
934 }},
935 .outputIndexes = {4}
936 },
937 .minSupportedVersion = TestHalVersion::V1_2,
938 .referenced = {}
939 };
940 return model;
941 }
942
943 const auto dummy_test_model_shape_nchw_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_all_inputs_as_internal", get_test_model_shape_nchw_all_inputs_as_internal());
944
945 } // namespace generated_tests::resize_bilinear_v1_2
946
947 namespace generated_tests::resize_bilinear_v1_2 {
948
get_test_model_shape_nchw_relaxed()949 const TestModel& get_test_model_shape_nchw_relaxed() {
950 static TestModel model = {
951 .expectFailure = false,
952 .expectedMultinomialDistributionTolerance = 0,
953 .isRelaxed = true,
954 .main = { // shape
955 .inputIndexes = {0},
956 .operands = {{ // op1
957 .channelQuant = {},
958 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
959 .dimensions = {1, 1, 2, 2},
960 .isIgnored = false,
961 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
962 .numberOfConsumers = 1,
963 .scale = 0.0f,
964 .type = TestOperandType::TENSOR_FLOAT32,
965 .zeroPoint = 0
966 }, { // param
967 .channelQuant = {},
968 .data = TestBuffer::createFromVector<int32_t>({3}),
969 .dimensions = {},
970 .isIgnored = false,
971 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
972 .numberOfConsumers = 1,
973 .scale = 0.0f,
974 .type = TestOperandType::INT32,
975 .zeroPoint = 0
976 }, { // param1
977 .channelQuant = {},
978 .data = TestBuffer::createFromVector<int32_t>({3}),
979 .dimensions = {},
980 .isIgnored = false,
981 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
982 .numberOfConsumers = 1,
983 .scale = 0.0f,
984 .type = TestOperandType::INT32,
985 .zeroPoint = 0
986 }, { // layout
987 .channelQuant = {},
988 .data = TestBuffer::createFromVector<bool8>({true}),
989 .dimensions = {},
990 .isIgnored = false,
991 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
992 .numberOfConsumers = 1,
993 .scale = 0.0f,
994 .type = TestOperandType::BOOL,
995 .zeroPoint = 0
996 }, { // op4
997 .channelQuant = {},
998 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
999 .dimensions = {1, 1, 3, 3},
1000 .isIgnored = false,
1001 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1002 .numberOfConsumers = 0,
1003 .scale = 0.0f,
1004 .type = TestOperandType::TENSOR_FLOAT32,
1005 .zeroPoint = 0
1006 }},
1007 .operations = {{
1008 .inputs = {0, 1, 2, 3},
1009 .outputs = {4},
1010 .type = TestOperationType::RESIZE_BILINEAR
1011 }},
1012 .outputIndexes = {4}
1013 },
1014 .minSupportedVersion = TestHalVersion::UNKNOWN,
1015 .referenced = {}
1016 };
1017 return model;
1018 }
1019
1020 const auto dummy_test_model_shape_nchw_relaxed = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_relaxed", get_test_model_shape_nchw_relaxed());
1021
1022 } // namespace generated_tests::resize_bilinear_v1_2
1023
1024 namespace generated_tests::resize_bilinear_v1_2 {
1025
get_test_model_shape_nchw_relaxed_all_inputs_as_internal()1026 const TestModel& get_test_model_shape_nchw_relaxed_all_inputs_as_internal() {
1027 static TestModel model = {
1028 .expectFailure = false,
1029 .expectedMultinomialDistributionTolerance = 0,
1030 .isRelaxed = true,
1031 .main = { // shape
1032 .inputIndexes = {5},
1033 .operands = {{ // op1
1034 .channelQuant = {},
1035 .data = TestBuffer::createFromVector<float>({}),
1036 .dimensions = {1, 1, 2, 2},
1037 .isIgnored = false,
1038 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1039 .numberOfConsumers = 1,
1040 .scale = 0.0f,
1041 .type = TestOperandType::TENSOR_FLOAT32,
1042 .zeroPoint = 0
1043 }, { // param
1044 .channelQuant = {},
1045 .data = TestBuffer::createFromVector<int32_t>({3}),
1046 .dimensions = {},
1047 .isIgnored = false,
1048 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1049 .numberOfConsumers = 1,
1050 .scale = 0.0f,
1051 .type = TestOperandType::INT32,
1052 .zeroPoint = 0
1053 }, { // param1
1054 .channelQuant = {},
1055 .data = TestBuffer::createFromVector<int32_t>({3}),
1056 .dimensions = {},
1057 .isIgnored = false,
1058 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1059 .numberOfConsumers = 1,
1060 .scale = 0.0f,
1061 .type = TestOperandType::INT32,
1062 .zeroPoint = 0
1063 }, { // layout
1064 .channelQuant = {},
1065 .data = TestBuffer::createFromVector<bool8>({true}),
1066 .dimensions = {},
1067 .isIgnored = false,
1068 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1069 .numberOfConsumers = 1,
1070 .scale = 0.0f,
1071 .type = TestOperandType::BOOL,
1072 .zeroPoint = 0
1073 }, { // op4
1074 .channelQuant = {},
1075 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
1076 .dimensions = {1, 1, 3, 3},
1077 .isIgnored = false,
1078 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1079 .numberOfConsumers = 0,
1080 .scale = 0.0f,
1081 .type = TestOperandType::TENSOR_FLOAT32,
1082 .zeroPoint = 0
1083 }, { // op1_new
1084 .channelQuant = {},
1085 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
1086 .dimensions = {1, 1, 2, 2},
1087 .isIgnored = false,
1088 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1089 .numberOfConsumers = 1,
1090 .scale = 0.0f,
1091 .type = TestOperandType::TENSOR_FLOAT32,
1092 .zeroPoint = 0
1093 }, { // dummy5
1094 .channelQuant = {},
1095 .data = TestBuffer::createFromVector<float>({0.0f}),
1096 .dimensions = {1},
1097 .isIgnored = false,
1098 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1099 .numberOfConsumers = 1,
1100 .scale = 0.0f,
1101 .type = TestOperandType::TENSOR_FLOAT32,
1102 .zeroPoint = 0
1103 }, { // param47
1104 .channelQuant = {},
1105 .data = TestBuffer::createFromVector<int32_t>({0}),
1106 .dimensions = {},
1107 .isIgnored = false,
1108 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1109 .numberOfConsumers = 1,
1110 .scale = 0.0f,
1111 .type = TestOperandType::INT32,
1112 .zeroPoint = 0
1113 }},
1114 .operations = {{
1115 .inputs = {5, 6, 7},
1116 .outputs = {0},
1117 .type = TestOperationType::ADD
1118 }, {
1119 .inputs = {0, 1, 2, 3},
1120 .outputs = {4},
1121 .type = TestOperationType::RESIZE_BILINEAR
1122 }},
1123 .outputIndexes = {4}
1124 },
1125 .minSupportedVersion = TestHalVersion::UNKNOWN,
1126 .referenced = {}
1127 };
1128 return model;
1129 }
1130
1131 const auto dummy_test_model_shape_nchw_relaxed_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_relaxed_all_inputs_as_internal", get_test_model_shape_nchw_relaxed_all_inputs_as_internal());
1132
1133 } // namespace generated_tests::resize_bilinear_v1_2
1134
1135 namespace generated_tests::resize_bilinear_v1_2 {
1136
get_test_model_shape_nchw_float16()1137 const TestModel& get_test_model_shape_nchw_float16() {
1138 static TestModel model = {
1139 .expectFailure = false,
1140 .expectedMultinomialDistributionTolerance = 0,
1141 .isRelaxed = false,
1142 .main = { // shape
1143 .inputIndexes = {0},
1144 .operands = {{ // op1
1145 .channelQuant = {},
1146 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 2.0f, 2.0f}),
1147 .dimensions = {1, 1, 2, 2},
1148 .isIgnored = false,
1149 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1150 .numberOfConsumers = 1,
1151 .scale = 0.0f,
1152 .type = TestOperandType::TENSOR_FLOAT16,
1153 .zeroPoint = 0
1154 }, { // param
1155 .channelQuant = {},
1156 .data = TestBuffer::createFromVector<int32_t>({3}),
1157 .dimensions = {},
1158 .isIgnored = false,
1159 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1160 .numberOfConsumers = 1,
1161 .scale = 0.0f,
1162 .type = TestOperandType::INT32,
1163 .zeroPoint = 0
1164 }, { // param1
1165 .channelQuant = {},
1166 .data = TestBuffer::createFromVector<int32_t>({3}),
1167 .dimensions = {},
1168 .isIgnored = false,
1169 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1170 .numberOfConsumers = 1,
1171 .scale = 0.0f,
1172 .type = TestOperandType::INT32,
1173 .zeroPoint = 0
1174 }, { // layout
1175 .channelQuant = {},
1176 .data = TestBuffer::createFromVector<bool8>({true}),
1177 .dimensions = {},
1178 .isIgnored = false,
1179 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1180 .numberOfConsumers = 1,
1181 .scale = 0.0f,
1182 .type = TestOperandType::BOOL,
1183 .zeroPoint = 0
1184 }, { // op4
1185 .channelQuant = {},
1186 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 1.0f, 1.6666666269302368f, 1.6666666269302368f, 1.6666666269302368f, 2.0f, 2.0f, 2.0f}),
1187 .dimensions = {1, 1, 3, 3},
1188 .isIgnored = false,
1189 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1190 .numberOfConsumers = 0,
1191 .scale = 0.0f,
1192 .type = TestOperandType::TENSOR_FLOAT16,
1193 .zeroPoint = 0
1194 }},
1195 .operations = {{
1196 .inputs = {0, 1, 2, 3},
1197 .outputs = {4},
1198 .type = TestOperationType::RESIZE_BILINEAR
1199 }},
1200 .outputIndexes = {4}
1201 },
1202 .minSupportedVersion = TestHalVersion::V1_2,
1203 .referenced = {}
1204 };
1205 return model;
1206 }
1207
1208 const auto dummy_test_model_shape_nchw_float16 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_float16", get_test_model_shape_nchw_float16());
1209
1210 } // namespace generated_tests::resize_bilinear_v1_2
1211
1212 namespace generated_tests::resize_bilinear_v1_2 {
1213
get_test_model_shape_nchw_float16_all_inputs_as_internal()1214 const TestModel& get_test_model_shape_nchw_float16_all_inputs_as_internal() {
1215 static TestModel model = {
1216 .expectFailure = false,
1217 .expectedMultinomialDistributionTolerance = 0,
1218 .isRelaxed = false,
1219 .main = { // shape
1220 .inputIndexes = {5},
1221 .operands = {{ // op1
1222 .channelQuant = {},
1223 .data = TestBuffer::createFromVector<_Float16>({}),
1224 .dimensions = {1, 1, 2, 2},
1225 .isIgnored = false,
1226 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1227 .numberOfConsumers = 1,
1228 .scale = 0.0f,
1229 .type = TestOperandType::TENSOR_FLOAT16,
1230 .zeroPoint = 0
1231 }, { // param
1232 .channelQuant = {},
1233 .data = TestBuffer::createFromVector<int32_t>({3}),
1234 .dimensions = {},
1235 .isIgnored = false,
1236 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1237 .numberOfConsumers = 1,
1238 .scale = 0.0f,
1239 .type = TestOperandType::INT32,
1240 .zeroPoint = 0
1241 }, { // param1
1242 .channelQuant = {},
1243 .data = TestBuffer::createFromVector<int32_t>({3}),
1244 .dimensions = {},
1245 .isIgnored = false,
1246 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1247 .numberOfConsumers = 1,
1248 .scale = 0.0f,
1249 .type = TestOperandType::INT32,
1250 .zeroPoint = 0
1251 }, { // layout
1252 .channelQuant = {},
1253 .data = TestBuffer::createFromVector<bool8>({true}),
1254 .dimensions = {},
1255 .isIgnored = false,
1256 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1257 .numberOfConsumers = 1,
1258 .scale = 0.0f,
1259 .type = TestOperandType::BOOL,
1260 .zeroPoint = 0
1261 }, { // op4
1262 .channelQuant = {},
1263 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 1.0f, 1.6666666269302368f, 1.6666666269302368f, 1.6666666269302368f, 2.0f, 2.0f, 2.0f}),
1264 .dimensions = {1, 1, 3, 3},
1265 .isIgnored = false,
1266 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1267 .numberOfConsumers = 0,
1268 .scale = 0.0f,
1269 .type = TestOperandType::TENSOR_FLOAT16,
1270 .zeroPoint = 0
1271 }, { // op1_new
1272 .channelQuant = {},
1273 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 2.0f, 2.0f}),
1274 .dimensions = {1, 1, 2, 2},
1275 .isIgnored = false,
1276 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1277 .numberOfConsumers = 1,
1278 .scale = 0.0f,
1279 .type = TestOperandType::TENSOR_FLOAT16,
1280 .zeroPoint = 0
1281 }, { // dummy6
1282 .channelQuant = {},
1283 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
1284 .dimensions = {1},
1285 .isIgnored = false,
1286 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1287 .numberOfConsumers = 1,
1288 .scale = 0.0f,
1289 .type = TestOperandType::TENSOR_FLOAT16,
1290 .zeroPoint = 0
1291 }, { // param48
1292 .channelQuant = {},
1293 .data = TestBuffer::createFromVector<int32_t>({0}),
1294 .dimensions = {},
1295 .isIgnored = false,
1296 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1297 .numberOfConsumers = 1,
1298 .scale = 0.0f,
1299 .type = TestOperandType::INT32,
1300 .zeroPoint = 0
1301 }},
1302 .operations = {{
1303 .inputs = {5, 6, 7},
1304 .outputs = {0},
1305 .type = TestOperationType::ADD
1306 }, {
1307 .inputs = {0, 1, 2, 3},
1308 .outputs = {4},
1309 .type = TestOperationType::RESIZE_BILINEAR
1310 }},
1311 .outputIndexes = {4}
1312 },
1313 .minSupportedVersion = TestHalVersion::V1_2,
1314 .referenced = {}
1315 };
1316 return model;
1317 }
1318
1319 const auto dummy_test_model_shape_nchw_float16_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_float16_all_inputs_as_internal", get_test_model_shape_nchw_float16_all_inputs_as_internal());
1320
1321 } // namespace generated_tests::resize_bilinear_v1_2
1322
1323 namespace generated_tests::resize_bilinear_v1_2 {
1324
get_test_model_shape_nchw_quant8()1325 const TestModel& get_test_model_shape_nchw_quant8() {
1326 static TestModel model = {
1327 .expectFailure = false,
1328 .expectedMultinomialDistributionTolerance = 0,
1329 .isRelaxed = false,
1330 .main = { // shape
1331 .inputIndexes = {0},
1332 .operands = {{ // op1
1333 .channelQuant = {},
1334 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 200, 200}),
1335 .dimensions = {1, 1, 2, 2},
1336 .isIgnored = false,
1337 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1338 .numberOfConsumers = 1,
1339 .scale = 0.01f,
1340 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1341 .zeroPoint = 0
1342 }, { // param
1343 .channelQuant = {},
1344 .data = TestBuffer::createFromVector<int32_t>({3}),
1345 .dimensions = {},
1346 .isIgnored = false,
1347 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1348 .numberOfConsumers = 1,
1349 .scale = 0.0f,
1350 .type = TestOperandType::INT32,
1351 .zeroPoint = 0
1352 }, { // param1
1353 .channelQuant = {},
1354 .data = TestBuffer::createFromVector<int32_t>({3}),
1355 .dimensions = {},
1356 .isIgnored = false,
1357 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1358 .numberOfConsumers = 1,
1359 .scale = 0.0f,
1360 .type = TestOperandType::INT32,
1361 .zeroPoint = 0
1362 }, { // layout
1363 .channelQuant = {},
1364 .data = TestBuffer::createFromVector<bool8>({true}),
1365 .dimensions = {},
1366 .isIgnored = false,
1367 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1368 .numberOfConsumers = 1,
1369 .scale = 0.0f,
1370 .type = TestOperandType::BOOL,
1371 .zeroPoint = 0
1372 }, { // op4
1373 .channelQuant = {},
1374 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 100, 167, 167, 167, 200, 200, 200}),
1375 .dimensions = {1, 1, 3, 3},
1376 .isIgnored = false,
1377 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1378 .numberOfConsumers = 0,
1379 .scale = 0.01f,
1380 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1381 .zeroPoint = 0
1382 }},
1383 .operations = {{
1384 .inputs = {0, 1, 2, 3},
1385 .outputs = {4},
1386 .type = TestOperationType::RESIZE_BILINEAR
1387 }},
1388 .outputIndexes = {4}
1389 },
1390 .minSupportedVersion = TestHalVersion::V1_2,
1391 .referenced = {}
1392 };
1393 return model;
1394 }
1395
1396 const auto dummy_test_model_shape_nchw_quant8 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_quant8", get_test_model_shape_nchw_quant8());
1397
1398 } // namespace generated_tests::resize_bilinear_v1_2
1399
1400 namespace generated_tests::resize_bilinear_v1_2 {
1401
get_test_model_shape_nchw_quant8_all_inputs_as_internal()1402 const TestModel& get_test_model_shape_nchw_quant8_all_inputs_as_internal() {
1403 static TestModel model = {
1404 .expectFailure = false,
1405 .expectedMultinomialDistributionTolerance = 0,
1406 .isRelaxed = false,
1407 .main = { // shape
1408 .inputIndexes = {5},
1409 .operands = {{ // op1
1410 .channelQuant = {},
1411 .data = TestBuffer::createFromVector<uint8_t>({}),
1412 .dimensions = {1, 1, 2, 2},
1413 .isIgnored = false,
1414 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1415 .numberOfConsumers = 1,
1416 .scale = 0.01f,
1417 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1418 .zeroPoint = 0
1419 }, { // param
1420 .channelQuant = {},
1421 .data = TestBuffer::createFromVector<int32_t>({3}),
1422 .dimensions = {},
1423 .isIgnored = false,
1424 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1425 .numberOfConsumers = 1,
1426 .scale = 0.0f,
1427 .type = TestOperandType::INT32,
1428 .zeroPoint = 0
1429 }, { // param1
1430 .channelQuant = {},
1431 .data = TestBuffer::createFromVector<int32_t>({3}),
1432 .dimensions = {},
1433 .isIgnored = false,
1434 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1435 .numberOfConsumers = 1,
1436 .scale = 0.0f,
1437 .type = TestOperandType::INT32,
1438 .zeroPoint = 0
1439 }, { // layout
1440 .channelQuant = {},
1441 .data = TestBuffer::createFromVector<bool8>({true}),
1442 .dimensions = {},
1443 .isIgnored = false,
1444 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1445 .numberOfConsumers = 1,
1446 .scale = 0.0f,
1447 .type = TestOperandType::BOOL,
1448 .zeroPoint = 0
1449 }, { // op4
1450 .channelQuant = {},
1451 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 100, 167, 167, 167, 200, 200, 200}),
1452 .dimensions = {1, 1, 3, 3},
1453 .isIgnored = false,
1454 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1455 .numberOfConsumers = 0,
1456 .scale = 0.01f,
1457 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1458 .zeroPoint = 0
1459 }, { // op1_new
1460 .channelQuant = {},
1461 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 200, 200}),
1462 .dimensions = {1, 1, 2, 2},
1463 .isIgnored = false,
1464 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1465 .numberOfConsumers = 1,
1466 .scale = 0.01f,
1467 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1468 .zeroPoint = 0
1469 }, { // dummy7
1470 .channelQuant = {},
1471 .data = TestBuffer::createFromVector<uint8_t>({0}),
1472 .dimensions = {1},
1473 .isIgnored = false,
1474 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1475 .numberOfConsumers = 1,
1476 .scale = 0.01f,
1477 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
1478 .zeroPoint = 0
1479 }, { // param49
1480 .channelQuant = {},
1481 .data = TestBuffer::createFromVector<int32_t>({0}),
1482 .dimensions = {},
1483 .isIgnored = false,
1484 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1485 .numberOfConsumers = 1,
1486 .scale = 0.0f,
1487 .type = TestOperandType::INT32,
1488 .zeroPoint = 0
1489 }},
1490 .operations = {{
1491 .inputs = {5, 6, 7},
1492 .outputs = {0},
1493 .type = TestOperationType::ADD
1494 }, {
1495 .inputs = {0, 1, 2, 3},
1496 .outputs = {4},
1497 .type = TestOperationType::RESIZE_BILINEAR
1498 }},
1499 .outputIndexes = {4}
1500 },
1501 .minSupportedVersion = TestHalVersion::V1_2,
1502 .referenced = {}
1503 };
1504 return model;
1505 }
1506
1507 const auto dummy_test_model_shape_nchw_quant8_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_quant8_all_inputs_as_internal", get_test_model_shape_nchw_quant8_all_inputs_as_internal());
1508
1509 } // namespace generated_tests::resize_bilinear_v1_2
1510
1511 namespace generated_tests::resize_bilinear_v1_2 {
1512
get_test_model_scale_nhwc()1513 const TestModel& get_test_model_scale_nhwc() {
1514 static TestModel model = {
1515 .expectFailure = false,
1516 .expectedMultinomialDistributionTolerance = 0,
1517 .isRelaxed = false,
1518 .main = { // scale
1519 .inputIndexes = {0},
1520 .operands = {{ // op1
1521 .channelQuant = {},
1522 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
1523 .dimensions = {1, 2, 2, 1},
1524 .isIgnored = false,
1525 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1526 .numberOfConsumers = 1,
1527 .scale = 0.0f,
1528 .type = TestOperandType::TENSOR_FLOAT32,
1529 .zeroPoint = 0
1530 }, { // param2
1531 .channelQuant = {},
1532 .data = TestBuffer::createFromVector<float>({1.5f}),
1533 .dimensions = {},
1534 .isIgnored = false,
1535 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1536 .numberOfConsumers = 1,
1537 .scale = 0.0f,
1538 .type = TestOperandType::FLOAT32,
1539 .zeroPoint = 0
1540 }, { // param3
1541 .channelQuant = {},
1542 .data = TestBuffer::createFromVector<float>({1.5f}),
1543 .dimensions = {},
1544 .isIgnored = false,
1545 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1546 .numberOfConsumers = 1,
1547 .scale = 0.0f,
1548 .type = TestOperandType::FLOAT32,
1549 .zeroPoint = 0
1550 }, { // layout
1551 .channelQuant = {},
1552 .data = TestBuffer::createFromVector<bool8>({false}),
1553 .dimensions = {},
1554 .isIgnored = false,
1555 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1556 .numberOfConsumers = 1,
1557 .scale = 0.0f,
1558 .type = TestOperandType::BOOL,
1559 .zeroPoint = 0
1560 }, { // op4
1561 .channelQuant = {},
1562 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
1563 .dimensions = {1, 3, 3, 1},
1564 .isIgnored = false,
1565 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1566 .numberOfConsumers = 0,
1567 .scale = 0.0f,
1568 .type = TestOperandType::TENSOR_FLOAT32,
1569 .zeroPoint = 0
1570 }},
1571 .operations = {{
1572 .inputs = {0, 1, 2, 3},
1573 .outputs = {4},
1574 .type = TestOperationType::RESIZE_BILINEAR
1575 }},
1576 .outputIndexes = {4}
1577 },
1578 .minSupportedVersion = TestHalVersion::V1_2,
1579 .referenced = {}
1580 };
1581 return model;
1582 }
1583
1584 const auto dummy_test_model_scale_nhwc = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc", get_test_model_scale_nhwc());
1585
1586 } // namespace generated_tests::resize_bilinear_v1_2
1587
1588 namespace generated_tests::resize_bilinear_v1_2 {
1589
get_test_model_scale_nhwc_all_inputs_as_internal()1590 const TestModel& get_test_model_scale_nhwc_all_inputs_as_internal() {
1591 static TestModel model = {
1592 .expectFailure = false,
1593 .expectedMultinomialDistributionTolerance = 0,
1594 .isRelaxed = false,
1595 .main = { // scale
1596 .inputIndexes = {5},
1597 .operands = {{ // op1
1598 .channelQuant = {},
1599 .data = TestBuffer::createFromVector<float>({}),
1600 .dimensions = {1, 2, 2, 1},
1601 .isIgnored = false,
1602 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1603 .numberOfConsumers = 1,
1604 .scale = 0.0f,
1605 .type = TestOperandType::TENSOR_FLOAT32,
1606 .zeroPoint = 0
1607 }, { // param2
1608 .channelQuant = {},
1609 .data = TestBuffer::createFromVector<float>({1.5f}),
1610 .dimensions = {},
1611 .isIgnored = false,
1612 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1613 .numberOfConsumers = 1,
1614 .scale = 0.0f,
1615 .type = TestOperandType::FLOAT32,
1616 .zeroPoint = 0
1617 }, { // param3
1618 .channelQuant = {},
1619 .data = TestBuffer::createFromVector<float>({1.5f}),
1620 .dimensions = {},
1621 .isIgnored = false,
1622 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1623 .numberOfConsumers = 1,
1624 .scale = 0.0f,
1625 .type = TestOperandType::FLOAT32,
1626 .zeroPoint = 0
1627 }, { // layout
1628 .channelQuant = {},
1629 .data = TestBuffer::createFromVector<bool8>({false}),
1630 .dimensions = {},
1631 .isIgnored = false,
1632 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1633 .numberOfConsumers = 1,
1634 .scale = 0.0f,
1635 .type = TestOperandType::BOOL,
1636 .zeroPoint = 0
1637 }, { // op4
1638 .channelQuant = {},
1639 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
1640 .dimensions = {1, 3, 3, 1},
1641 .isIgnored = false,
1642 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1643 .numberOfConsumers = 0,
1644 .scale = 0.0f,
1645 .type = TestOperandType::TENSOR_FLOAT32,
1646 .zeroPoint = 0
1647 }, { // op1_new
1648 .channelQuant = {},
1649 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
1650 .dimensions = {1, 2, 2, 1},
1651 .isIgnored = false,
1652 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1653 .numberOfConsumers = 1,
1654 .scale = 0.0f,
1655 .type = TestOperandType::TENSOR_FLOAT32,
1656 .zeroPoint = 0
1657 }, { // dummy8
1658 .channelQuant = {},
1659 .data = TestBuffer::createFromVector<float>({0.0f}),
1660 .dimensions = {1},
1661 .isIgnored = false,
1662 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1663 .numberOfConsumers = 1,
1664 .scale = 0.0f,
1665 .type = TestOperandType::TENSOR_FLOAT32,
1666 .zeroPoint = 0
1667 }, { // param50
1668 .channelQuant = {},
1669 .data = TestBuffer::createFromVector<int32_t>({0}),
1670 .dimensions = {},
1671 .isIgnored = false,
1672 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1673 .numberOfConsumers = 1,
1674 .scale = 0.0f,
1675 .type = TestOperandType::INT32,
1676 .zeroPoint = 0
1677 }},
1678 .operations = {{
1679 .inputs = {5, 6, 7},
1680 .outputs = {0},
1681 .type = TestOperationType::ADD
1682 }, {
1683 .inputs = {0, 1, 2, 3},
1684 .outputs = {4},
1685 .type = TestOperationType::RESIZE_BILINEAR
1686 }},
1687 .outputIndexes = {4}
1688 },
1689 .minSupportedVersion = TestHalVersion::V1_2,
1690 .referenced = {}
1691 };
1692 return model;
1693 }
1694
1695 const auto dummy_test_model_scale_nhwc_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_all_inputs_as_internal", get_test_model_scale_nhwc_all_inputs_as_internal());
1696
1697 } // namespace generated_tests::resize_bilinear_v1_2
1698
1699 namespace generated_tests::resize_bilinear_v1_2 {
1700
get_test_model_scale_nhwc_relaxed()1701 const TestModel& get_test_model_scale_nhwc_relaxed() {
1702 static TestModel model = {
1703 .expectFailure = false,
1704 .expectedMultinomialDistributionTolerance = 0,
1705 .isRelaxed = true,
1706 .main = { // scale
1707 .inputIndexes = {0},
1708 .operands = {{ // op1
1709 .channelQuant = {},
1710 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
1711 .dimensions = {1, 2, 2, 1},
1712 .isIgnored = false,
1713 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1714 .numberOfConsumers = 1,
1715 .scale = 0.0f,
1716 .type = TestOperandType::TENSOR_FLOAT32,
1717 .zeroPoint = 0
1718 }, { // param2
1719 .channelQuant = {},
1720 .data = TestBuffer::createFromVector<float>({1.5f}),
1721 .dimensions = {},
1722 .isIgnored = false,
1723 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1724 .numberOfConsumers = 1,
1725 .scale = 0.0f,
1726 .type = TestOperandType::FLOAT32,
1727 .zeroPoint = 0
1728 }, { // param3
1729 .channelQuant = {},
1730 .data = TestBuffer::createFromVector<float>({1.5f}),
1731 .dimensions = {},
1732 .isIgnored = false,
1733 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1734 .numberOfConsumers = 1,
1735 .scale = 0.0f,
1736 .type = TestOperandType::FLOAT32,
1737 .zeroPoint = 0
1738 }, { // layout
1739 .channelQuant = {},
1740 .data = TestBuffer::createFromVector<bool8>({false}),
1741 .dimensions = {},
1742 .isIgnored = false,
1743 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1744 .numberOfConsumers = 1,
1745 .scale = 0.0f,
1746 .type = TestOperandType::BOOL,
1747 .zeroPoint = 0
1748 }, { // op4
1749 .channelQuant = {},
1750 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
1751 .dimensions = {1, 3, 3, 1},
1752 .isIgnored = false,
1753 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1754 .numberOfConsumers = 0,
1755 .scale = 0.0f,
1756 .type = TestOperandType::TENSOR_FLOAT32,
1757 .zeroPoint = 0
1758 }},
1759 .operations = {{
1760 .inputs = {0, 1, 2, 3},
1761 .outputs = {4},
1762 .type = TestOperationType::RESIZE_BILINEAR
1763 }},
1764 .outputIndexes = {4}
1765 },
1766 .minSupportedVersion = TestHalVersion::UNKNOWN,
1767 .referenced = {}
1768 };
1769 return model;
1770 }
1771
1772 const auto dummy_test_model_scale_nhwc_relaxed = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_relaxed", get_test_model_scale_nhwc_relaxed());
1773
1774 } // namespace generated_tests::resize_bilinear_v1_2
1775
1776 namespace generated_tests::resize_bilinear_v1_2 {
1777
get_test_model_scale_nhwc_relaxed_all_inputs_as_internal()1778 const TestModel& get_test_model_scale_nhwc_relaxed_all_inputs_as_internal() {
1779 static TestModel model = {
1780 .expectFailure = false,
1781 .expectedMultinomialDistributionTolerance = 0,
1782 .isRelaxed = true,
1783 .main = { // scale
1784 .inputIndexes = {5},
1785 .operands = {{ // op1
1786 .channelQuant = {},
1787 .data = TestBuffer::createFromVector<float>({}),
1788 .dimensions = {1, 2, 2, 1},
1789 .isIgnored = false,
1790 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1791 .numberOfConsumers = 1,
1792 .scale = 0.0f,
1793 .type = TestOperandType::TENSOR_FLOAT32,
1794 .zeroPoint = 0
1795 }, { // param2
1796 .channelQuant = {},
1797 .data = TestBuffer::createFromVector<float>({1.5f}),
1798 .dimensions = {},
1799 .isIgnored = false,
1800 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1801 .numberOfConsumers = 1,
1802 .scale = 0.0f,
1803 .type = TestOperandType::FLOAT32,
1804 .zeroPoint = 0
1805 }, { // param3
1806 .channelQuant = {},
1807 .data = TestBuffer::createFromVector<float>({1.5f}),
1808 .dimensions = {},
1809 .isIgnored = false,
1810 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1811 .numberOfConsumers = 1,
1812 .scale = 0.0f,
1813 .type = TestOperandType::FLOAT32,
1814 .zeroPoint = 0
1815 }, { // layout
1816 .channelQuant = {},
1817 .data = TestBuffer::createFromVector<bool8>({false}),
1818 .dimensions = {},
1819 .isIgnored = false,
1820 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1821 .numberOfConsumers = 1,
1822 .scale = 0.0f,
1823 .type = TestOperandType::BOOL,
1824 .zeroPoint = 0
1825 }, { // op4
1826 .channelQuant = {},
1827 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
1828 .dimensions = {1, 3, 3, 1},
1829 .isIgnored = false,
1830 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1831 .numberOfConsumers = 0,
1832 .scale = 0.0f,
1833 .type = TestOperandType::TENSOR_FLOAT32,
1834 .zeroPoint = 0
1835 }, { // op1_new
1836 .channelQuant = {},
1837 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
1838 .dimensions = {1, 2, 2, 1},
1839 .isIgnored = false,
1840 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1841 .numberOfConsumers = 1,
1842 .scale = 0.0f,
1843 .type = TestOperandType::TENSOR_FLOAT32,
1844 .zeroPoint = 0
1845 }, { // dummy9
1846 .channelQuant = {},
1847 .data = TestBuffer::createFromVector<float>({0.0f}),
1848 .dimensions = {1},
1849 .isIgnored = false,
1850 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1851 .numberOfConsumers = 1,
1852 .scale = 0.0f,
1853 .type = TestOperandType::TENSOR_FLOAT32,
1854 .zeroPoint = 0
1855 }, { // param51
1856 .channelQuant = {},
1857 .data = TestBuffer::createFromVector<int32_t>({0}),
1858 .dimensions = {},
1859 .isIgnored = false,
1860 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1861 .numberOfConsumers = 1,
1862 .scale = 0.0f,
1863 .type = TestOperandType::INT32,
1864 .zeroPoint = 0
1865 }},
1866 .operations = {{
1867 .inputs = {5, 6, 7},
1868 .outputs = {0},
1869 .type = TestOperationType::ADD
1870 }, {
1871 .inputs = {0, 1, 2, 3},
1872 .outputs = {4},
1873 .type = TestOperationType::RESIZE_BILINEAR
1874 }},
1875 .outputIndexes = {4}
1876 },
1877 .minSupportedVersion = TestHalVersion::UNKNOWN,
1878 .referenced = {}
1879 };
1880 return model;
1881 }
1882
1883 const auto dummy_test_model_scale_nhwc_relaxed_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_relaxed_all_inputs_as_internal", get_test_model_scale_nhwc_relaxed_all_inputs_as_internal());
1884
1885 } // namespace generated_tests::resize_bilinear_v1_2
1886
1887 namespace generated_tests::resize_bilinear_v1_2 {
1888
get_test_model_scale_nhwc_float16()1889 const TestModel& get_test_model_scale_nhwc_float16() {
1890 static TestModel model = {
1891 .expectFailure = false,
1892 .expectedMultinomialDistributionTolerance = 0,
1893 .isRelaxed = false,
1894 .main = { // scale
1895 .inputIndexes = {0},
1896 .operands = {{ // op1
1897 .channelQuant = {},
1898 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 2.0f, 2.0f}),
1899 .dimensions = {1, 2, 2, 1},
1900 .isIgnored = false,
1901 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1902 .numberOfConsumers = 1,
1903 .scale = 0.0f,
1904 .type = TestOperandType::TENSOR_FLOAT16,
1905 .zeroPoint = 0
1906 }, { // param2
1907 .channelQuant = {},
1908 .data = TestBuffer::createFromVector<_Float16>({1.5f}),
1909 .dimensions = {},
1910 .isIgnored = false,
1911 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1912 .numberOfConsumers = 1,
1913 .scale = 0.0f,
1914 .type = TestOperandType::FLOAT16,
1915 .zeroPoint = 0
1916 }, { // param3
1917 .channelQuant = {},
1918 .data = TestBuffer::createFromVector<_Float16>({1.5f}),
1919 .dimensions = {},
1920 .isIgnored = false,
1921 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1922 .numberOfConsumers = 1,
1923 .scale = 0.0f,
1924 .type = TestOperandType::FLOAT16,
1925 .zeroPoint = 0
1926 }, { // layout
1927 .channelQuant = {},
1928 .data = TestBuffer::createFromVector<bool8>({false}),
1929 .dimensions = {},
1930 .isIgnored = false,
1931 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1932 .numberOfConsumers = 1,
1933 .scale = 0.0f,
1934 .type = TestOperandType::BOOL,
1935 .zeroPoint = 0
1936 }, { // op4
1937 .channelQuant = {},
1938 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 1.0f, 1.6666666269302368f, 1.6666666269302368f, 1.6666666269302368f, 2.0f, 2.0f, 2.0f}),
1939 .dimensions = {1, 3, 3, 1},
1940 .isIgnored = false,
1941 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1942 .numberOfConsumers = 0,
1943 .scale = 0.0f,
1944 .type = TestOperandType::TENSOR_FLOAT16,
1945 .zeroPoint = 0
1946 }},
1947 .operations = {{
1948 .inputs = {0, 1, 2, 3},
1949 .outputs = {4},
1950 .type = TestOperationType::RESIZE_BILINEAR
1951 }},
1952 .outputIndexes = {4}
1953 },
1954 .minSupportedVersion = TestHalVersion::V1_2,
1955 .referenced = {}
1956 };
1957 return model;
1958 }
1959
1960 const auto dummy_test_model_scale_nhwc_float16 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_float16", get_test_model_scale_nhwc_float16());
1961
1962 } // namespace generated_tests::resize_bilinear_v1_2
1963
1964 namespace generated_tests::resize_bilinear_v1_2 {
1965
get_test_model_scale_nhwc_float16_all_inputs_as_internal()1966 const TestModel& get_test_model_scale_nhwc_float16_all_inputs_as_internal() {
1967 static TestModel model = {
1968 .expectFailure = false,
1969 .expectedMultinomialDistributionTolerance = 0,
1970 .isRelaxed = false,
1971 .main = { // scale
1972 .inputIndexes = {5},
1973 .operands = {{ // op1
1974 .channelQuant = {},
1975 .data = TestBuffer::createFromVector<_Float16>({}),
1976 .dimensions = {1, 2, 2, 1},
1977 .isIgnored = false,
1978 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
1979 .numberOfConsumers = 1,
1980 .scale = 0.0f,
1981 .type = TestOperandType::TENSOR_FLOAT16,
1982 .zeroPoint = 0
1983 }, { // param2
1984 .channelQuant = {},
1985 .data = TestBuffer::createFromVector<_Float16>({1.5f}),
1986 .dimensions = {},
1987 .isIgnored = false,
1988 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1989 .numberOfConsumers = 1,
1990 .scale = 0.0f,
1991 .type = TestOperandType::FLOAT16,
1992 .zeroPoint = 0
1993 }, { // param3
1994 .channelQuant = {},
1995 .data = TestBuffer::createFromVector<_Float16>({1.5f}),
1996 .dimensions = {},
1997 .isIgnored = false,
1998 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1999 .numberOfConsumers = 1,
2000 .scale = 0.0f,
2001 .type = TestOperandType::FLOAT16,
2002 .zeroPoint = 0
2003 }, { // layout
2004 .channelQuant = {},
2005 .data = TestBuffer::createFromVector<bool8>({false}),
2006 .dimensions = {},
2007 .isIgnored = false,
2008 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2009 .numberOfConsumers = 1,
2010 .scale = 0.0f,
2011 .type = TestOperandType::BOOL,
2012 .zeroPoint = 0
2013 }, { // op4
2014 .channelQuant = {},
2015 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 1.0f, 1.6666666269302368f, 1.6666666269302368f, 1.6666666269302368f, 2.0f, 2.0f, 2.0f}),
2016 .dimensions = {1, 3, 3, 1},
2017 .isIgnored = false,
2018 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2019 .numberOfConsumers = 0,
2020 .scale = 0.0f,
2021 .type = TestOperandType::TENSOR_FLOAT16,
2022 .zeroPoint = 0
2023 }, { // op1_new
2024 .channelQuant = {},
2025 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 2.0f, 2.0f}),
2026 .dimensions = {1, 2, 2, 1},
2027 .isIgnored = false,
2028 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2029 .numberOfConsumers = 1,
2030 .scale = 0.0f,
2031 .type = TestOperandType::TENSOR_FLOAT16,
2032 .zeroPoint = 0
2033 }, { // dummy10
2034 .channelQuant = {},
2035 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
2036 .dimensions = {1},
2037 .isIgnored = false,
2038 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2039 .numberOfConsumers = 1,
2040 .scale = 0.0f,
2041 .type = TestOperandType::TENSOR_FLOAT16,
2042 .zeroPoint = 0
2043 }, { // param52
2044 .channelQuant = {},
2045 .data = TestBuffer::createFromVector<int32_t>({0}),
2046 .dimensions = {},
2047 .isIgnored = false,
2048 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2049 .numberOfConsumers = 1,
2050 .scale = 0.0f,
2051 .type = TestOperandType::INT32,
2052 .zeroPoint = 0
2053 }},
2054 .operations = {{
2055 .inputs = {5, 6, 7},
2056 .outputs = {0},
2057 .type = TestOperationType::ADD
2058 }, {
2059 .inputs = {0, 1, 2, 3},
2060 .outputs = {4},
2061 .type = TestOperationType::RESIZE_BILINEAR
2062 }},
2063 .outputIndexes = {4}
2064 },
2065 .minSupportedVersion = TestHalVersion::V1_2,
2066 .referenced = {}
2067 };
2068 return model;
2069 }
2070
2071 const auto dummy_test_model_scale_nhwc_float16_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_float16_all_inputs_as_internal", get_test_model_scale_nhwc_float16_all_inputs_as_internal());
2072
2073 } // namespace generated_tests::resize_bilinear_v1_2
2074
2075 namespace generated_tests::resize_bilinear_v1_2 {
2076
get_test_model_scale_nhwc_quant8()2077 const TestModel& get_test_model_scale_nhwc_quant8() {
2078 static TestModel model = {
2079 .expectFailure = false,
2080 .expectedMultinomialDistributionTolerance = 0,
2081 .isRelaxed = false,
2082 .main = { // scale
2083 .inputIndexes = {0},
2084 .operands = {{ // op1
2085 .channelQuant = {},
2086 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 200, 200}),
2087 .dimensions = {1, 2, 2, 1},
2088 .isIgnored = false,
2089 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2090 .numberOfConsumers = 1,
2091 .scale = 0.01f,
2092 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2093 .zeroPoint = 0
2094 }, { // param2
2095 .channelQuant = {},
2096 .data = TestBuffer::createFromVector<float>({1.5f}),
2097 .dimensions = {},
2098 .isIgnored = false,
2099 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2100 .numberOfConsumers = 1,
2101 .scale = 0.0f,
2102 .type = TestOperandType::FLOAT32,
2103 .zeroPoint = 0
2104 }, { // param3
2105 .channelQuant = {},
2106 .data = TestBuffer::createFromVector<float>({1.5f}),
2107 .dimensions = {},
2108 .isIgnored = false,
2109 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2110 .numberOfConsumers = 1,
2111 .scale = 0.0f,
2112 .type = TestOperandType::FLOAT32,
2113 .zeroPoint = 0
2114 }, { // layout
2115 .channelQuant = {},
2116 .data = TestBuffer::createFromVector<bool8>({false}),
2117 .dimensions = {},
2118 .isIgnored = false,
2119 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2120 .numberOfConsumers = 1,
2121 .scale = 0.0f,
2122 .type = TestOperandType::BOOL,
2123 .zeroPoint = 0
2124 }, { // op4
2125 .channelQuant = {},
2126 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 100, 167, 167, 167, 200, 200, 200}),
2127 .dimensions = {1, 3, 3, 1},
2128 .isIgnored = false,
2129 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2130 .numberOfConsumers = 0,
2131 .scale = 0.01f,
2132 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2133 .zeroPoint = 0
2134 }},
2135 .operations = {{
2136 .inputs = {0, 1, 2, 3},
2137 .outputs = {4},
2138 .type = TestOperationType::RESIZE_BILINEAR
2139 }},
2140 .outputIndexes = {4}
2141 },
2142 .minSupportedVersion = TestHalVersion::V1_2,
2143 .referenced = {}
2144 };
2145 return model;
2146 }
2147
2148 const auto dummy_test_model_scale_nhwc_quant8 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_quant8", get_test_model_scale_nhwc_quant8());
2149
2150 } // namespace generated_tests::resize_bilinear_v1_2
2151
2152 namespace generated_tests::resize_bilinear_v1_2 {
2153
get_test_model_scale_nhwc_quant8_all_inputs_as_internal()2154 const TestModel& get_test_model_scale_nhwc_quant8_all_inputs_as_internal() {
2155 static TestModel model = {
2156 .expectFailure = false,
2157 .expectedMultinomialDistributionTolerance = 0,
2158 .isRelaxed = false,
2159 .main = { // scale
2160 .inputIndexes = {5},
2161 .operands = {{ // op1
2162 .channelQuant = {},
2163 .data = TestBuffer::createFromVector<uint8_t>({}),
2164 .dimensions = {1, 2, 2, 1},
2165 .isIgnored = false,
2166 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2167 .numberOfConsumers = 1,
2168 .scale = 0.01f,
2169 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2170 .zeroPoint = 0
2171 }, { // param2
2172 .channelQuant = {},
2173 .data = TestBuffer::createFromVector<float>({1.5f}),
2174 .dimensions = {},
2175 .isIgnored = false,
2176 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2177 .numberOfConsumers = 1,
2178 .scale = 0.0f,
2179 .type = TestOperandType::FLOAT32,
2180 .zeroPoint = 0
2181 }, { // param3
2182 .channelQuant = {},
2183 .data = TestBuffer::createFromVector<float>({1.5f}),
2184 .dimensions = {},
2185 .isIgnored = false,
2186 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2187 .numberOfConsumers = 1,
2188 .scale = 0.0f,
2189 .type = TestOperandType::FLOAT32,
2190 .zeroPoint = 0
2191 }, { // layout
2192 .channelQuant = {},
2193 .data = TestBuffer::createFromVector<bool8>({false}),
2194 .dimensions = {},
2195 .isIgnored = false,
2196 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2197 .numberOfConsumers = 1,
2198 .scale = 0.0f,
2199 .type = TestOperandType::BOOL,
2200 .zeroPoint = 0
2201 }, { // op4
2202 .channelQuant = {},
2203 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 100, 167, 167, 167, 200, 200, 200}),
2204 .dimensions = {1, 3, 3, 1},
2205 .isIgnored = false,
2206 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2207 .numberOfConsumers = 0,
2208 .scale = 0.01f,
2209 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2210 .zeroPoint = 0
2211 }, { // op1_new
2212 .channelQuant = {},
2213 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 200, 200}),
2214 .dimensions = {1, 2, 2, 1},
2215 .isIgnored = false,
2216 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2217 .numberOfConsumers = 1,
2218 .scale = 0.01f,
2219 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2220 .zeroPoint = 0
2221 }, { // dummy11
2222 .channelQuant = {},
2223 .data = TestBuffer::createFromVector<uint8_t>({0}),
2224 .dimensions = {1},
2225 .isIgnored = false,
2226 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2227 .numberOfConsumers = 1,
2228 .scale = 0.01f,
2229 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2230 .zeroPoint = 0
2231 }, { // param53
2232 .channelQuant = {},
2233 .data = TestBuffer::createFromVector<int32_t>({0}),
2234 .dimensions = {},
2235 .isIgnored = false,
2236 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2237 .numberOfConsumers = 1,
2238 .scale = 0.0f,
2239 .type = TestOperandType::INT32,
2240 .zeroPoint = 0
2241 }},
2242 .operations = {{
2243 .inputs = {5, 6, 7},
2244 .outputs = {0},
2245 .type = TestOperationType::ADD
2246 }, {
2247 .inputs = {0, 1, 2, 3},
2248 .outputs = {4},
2249 .type = TestOperationType::RESIZE_BILINEAR
2250 }},
2251 .outputIndexes = {4}
2252 },
2253 .minSupportedVersion = TestHalVersion::V1_2,
2254 .referenced = {}
2255 };
2256 return model;
2257 }
2258
2259 const auto dummy_test_model_scale_nhwc_quant8_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_quant8_all_inputs_as_internal", get_test_model_scale_nhwc_quant8_all_inputs_as_internal());
2260
2261 } // namespace generated_tests::resize_bilinear_v1_2
2262
2263 namespace generated_tests::resize_bilinear_v1_2 {
2264
get_test_model_scale_nchw()2265 const TestModel& get_test_model_scale_nchw() {
2266 static TestModel model = {
2267 .expectFailure = false,
2268 .expectedMultinomialDistributionTolerance = 0,
2269 .isRelaxed = false,
2270 .main = { // scale
2271 .inputIndexes = {0},
2272 .operands = {{ // op1
2273 .channelQuant = {},
2274 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
2275 .dimensions = {1, 1, 2, 2},
2276 .isIgnored = false,
2277 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2278 .numberOfConsumers = 1,
2279 .scale = 0.0f,
2280 .type = TestOperandType::TENSOR_FLOAT32,
2281 .zeroPoint = 0
2282 }, { // param2
2283 .channelQuant = {},
2284 .data = TestBuffer::createFromVector<float>({1.5f}),
2285 .dimensions = {},
2286 .isIgnored = false,
2287 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2288 .numberOfConsumers = 1,
2289 .scale = 0.0f,
2290 .type = TestOperandType::FLOAT32,
2291 .zeroPoint = 0
2292 }, { // param3
2293 .channelQuant = {},
2294 .data = TestBuffer::createFromVector<float>({1.5f}),
2295 .dimensions = {},
2296 .isIgnored = false,
2297 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2298 .numberOfConsumers = 1,
2299 .scale = 0.0f,
2300 .type = TestOperandType::FLOAT32,
2301 .zeroPoint = 0
2302 }, { // layout
2303 .channelQuant = {},
2304 .data = TestBuffer::createFromVector<bool8>({true}),
2305 .dimensions = {},
2306 .isIgnored = false,
2307 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2308 .numberOfConsumers = 1,
2309 .scale = 0.0f,
2310 .type = TestOperandType::BOOL,
2311 .zeroPoint = 0
2312 }, { // op4
2313 .channelQuant = {},
2314 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
2315 .dimensions = {1, 1, 3, 3},
2316 .isIgnored = false,
2317 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2318 .numberOfConsumers = 0,
2319 .scale = 0.0f,
2320 .type = TestOperandType::TENSOR_FLOAT32,
2321 .zeroPoint = 0
2322 }},
2323 .operations = {{
2324 .inputs = {0, 1, 2, 3},
2325 .outputs = {4},
2326 .type = TestOperationType::RESIZE_BILINEAR
2327 }},
2328 .outputIndexes = {4}
2329 },
2330 .minSupportedVersion = TestHalVersion::V1_2,
2331 .referenced = {}
2332 };
2333 return model;
2334 }
2335
2336 const auto dummy_test_model_scale_nchw = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw", get_test_model_scale_nchw());
2337
2338 } // namespace generated_tests::resize_bilinear_v1_2
2339
2340 namespace generated_tests::resize_bilinear_v1_2 {
2341
get_test_model_scale_nchw_all_inputs_as_internal()2342 const TestModel& get_test_model_scale_nchw_all_inputs_as_internal() {
2343 static TestModel model = {
2344 .expectFailure = false,
2345 .expectedMultinomialDistributionTolerance = 0,
2346 .isRelaxed = false,
2347 .main = { // scale
2348 .inputIndexes = {5},
2349 .operands = {{ // op1
2350 .channelQuant = {},
2351 .data = TestBuffer::createFromVector<float>({}),
2352 .dimensions = {1, 1, 2, 2},
2353 .isIgnored = false,
2354 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2355 .numberOfConsumers = 1,
2356 .scale = 0.0f,
2357 .type = TestOperandType::TENSOR_FLOAT32,
2358 .zeroPoint = 0
2359 }, { // param2
2360 .channelQuant = {},
2361 .data = TestBuffer::createFromVector<float>({1.5f}),
2362 .dimensions = {},
2363 .isIgnored = false,
2364 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2365 .numberOfConsumers = 1,
2366 .scale = 0.0f,
2367 .type = TestOperandType::FLOAT32,
2368 .zeroPoint = 0
2369 }, { // param3
2370 .channelQuant = {},
2371 .data = TestBuffer::createFromVector<float>({1.5f}),
2372 .dimensions = {},
2373 .isIgnored = false,
2374 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2375 .numberOfConsumers = 1,
2376 .scale = 0.0f,
2377 .type = TestOperandType::FLOAT32,
2378 .zeroPoint = 0
2379 }, { // layout
2380 .channelQuant = {},
2381 .data = TestBuffer::createFromVector<bool8>({true}),
2382 .dimensions = {},
2383 .isIgnored = false,
2384 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2385 .numberOfConsumers = 1,
2386 .scale = 0.0f,
2387 .type = TestOperandType::BOOL,
2388 .zeroPoint = 0
2389 }, { // op4
2390 .channelQuant = {},
2391 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
2392 .dimensions = {1, 1, 3, 3},
2393 .isIgnored = false,
2394 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2395 .numberOfConsumers = 0,
2396 .scale = 0.0f,
2397 .type = TestOperandType::TENSOR_FLOAT32,
2398 .zeroPoint = 0
2399 }, { // op1_new
2400 .channelQuant = {},
2401 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
2402 .dimensions = {1, 1, 2, 2},
2403 .isIgnored = false,
2404 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2405 .numberOfConsumers = 1,
2406 .scale = 0.0f,
2407 .type = TestOperandType::TENSOR_FLOAT32,
2408 .zeroPoint = 0
2409 }, { // dummy12
2410 .channelQuant = {},
2411 .data = TestBuffer::createFromVector<float>({0.0f}),
2412 .dimensions = {1},
2413 .isIgnored = false,
2414 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2415 .numberOfConsumers = 1,
2416 .scale = 0.0f,
2417 .type = TestOperandType::TENSOR_FLOAT32,
2418 .zeroPoint = 0
2419 }, { // param54
2420 .channelQuant = {},
2421 .data = TestBuffer::createFromVector<int32_t>({0}),
2422 .dimensions = {},
2423 .isIgnored = false,
2424 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2425 .numberOfConsumers = 1,
2426 .scale = 0.0f,
2427 .type = TestOperandType::INT32,
2428 .zeroPoint = 0
2429 }},
2430 .operations = {{
2431 .inputs = {5, 6, 7},
2432 .outputs = {0},
2433 .type = TestOperationType::ADD
2434 }, {
2435 .inputs = {0, 1, 2, 3},
2436 .outputs = {4},
2437 .type = TestOperationType::RESIZE_BILINEAR
2438 }},
2439 .outputIndexes = {4}
2440 },
2441 .minSupportedVersion = TestHalVersion::V1_2,
2442 .referenced = {}
2443 };
2444 return model;
2445 }
2446
2447 const auto dummy_test_model_scale_nchw_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_all_inputs_as_internal", get_test_model_scale_nchw_all_inputs_as_internal());
2448
2449 } // namespace generated_tests::resize_bilinear_v1_2
2450
2451 namespace generated_tests::resize_bilinear_v1_2 {
2452
get_test_model_scale_nchw_relaxed()2453 const TestModel& get_test_model_scale_nchw_relaxed() {
2454 static TestModel model = {
2455 .expectFailure = false,
2456 .expectedMultinomialDistributionTolerance = 0,
2457 .isRelaxed = true,
2458 .main = { // scale
2459 .inputIndexes = {0},
2460 .operands = {{ // op1
2461 .channelQuant = {},
2462 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
2463 .dimensions = {1, 1, 2, 2},
2464 .isIgnored = false,
2465 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2466 .numberOfConsumers = 1,
2467 .scale = 0.0f,
2468 .type = TestOperandType::TENSOR_FLOAT32,
2469 .zeroPoint = 0
2470 }, { // param2
2471 .channelQuant = {},
2472 .data = TestBuffer::createFromVector<float>({1.5f}),
2473 .dimensions = {},
2474 .isIgnored = false,
2475 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2476 .numberOfConsumers = 1,
2477 .scale = 0.0f,
2478 .type = TestOperandType::FLOAT32,
2479 .zeroPoint = 0
2480 }, { // param3
2481 .channelQuant = {},
2482 .data = TestBuffer::createFromVector<float>({1.5f}),
2483 .dimensions = {},
2484 .isIgnored = false,
2485 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2486 .numberOfConsumers = 1,
2487 .scale = 0.0f,
2488 .type = TestOperandType::FLOAT32,
2489 .zeroPoint = 0
2490 }, { // layout
2491 .channelQuant = {},
2492 .data = TestBuffer::createFromVector<bool8>({true}),
2493 .dimensions = {},
2494 .isIgnored = false,
2495 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2496 .numberOfConsumers = 1,
2497 .scale = 0.0f,
2498 .type = TestOperandType::BOOL,
2499 .zeroPoint = 0
2500 }, { // op4
2501 .channelQuant = {},
2502 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
2503 .dimensions = {1, 1, 3, 3},
2504 .isIgnored = false,
2505 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2506 .numberOfConsumers = 0,
2507 .scale = 0.0f,
2508 .type = TestOperandType::TENSOR_FLOAT32,
2509 .zeroPoint = 0
2510 }},
2511 .operations = {{
2512 .inputs = {0, 1, 2, 3},
2513 .outputs = {4},
2514 .type = TestOperationType::RESIZE_BILINEAR
2515 }},
2516 .outputIndexes = {4}
2517 },
2518 .minSupportedVersion = TestHalVersion::UNKNOWN,
2519 .referenced = {}
2520 };
2521 return model;
2522 }
2523
2524 const auto dummy_test_model_scale_nchw_relaxed = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_relaxed", get_test_model_scale_nchw_relaxed());
2525
2526 } // namespace generated_tests::resize_bilinear_v1_2
2527
2528 namespace generated_tests::resize_bilinear_v1_2 {
2529
get_test_model_scale_nchw_relaxed_all_inputs_as_internal()2530 const TestModel& get_test_model_scale_nchw_relaxed_all_inputs_as_internal() {
2531 static TestModel model = {
2532 .expectFailure = false,
2533 .expectedMultinomialDistributionTolerance = 0,
2534 .isRelaxed = true,
2535 .main = { // scale
2536 .inputIndexes = {5},
2537 .operands = {{ // op1
2538 .channelQuant = {},
2539 .data = TestBuffer::createFromVector<float>({}),
2540 .dimensions = {1, 1, 2, 2},
2541 .isIgnored = false,
2542 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2543 .numberOfConsumers = 1,
2544 .scale = 0.0f,
2545 .type = TestOperandType::TENSOR_FLOAT32,
2546 .zeroPoint = 0
2547 }, { // param2
2548 .channelQuant = {},
2549 .data = TestBuffer::createFromVector<float>({1.5f}),
2550 .dimensions = {},
2551 .isIgnored = false,
2552 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2553 .numberOfConsumers = 1,
2554 .scale = 0.0f,
2555 .type = TestOperandType::FLOAT32,
2556 .zeroPoint = 0
2557 }, { // param3
2558 .channelQuant = {},
2559 .data = TestBuffer::createFromVector<float>({1.5f}),
2560 .dimensions = {},
2561 .isIgnored = false,
2562 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2563 .numberOfConsumers = 1,
2564 .scale = 0.0f,
2565 .type = TestOperandType::FLOAT32,
2566 .zeroPoint = 0
2567 }, { // layout
2568 .channelQuant = {},
2569 .data = TestBuffer::createFromVector<bool8>({true}),
2570 .dimensions = {},
2571 .isIgnored = false,
2572 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2573 .numberOfConsumers = 1,
2574 .scale = 0.0f,
2575 .type = TestOperandType::BOOL,
2576 .zeroPoint = 0
2577 }, { // op4
2578 .channelQuant = {},
2579 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 1.0f, 1.666666667f, 1.666666667f, 1.666666667f, 2.0f, 2.0f, 2.0f}),
2580 .dimensions = {1, 1, 3, 3},
2581 .isIgnored = false,
2582 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2583 .numberOfConsumers = 0,
2584 .scale = 0.0f,
2585 .type = TestOperandType::TENSOR_FLOAT32,
2586 .zeroPoint = 0
2587 }, { // op1_new
2588 .channelQuant = {},
2589 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 2.0f, 2.0f}),
2590 .dimensions = {1, 1, 2, 2},
2591 .isIgnored = false,
2592 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2593 .numberOfConsumers = 1,
2594 .scale = 0.0f,
2595 .type = TestOperandType::TENSOR_FLOAT32,
2596 .zeroPoint = 0
2597 }, { // dummy13
2598 .channelQuant = {},
2599 .data = TestBuffer::createFromVector<float>({0.0f}),
2600 .dimensions = {1},
2601 .isIgnored = false,
2602 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2603 .numberOfConsumers = 1,
2604 .scale = 0.0f,
2605 .type = TestOperandType::TENSOR_FLOAT32,
2606 .zeroPoint = 0
2607 }, { // param55
2608 .channelQuant = {},
2609 .data = TestBuffer::createFromVector<int32_t>({0}),
2610 .dimensions = {},
2611 .isIgnored = false,
2612 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2613 .numberOfConsumers = 1,
2614 .scale = 0.0f,
2615 .type = TestOperandType::INT32,
2616 .zeroPoint = 0
2617 }},
2618 .operations = {{
2619 .inputs = {5, 6, 7},
2620 .outputs = {0},
2621 .type = TestOperationType::ADD
2622 }, {
2623 .inputs = {0, 1, 2, 3},
2624 .outputs = {4},
2625 .type = TestOperationType::RESIZE_BILINEAR
2626 }},
2627 .outputIndexes = {4}
2628 },
2629 .minSupportedVersion = TestHalVersion::UNKNOWN,
2630 .referenced = {}
2631 };
2632 return model;
2633 }
2634
2635 const auto dummy_test_model_scale_nchw_relaxed_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_relaxed_all_inputs_as_internal", get_test_model_scale_nchw_relaxed_all_inputs_as_internal());
2636
2637 } // namespace generated_tests::resize_bilinear_v1_2
2638
2639 namespace generated_tests::resize_bilinear_v1_2 {
2640
get_test_model_scale_nchw_float16()2641 const TestModel& get_test_model_scale_nchw_float16() {
2642 static TestModel model = {
2643 .expectFailure = false,
2644 .expectedMultinomialDistributionTolerance = 0,
2645 .isRelaxed = false,
2646 .main = { // scale
2647 .inputIndexes = {0},
2648 .operands = {{ // op1
2649 .channelQuant = {},
2650 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 2.0f, 2.0f}),
2651 .dimensions = {1, 1, 2, 2},
2652 .isIgnored = false,
2653 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2654 .numberOfConsumers = 1,
2655 .scale = 0.0f,
2656 .type = TestOperandType::TENSOR_FLOAT16,
2657 .zeroPoint = 0
2658 }, { // param2
2659 .channelQuant = {},
2660 .data = TestBuffer::createFromVector<_Float16>({1.5f}),
2661 .dimensions = {},
2662 .isIgnored = false,
2663 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2664 .numberOfConsumers = 1,
2665 .scale = 0.0f,
2666 .type = TestOperandType::FLOAT16,
2667 .zeroPoint = 0
2668 }, { // param3
2669 .channelQuant = {},
2670 .data = TestBuffer::createFromVector<_Float16>({1.5f}),
2671 .dimensions = {},
2672 .isIgnored = false,
2673 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2674 .numberOfConsumers = 1,
2675 .scale = 0.0f,
2676 .type = TestOperandType::FLOAT16,
2677 .zeroPoint = 0
2678 }, { // layout
2679 .channelQuant = {},
2680 .data = TestBuffer::createFromVector<bool8>({true}),
2681 .dimensions = {},
2682 .isIgnored = false,
2683 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2684 .numberOfConsumers = 1,
2685 .scale = 0.0f,
2686 .type = TestOperandType::BOOL,
2687 .zeroPoint = 0
2688 }, { // op4
2689 .channelQuant = {},
2690 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 1.0f, 1.6666666269302368f, 1.6666666269302368f, 1.6666666269302368f, 2.0f, 2.0f, 2.0f}),
2691 .dimensions = {1, 1, 3, 3},
2692 .isIgnored = false,
2693 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2694 .numberOfConsumers = 0,
2695 .scale = 0.0f,
2696 .type = TestOperandType::TENSOR_FLOAT16,
2697 .zeroPoint = 0
2698 }},
2699 .operations = {{
2700 .inputs = {0, 1, 2, 3},
2701 .outputs = {4},
2702 .type = TestOperationType::RESIZE_BILINEAR
2703 }},
2704 .outputIndexes = {4}
2705 },
2706 .minSupportedVersion = TestHalVersion::V1_2,
2707 .referenced = {}
2708 };
2709 return model;
2710 }
2711
2712 const auto dummy_test_model_scale_nchw_float16 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_float16", get_test_model_scale_nchw_float16());
2713
2714 } // namespace generated_tests::resize_bilinear_v1_2
2715
2716 namespace generated_tests::resize_bilinear_v1_2 {
2717
get_test_model_scale_nchw_float16_all_inputs_as_internal()2718 const TestModel& get_test_model_scale_nchw_float16_all_inputs_as_internal() {
2719 static TestModel model = {
2720 .expectFailure = false,
2721 .expectedMultinomialDistributionTolerance = 0,
2722 .isRelaxed = false,
2723 .main = { // scale
2724 .inputIndexes = {5},
2725 .operands = {{ // op1
2726 .channelQuant = {},
2727 .data = TestBuffer::createFromVector<_Float16>({}),
2728 .dimensions = {1, 1, 2, 2},
2729 .isIgnored = false,
2730 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2731 .numberOfConsumers = 1,
2732 .scale = 0.0f,
2733 .type = TestOperandType::TENSOR_FLOAT16,
2734 .zeroPoint = 0
2735 }, { // param2
2736 .channelQuant = {},
2737 .data = TestBuffer::createFromVector<_Float16>({1.5f}),
2738 .dimensions = {},
2739 .isIgnored = false,
2740 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2741 .numberOfConsumers = 1,
2742 .scale = 0.0f,
2743 .type = TestOperandType::FLOAT16,
2744 .zeroPoint = 0
2745 }, { // param3
2746 .channelQuant = {},
2747 .data = TestBuffer::createFromVector<_Float16>({1.5f}),
2748 .dimensions = {},
2749 .isIgnored = false,
2750 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2751 .numberOfConsumers = 1,
2752 .scale = 0.0f,
2753 .type = TestOperandType::FLOAT16,
2754 .zeroPoint = 0
2755 }, { // layout
2756 .channelQuant = {},
2757 .data = TestBuffer::createFromVector<bool8>({true}),
2758 .dimensions = {},
2759 .isIgnored = false,
2760 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2761 .numberOfConsumers = 1,
2762 .scale = 0.0f,
2763 .type = TestOperandType::BOOL,
2764 .zeroPoint = 0
2765 }, { // op4
2766 .channelQuant = {},
2767 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 1.0f, 1.6666666269302368f, 1.6666666269302368f, 1.6666666269302368f, 2.0f, 2.0f, 2.0f}),
2768 .dimensions = {1, 1, 3, 3},
2769 .isIgnored = false,
2770 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2771 .numberOfConsumers = 0,
2772 .scale = 0.0f,
2773 .type = TestOperandType::TENSOR_FLOAT16,
2774 .zeroPoint = 0
2775 }, { // op1_new
2776 .channelQuant = {},
2777 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 2.0f, 2.0f}),
2778 .dimensions = {1, 1, 2, 2},
2779 .isIgnored = false,
2780 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2781 .numberOfConsumers = 1,
2782 .scale = 0.0f,
2783 .type = TestOperandType::TENSOR_FLOAT16,
2784 .zeroPoint = 0
2785 }, { // dummy14
2786 .channelQuant = {},
2787 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
2788 .dimensions = {1},
2789 .isIgnored = false,
2790 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2791 .numberOfConsumers = 1,
2792 .scale = 0.0f,
2793 .type = TestOperandType::TENSOR_FLOAT16,
2794 .zeroPoint = 0
2795 }, { // param56
2796 .channelQuant = {},
2797 .data = TestBuffer::createFromVector<int32_t>({0}),
2798 .dimensions = {},
2799 .isIgnored = false,
2800 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2801 .numberOfConsumers = 1,
2802 .scale = 0.0f,
2803 .type = TestOperandType::INT32,
2804 .zeroPoint = 0
2805 }},
2806 .operations = {{
2807 .inputs = {5, 6, 7},
2808 .outputs = {0},
2809 .type = TestOperationType::ADD
2810 }, {
2811 .inputs = {0, 1, 2, 3},
2812 .outputs = {4},
2813 .type = TestOperationType::RESIZE_BILINEAR
2814 }},
2815 .outputIndexes = {4}
2816 },
2817 .minSupportedVersion = TestHalVersion::V1_2,
2818 .referenced = {}
2819 };
2820 return model;
2821 }
2822
2823 const auto dummy_test_model_scale_nchw_float16_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_float16_all_inputs_as_internal", get_test_model_scale_nchw_float16_all_inputs_as_internal());
2824
2825 } // namespace generated_tests::resize_bilinear_v1_2
2826
2827 namespace generated_tests::resize_bilinear_v1_2 {
2828
get_test_model_scale_nchw_quant8()2829 const TestModel& get_test_model_scale_nchw_quant8() {
2830 static TestModel model = {
2831 .expectFailure = false,
2832 .expectedMultinomialDistributionTolerance = 0,
2833 .isRelaxed = false,
2834 .main = { // scale
2835 .inputIndexes = {0},
2836 .operands = {{ // op1
2837 .channelQuant = {},
2838 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 200, 200}),
2839 .dimensions = {1, 1, 2, 2},
2840 .isIgnored = false,
2841 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2842 .numberOfConsumers = 1,
2843 .scale = 0.01f,
2844 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2845 .zeroPoint = 0
2846 }, { // param2
2847 .channelQuant = {},
2848 .data = TestBuffer::createFromVector<float>({1.5f}),
2849 .dimensions = {},
2850 .isIgnored = false,
2851 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2852 .numberOfConsumers = 1,
2853 .scale = 0.0f,
2854 .type = TestOperandType::FLOAT32,
2855 .zeroPoint = 0
2856 }, { // param3
2857 .channelQuant = {},
2858 .data = TestBuffer::createFromVector<float>({1.5f}),
2859 .dimensions = {},
2860 .isIgnored = false,
2861 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2862 .numberOfConsumers = 1,
2863 .scale = 0.0f,
2864 .type = TestOperandType::FLOAT32,
2865 .zeroPoint = 0
2866 }, { // layout
2867 .channelQuant = {},
2868 .data = TestBuffer::createFromVector<bool8>({true}),
2869 .dimensions = {},
2870 .isIgnored = false,
2871 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2872 .numberOfConsumers = 1,
2873 .scale = 0.0f,
2874 .type = TestOperandType::BOOL,
2875 .zeroPoint = 0
2876 }, { // op4
2877 .channelQuant = {},
2878 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 100, 167, 167, 167, 200, 200, 200}),
2879 .dimensions = {1, 1, 3, 3},
2880 .isIgnored = false,
2881 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2882 .numberOfConsumers = 0,
2883 .scale = 0.01f,
2884 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2885 .zeroPoint = 0
2886 }},
2887 .operations = {{
2888 .inputs = {0, 1, 2, 3},
2889 .outputs = {4},
2890 .type = TestOperationType::RESIZE_BILINEAR
2891 }},
2892 .outputIndexes = {4}
2893 },
2894 .minSupportedVersion = TestHalVersion::V1_2,
2895 .referenced = {}
2896 };
2897 return model;
2898 }
2899
2900 const auto dummy_test_model_scale_nchw_quant8 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_quant8", get_test_model_scale_nchw_quant8());
2901
2902 } // namespace generated_tests::resize_bilinear_v1_2
2903
2904 namespace generated_tests::resize_bilinear_v1_2 {
2905
get_test_model_scale_nchw_quant8_all_inputs_as_internal()2906 const TestModel& get_test_model_scale_nchw_quant8_all_inputs_as_internal() {
2907 static TestModel model = {
2908 .expectFailure = false,
2909 .expectedMultinomialDistributionTolerance = 0,
2910 .isRelaxed = false,
2911 .main = { // scale
2912 .inputIndexes = {5},
2913 .operands = {{ // op1
2914 .channelQuant = {},
2915 .data = TestBuffer::createFromVector<uint8_t>({}),
2916 .dimensions = {1, 1, 2, 2},
2917 .isIgnored = false,
2918 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
2919 .numberOfConsumers = 1,
2920 .scale = 0.01f,
2921 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2922 .zeroPoint = 0
2923 }, { // param2
2924 .channelQuant = {},
2925 .data = TestBuffer::createFromVector<float>({1.5f}),
2926 .dimensions = {},
2927 .isIgnored = false,
2928 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2929 .numberOfConsumers = 1,
2930 .scale = 0.0f,
2931 .type = TestOperandType::FLOAT32,
2932 .zeroPoint = 0
2933 }, { // param3
2934 .channelQuant = {},
2935 .data = TestBuffer::createFromVector<float>({1.5f}),
2936 .dimensions = {},
2937 .isIgnored = false,
2938 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2939 .numberOfConsumers = 1,
2940 .scale = 0.0f,
2941 .type = TestOperandType::FLOAT32,
2942 .zeroPoint = 0
2943 }, { // layout
2944 .channelQuant = {},
2945 .data = TestBuffer::createFromVector<bool8>({true}),
2946 .dimensions = {},
2947 .isIgnored = false,
2948 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2949 .numberOfConsumers = 1,
2950 .scale = 0.0f,
2951 .type = TestOperandType::BOOL,
2952 .zeroPoint = 0
2953 }, { // op4
2954 .channelQuant = {},
2955 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 100, 167, 167, 167, 200, 200, 200}),
2956 .dimensions = {1, 1, 3, 3},
2957 .isIgnored = false,
2958 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
2959 .numberOfConsumers = 0,
2960 .scale = 0.01f,
2961 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2962 .zeroPoint = 0
2963 }, { // op1_new
2964 .channelQuant = {},
2965 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 200, 200}),
2966 .dimensions = {1, 1, 2, 2},
2967 .isIgnored = false,
2968 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
2969 .numberOfConsumers = 1,
2970 .scale = 0.01f,
2971 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2972 .zeroPoint = 0
2973 }, { // dummy15
2974 .channelQuant = {},
2975 .data = TestBuffer::createFromVector<uint8_t>({0}),
2976 .dimensions = {1},
2977 .isIgnored = false,
2978 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2979 .numberOfConsumers = 1,
2980 .scale = 0.01f,
2981 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
2982 .zeroPoint = 0
2983 }, { // param57
2984 .channelQuant = {},
2985 .data = TestBuffer::createFromVector<int32_t>({0}),
2986 .dimensions = {},
2987 .isIgnored = false,
2988 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
2989 .numberOfConsumers = 1,
2990 .scale = 0.0f,
2991 .type = TestOperandType::INT32,
2992 .zeroPoint = 0
2993 }},
2994 .operations = {{
2995 .inputs = {5, 6, 7},
2996 .outputs = {0},
2997 .type = TestOperationType::ADD
2998 }, {
2999 .inputs = {0, 1, 2, 3},
3000 .outputs = {4},
3001 .type = TestOperationType::RESIZE_BILINEAR
3002 }},
3003 .outputIndexes = {4}
3004 },
3005 .minSupportedVersion = TestHalVersion::V1_2,
3006 .referenced = {}
3007 };
3008 return model;
3009 }
3010
3011 const auto dummy_test_model_scale_nchw_quant8_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_quant8_all_inputs_as_internal", get_test_model_scale_nchw_quant8_all_inputs_as_internal());
3012
3013 } // namespace generated_tests::resize_bilinear_v1_2
3014
3015 namespace generated_tests::resize_bilinear_v1_2 {
3016
get_test_model_shape_nhwc_2()3017 const TestModel& get_test_model_shape_nhwc_2() {
3018 static TestModel model = {
3019 .expectFailure = false,
3020 .expectedMultinomialDistributionTolerance = 0,
3021 .isRelaxed = false,
3022 .main = { // shape
3023 .inputIndexes = {0},
3024 .operands = {{ // op11
3025 .channelQuant = {},
3026 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 6.0f, 10.0f, 9.0f, 10.0f, 12.0f, 16.0f}),
3027 .dimensions = {1, 2, 2, 2},
3028 .isIgnored = false,
3029 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3030 .numberOfConsumers = 1,
3031 .scale = 0.0f,
3032 .type = TestOperandType::TENSOR_FLOAT32,
3033 .zeroPoint = 0
3034 }, { // param4
3035 .channelQuant = {},
3036 .data = TestBuffer::createFromVector<int32_t>({3}),
3037 .dimensions = {},
3038 .isIgnored = false,
3039 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3040 .numberOfConsumers = 1,
3041 .scale = 0.0f,
3042 .type = TestOperandType::INT32,
3043 .zeroPoint = 0
3044 }, { // param5
3045 .channelQuant = {},
3046 .data = TestBuffer::createFromVector<int32_t>({3}),
3047 .dimensions = {},
3048 .isIgnored = false,
3049 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3050 .numberOfConsumers = 1,
3051 .scale = 0.0f,
3052 .type = TestOperandType::INT32,
3053 .zeroPoint = 0
3054 }, { // layout
3055 .channelQuant = {},
3056 .data = TestBuffer::createFromVector<bool8>({false}),
3057 .dimensions = {},
3058 .isIgnored = false,
3059 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3060 .numberOfConsumers = 1,
3061 .scale = 0.0f,
3062 .type = TestOperandType::BOOL,
3063 .zeroPoint = 0
3064 }, { // op41
3065 .channelQuant = {},
3066 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 5.0f, 8.0f, 6.0f, 10.0f, 7.0f, 8.0f, 9.0f, 12.0f, 10.0f, 14.0f, 9.0f, 10.0f, 11.0f, 14.0f, 12.0f, 16.0f}),
3067 .dimensions = {1, 3, 3, 2},
3068 .isIgnored = false,
3069 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3070 .numberOfConsumers = 0,
3071 .scale = 0.0f,
3072 .type = TestOperandType::TENSOR_FLOAT32,
3073 .zeroPoint = 0
3074 }},
3075 .operations = {{
3076 .inputs = {0, 1, 2, 3},
3077 .outputs = {4},
3078 .type = TestOperationType::RESIZE_BILINEAR
3079 }},
3080 .outputIndexes = {4}
3081 },
3082 .minSupportedVersion = TestHalVersion::V1_0,
3083 .referenced = {}
3084 };
3085 return model;
3086 }
3087
3088 const auto dummy_test_model_shape_nhwc_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_2", get_test_model_shape_nhwc_2());
3089
3090 } // namespace generated_tests::resize_bilinear_v1_2
3091
3092 namespace generated_tests::resize_bilinear_v1_2 {
3093
get_test_model_shape_nhwc_all_inputs_as_internal_2()3094 const TestModel& get_test_model_shape_nhwc_all_inputs_as_internal_2() {
3095 static TestModel model = {
3096 .expectFailure = false,
3097 .expectedMultinomialDistributionTolerance = 0,
3098 .isRelaxed = false,
3099 .main = { // shape
3100 .inputIndexes = {5},
3101 .operands = {{ // op11
3102 .channelQuant = {},
3103 .data = TestBuffer::createFromVector<float>({}),
3104 .dimensions = {1, 2, 2, 2},
3105 .isIgnored = false,
3106 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3107 .numberOfConsumers = 1,
3108 .scale = 0.0f,
3109 .type = TestOperandType::TENSOR_FLOAT32,
3110 .zeroPoint = 0
3111 }, { // param4
3112 .channelQuant = {},
3113 .data = TestBuffer::createFromVector<int32_t>({3}),
3114 .dimensions = {},
3115 .isIgnored = false,
3116 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3117 .numberOfConsumers = 1,
3118 .scale = 0.0f,
3119 .type = TestOperandType::INT32,
3120 .zeroPoint = 0
3121 }, { // param5
3122 .channelQuant = {},
3123 .data = TestBuffer::createFromVector<int32_t>({3}),
3124 .dimensions = {},
3125 .isIgnored = false,
3126 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3127 .numberOfConsumers = 1,
3128 .scale = 0.0f,
3129 .type = TestOperandType::INT32,
3130 .zeroPoint = 0
3131 }, { // layout
3132 .channelQuant = {},
3133 .data = TestBuffer::createFromVector<bool8>({false}),
3134 .dimensions = {},
3135 .isIgnored = false,
3136 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3137 .numberOfConsumers = 1,
3138 .scale = 0.0f,
3139 .type = TestOperandType::BOOL,
3140 .zeroPoint = 0
3141 }, { // op41
3142 .channelQuant = {},
3143 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 5.0f, 8.0f, 6.0f, 10.0f, 7.0f, 8.0f, 9.0f, 12.0f, 10.0f, 14.0f, 9.0f, 10.0f, 11.0f, 14.0f, 12.0f, 16.0f}),
3144 .dimensions = {1, 3, 3, 2},
3145 .isIgnored = false,
3146 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3147 .numberOfConsumers = 0,
3148 .scale = 0.0f,
3149 .type = TestOperandType::TENSOR_FLOAT32,
3150 .zeroPoint = 0
3151 }, { // op11_new
3152 .channelQuant = {},
3153 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 6.0f, 10.0f, 9.0f, 10.0f, 12.0f, 16.0f}),
3154 .dimensions = {1, 2, 2, 2},
3155 .isIgnored = false,
3156 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3157 .numberOfConsumers = 1,
3158 .scale = 0.0f,
3159 .type = TestOperandType::TENSOR_FLOAT32,
3160 .zeroPoint = 0
3161 }, { // dummy16
3162 .channelQuant = {},
3163 .data = TestBuffer::createFromVector<float>({0.0f}),
3164 .dimensions = {1},
3165 .isIgnored = false,
3166 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3167 .numberOfConsumers = 1,
3168 .scale = 0.0f,
3169 .type = TestOperandType::TENSOR_FLOAT32,
3170 .zeroPoint = 0
3171 }, { // param58
3172 .channelQuant = {},
3173 .data = TestBuffer::createFromVector<int32_t>({0}),
3174 .dimensions = {},
3175 .isIgnored = false,
3176 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3177 .numberOfConsumers = 1,
3178 .scale = 0.0f,
3179 .type = TestOperandType::INT32,
3180 .zeroPoint = 0
3181 }},
3182 .operations = {{
3183 .inputs = {5, 6, 7},
3184 .outputs = {0},
3185 .type = TestOperationType::ADD
3186 }, {
3187 .inputs = {0, 1, 2, 3},
3188 .outputs = {4},
3189 .type = TestOperationType::RESIZE_BILINEAR
3190 }},
3191 .outputIndexes = {4}
3192 },
3193 .minSupportedVersion = TestHalVersion::V1_0,
3194 .referenced = {}
3195 };
3196 return model;
3197 }
3198
3199 const auto dummy_test_model_shape_nhwc_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_all_inputs_as_internal_2", get_test_model_shape_nhwc_all_inputs_as_internal_2());
3200
3201 } // namespace generated_tests::resize_bilinear_v1_2
3202
3203 namespace generated_tests::resize_bilinear_v1_2 {
3204
get_test_model_shape_nhwc_relaxed_2()3205 const TestModel& get_test_model_shape_nhwc_relaxed_2() {
3206 static TestModel model = {
3207 .expectFailure = false,
3208 .expectedMultinomialDistributionTolerance = 0,
3209 .isRelaxed = true,
3210 .main = { // shape
3211 .inputIndexes = {0},
3212 .operands = {{ // op11
3213 .channelQuant = {},
3214 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 6.0f, 10.0f, 9.0f, 10.0f, 12.0f, 16.0f}),
3215 .dimensions = {1, 2, 2, 2},
3216 .isIgnored = false,
3217 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3218 .numberOfConsumers = 1,
3219 .scale = 0.0f,
3220 .type = TestOperandType::TENSOR_FLOAT32,
3221 .zeroPoint = 0
3222 }, { // param4
3223 .channelQuant = {},
3224 .data = TestBuffer::createFromVector<int32_t>({3}),
3225 .dimensions = {},
3226 .isIgnored = false,
3227 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3228 .numberOfConsumers = 1,
3229 .scale = 0.0f,
3230 .type = TestOperandType::INT32,
3231 .zeroPoint = 0
3232 }, { // param5
3233 .channelQuant = {},
3234 .data = TestBuffer::createFromVector<int32_t>({3}),
3235 .dimensions = {},
3236 .isIgnored = false,
3237 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3238 .numberOfConsumers = 1,
3239 .scale = 0.0f,
3240 .type = TestOperandType::INT32,
3241 .zeroPoint = 0
3242 }, { // layout
3243 .channelQuant = {},
3244 .data = TestBuffer::createFromVector<bool8>({false}),
3245 .dimensions = {},
3246 .isIgnored = false,
3247 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3248 .numberOfConsumers = 1,
3249 .scale = 0.0f,
3250 .type = TestOperandType::BOOL,
3251 .zeroPoint = 0
3252 }, { // op41
3253 .channelQuant = {},
3254 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 5.0f, 8.0f, 6.0f, 10.0f, 7.0f, 8.0f, 9.0f, 12.0f, 10.0f, 14.0f, 9.0f, 10.0f, 11.0f, 14.0f, 12.0f, 16.0f}),
3255 .dimensions = {1, 3, 3, 2},
3256 .isIgnored = false,
3257 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3258 .numberOfConsumers = 0,
3259 .scale = 0.0f,
3260 .type = TestOperandType::TENSOR_FLOAT32,
3261 .zeroPoint = 0
3262 }},
3263 .operations = {{
3264 .inputs = {0, 1, 2, 3},
3265 .outputs = {4},
3266 .type = TestOperationType::RESIZE_BILINEAR
3267 }},
3268 .outputIndexes = {4}
3269 },
3270 .minSupportedVersion = TestHalVersion::UNKNOWN,
3271 .referenced = {}
3272 };
3273 return model;
3274 }
3275
3276 const auto dummy_test_model_shape_nhwc_relaxed_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_relaxed_2", get_test_model_shape_nhwc_relaxed_2());
3277
3278 } // namespace generated_tests::resize_bilinear_v1_2
3279
3280 namespace generated_tests::resize_bilinear_v1_2 {
3281
get_test_model_shape_nhwc_relaxed_all_inputs_as_internal_2()3282 const TestModel& get_test_model_shape_nhwc_relaxed_all_inputs_as_internal_2() {
3283 static TestModel model = {
3284 .expectFailure = false,
3285 .expectedMultinomialDistributionTolerance = 0,
3286 .isRelaxed = true,
3287 .main = { // shape
3288 .inputIndexes = {5},
3289 .operands = {{ // op11
3290 .channelQuant = {},
3291 .data = TestBuffer::createFromVector<float>({}),
3292 .dimensions = {1, 2, 2, 2},
3293 .isIgnored = false,
3294 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3295 .numberOfConsumers = 1,
3296 .scale = 0.0f,
3297 .type = TestOperandType::TENSOR_FLOAT32,
3298 .zeroPoint = 0
3299 }, { // param4
3300 .channelQuant = {},
3301 .data = TestBuffer::createFromVector<int32_t>({3}),
3302 .dimensions = {},
3303 .isIgnored = false,
3304 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3305 .numberOfConsumers = 1,
3306 .scale = 0.0f,
3307 .type = TestOperandType::INT32,
3308 .zeroPoint = 0
3309 }, { // param5
3310 .channelQuant = {},
3311 .data = TestBuffer::createFromVector<int32_t>({3}),
3312 .dimensions = {},
3313 .isIgnored = false,
3314 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3315 .numberOfConsumers = 1,
3316 .scale = 0.0f,
3317 .type = TestOperandType::INT32,
3318 .zeroPoint = 0
3319 }, { // layout
3320 .channelQuant = {},
3321 .data = TestBuffer::createFromVector<bool8>({false}),
3322 .dimensions = {},
3323 .isIgnored = false,
3324 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3325 .numberOfConsumers = 1,
3326 .scale = 0.0f,
3327 .type = TestOperandType::BOOL,
3328 .zeroPoint = 0
3329 }, { // op41
3330 .channelQuant = {},
3331 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 5.0f, 8.0f, 6.0f, 10.0f, 7.0f, 8.0f, 9.0f, 12.0f, 10.0f, 14.0f, 9.0f, 10.0f, 11.0f, 14.0f, 12.0f, 16.0f}),
3332 .dimensions = {1, 3, 3, 2},
3333 .isIgnored = false,
3334 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3335 .numberOfConsumers = 0,
3336 .scale = 0.0f,
3337 .type = TestOperandType::TENSOR_FLOAT32,
3338 .zeroPoint = 0
3339 }, { // op11_new
3340 .channelQuant = {},
3341 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 6.0f, 10.0f, 9.0f, 10.0f, 12.0f, 16.0f}),
3342 .dimensions = {1, 2, 2, 2},
3343 .isIgnored = false,
3344 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3345 .numberOfConsumers = 1,
3346 .scale = 0.0f,
3347 .type = TestOperandType::TENSOR_FLOAT32,
3348 .zeroPoint = 0
3349 }, { // dummy17
3350 .channelQuant = {},
3351 .data = TestBuffer::createFromVector<float>({0.0f}),
3352 .dimensions = {1},
3353 .isIgnored = false,
3354 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3355 .numberOfConsumers = 1,
3356 .scale = 0.0f,
3357 .type = TestOperandType::TENSOR_FLOAT32,
3358 .zeroPoint = 0
3359 }, { // param59
3360 .channelQuant = {},
3361 .data = TestBuffer::createFromVector<int32_t>({0}),
3362 .dimensions = {},
3363 .isIgnored = false,
3364 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3365 .numberOfConsumers = 1,
3366 .scale = 0.0f,
3367 .type = TestOperandType::INT32,
3368 .zeroPoint = 0
3369 }},
3370 .operations = {{
3371 .inputs = {5, 6, 7},
3372 .outputs = {0},
3373 .type = TestOperationType::ADD
3374 }, {
3375 .inputs = {0, 1, 2, 3},
3376 .outputs = {4},
3377 .type = TestOperationType::RESIZE_BILINEAR
3378 }},
3379 .outputIndexes = {4}
3380 },
3381 .minSupportedVersion = TestHalVersion::UNKNOWN,
3382 .referenced = {}
3383 };
3384 return model;
3385 }
3386
3387 const auto dummy_test_model_shape_nhwc_relaxed_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_relaxed_all_inputs_as_internal_2", get_test_model_shape_nhwc_relaxed_all_inputs_as_internal_2());
3388
3389 } // namespace generated_tests::resize_bilinear_v1_2
3390
3391 namespace generated_tests::resize_bilinear_v1_2 {
3392
get_test_model_shape_nhwc_float16_2()3393 const TestModel& get_test_model_shape_nhwc_float16_2() {
3394 static TestModel model = {
3395 .expectFailure = false,
3396 .expectedMultinomialDistributionTolerance = 0,
3397 .isRelaxed = false,
3398 .main = { // shape
3399 .inputIndexes = {0},
3400 .operands = {{ // op11
3401 .channelQuant = {},
3402 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f, 6.0f, 10.0f, 9.0f, 10.0f, 12.0f, 16.0f}),
3403 .dimensions = {1, 2, 2, 2},
3404 .isIgnored = false,
3405 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3406 .numberOfConsumers = 1,
3407 .scale = 0.0f,
3408 .type = TestOperandType::TENSOR_FLOAT16,
3409 .zeroPoint = 0
3410 }, { // param4
3411 .channelQuant = {},
3412 .data = TestBuffer::createFromVector<int32_t>({3}),
3413 .dimensions = {},
3414 .isIgnored = false,
3415 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3416 .numberOfConsumers = 1,
3417 .scale = 0.0f,
3418 .type = TestOperandType::INT32,
3419 .zeroPoint = 0
3420 }, { // param5
3421 .channelQuant = {},
3422 .data = TestBuffer::createFromVector<int32_t>({3}),
3423 .dimensions = {},
3424 .isIgnored = false,
3425 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3426 .numberOfConsumers = 1,
3427 .scale = 0.0f,
3428 .type = TestOperandType::INT32,
3429 .zeroPoint = 0
3430 }, { // layout
3431 .channelQuant = {},
3432 .data = TestBuffer::createFromVector<bool8>({false}),
3433 .dimensions = {},
3434 .isIgnored = false,
3435 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3436 .numberOfConsumers = 1,
3437 .scale = 0.0f,
3438 .type = TestOperandType::BOOL,
3439 .zeroPoint = 0
3440 }, { // op41
3441 .channelQuant = {},
3442 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f, 5.0f, 8.0f, 6.0f, 10.0f, 7.0f, 8.0f, 9.0f, 12.0f, 10.0f, 14.0f, 9.0f, 10.0f, 11.0f, 14.0f, 12.0f, 16.0f}),
3443 .dimensions = {1, 3, 3, 2},
3444 .isIgnored = false,
3445 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3446 .numberOfConsumers = 0,
3447 .scale = 0.0f,
3448 .type = TestOperandType::TENSOR_FLOAT16,
3449 .zeroPoint = 0
3450 }},
3451 .operations = {{
3452 .inputs = {0, 1, 2, 3},
3453 .outputs = {4},
3454 .type = TestOperationType::RESIZE_BILINEAR
3455 }},
3456 .outputIndexes = {4}
3457 },
3458 .minSupportedVersion = TestHalVersion::V1_2,
3459 .referenced = {}
3460 };
3461 return model;
3462 }
3463
3464 const auto dummy_test_model_shape_nhwc_float16_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_float16_2", get_test_model_shape_nhwc_float16_2());
3465
3466 } // namespace generated_tests::resize_bilinear_v1_2
3467
3468 namespace generated_tests::resize_bilinear_v1_2 {
3469
get_test_model_shape_nhwc_float16_all_inputs_as_internal_2()3470 const TestModel& get_test_model_shape_nhwc_float16_all_inputs_as_internal_2() {
3471 static TestModel model = {
3472 .expectFailure = false,
3473 .expectedMultinomialDistributionTolerance = 0,
3474 .isRelaxed = false,
3475 .main = { // shape
3476 .inputIndexes = {5},
3477 .operands = {{ // op11
3478 .channelQuant = {},
3479 .data = TestBuffer::createFromVector<_Float16>({}),
3480 .dimensions = {1, 2, 2, 2},
3481 .isIgnored = false,
3482 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3483 .numberOfConsumers = 1,
3484 .scale = 0.0f,
3485 .type = TestOperandType::TENSOR_FLOAT16,
3486 .zeroPoint = 0
3487 }, { // param4
3488 .channelQuant = {},
3489 .data = TestBuffer::createFromVector<int32_t>({3}),
3490 .dimensions = {},
3491 .isIgnored = false,
3492 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3493 .numberOfConsumers = 1,
3494 .scale = 0.0f,
3495 .type = TestOperandType::INT32,
3496 .zeroPoint = 0
3497 }, { // param5
3498 .channelQuant = {},
3499 .data = TestBuffer::createFromVector<int32_t>({3}),
3500 .dimensions = {},
3501 .isIgnored = false,
3502 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3503 .numberOfConsumers = 1,
3504 .scale = 0.0f,
3505 .type = TestOperandType::INT32,
3506 .zeroPoint = 0
3507 }, { // layout
3508 .channelQuant = {},
3509 .data = TestBuffer::createFromVector<bool8>({false}),
3510 .dimensions = {},
3511 .isIgnored = false,
3512 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3513 .numberOfConsumers = 1,
3514 .scale = 0.0f,
3515 .type = TestOperandType::BOOL,
3516 .zeroPoint = 0
3517 }, { // op41
3518 .channelQuant = {},
3519 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f, 5.0f, 8.0f, 6.0f, 10.0f, 7.0f, 8.0f, 9.0f, 12.0f, 10.0f, 14.0f, 9.0f, 10.0f, 11.0f, 14.0f, 12.0f, 16.0f}),
3520 .dimensions = {1, 3, 3, 2},
3521 .isIgnored = false,
3522 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3523 .numberOfConsumers = 0,
3524 .scale = 0.0f,
3525 .type = TestOperandType::TENSOR_FLOAT16,
3526 .zeroPoint = 0
3527 }, { // op11_new
3528 .channelQuant = {},
3529 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f, 6.0f, 10.0f, 9.0f, 10.0f, 12.0f, 16.0f}),
3530 .dimensions = {1, 2, 2, 2},
3531 .isIgnored = false,
3532 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3533 .numberOfConsumers = 1,
3534 .scale = 0.0f,
3535 .type = TestOperandType::TENSOR_FLOAT16,
3536 .zeroPoint = 0
3537 }, { // dummy18
3538 .channelQuant = {},
3539 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
3540 .dimensions = {1},
3541 .isIgnored = false,
3542 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3543 .numberOfConsumers = 1,
3544 .scale = 0.0f,
3545 .type = TestOperandType::TENSOR_FLOAT16,
3546 .zeroPoint = 0
3547 }, { // param60
3548 .channelQuant = {},
3549 .data = TestBuffer::createFromVector<int32_t>({0}),
3550 .dimensions = {},
3551 .isIgnored = false,
3552 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3553 .numberOfConsumers = 1,
3554 .scale = 0.0f,
3555 .type = TestOperandType::INT32,
3556 .zeroPoint = 0
3557 }},
3558 .operations = {{
3559 .inputs = {5, 6, 7},
3560 .outputs = {0},
3561 .type = TestOperationType::ADD
3562 }, {
3563 .inputs = {0, 1, 2, 3},
3564 .outputs = {4},
3565 .type = TestOperationType::RESIZE_BILINEAR
3566 }},
3567 .outputIndexes = {4}
3568 },
3569 .minSupportedVersion = TestHalVersion::V1_2,
3570 .referenced = {}
3571 };
3572 return model;
3573 }
3574
3575 const auto dummy_test_model_shape_nhwc_float16_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_float16_all_inputs_as_internal_2", get_test_model_shape_nhwc_float16_all_inputs_as_internal_2());
3576
3577 } // namespace generated_tests::resize_bilinear_v1_2
3578
3579 namespace generated_tests::resize_bilinear_v1_2 {
3580
get_test_model_shape_nhwc_quant8_2()3581 const TestModel& get_test_model_shape_nhwc_quant8_2() {
3582 static TestModel model = {
3583 .expectFailure = false,
3584 .expectedMultinomialDistributionTolerance = 0,
3585 .isRelaxed = false,
3586 .main = { // shape
3587 .inputIndexes = {0},
3588 .operands = {{ // op11
3589 .channelQuant = {},
3590 .data = TestBuffer::createFromVector<uint8_t>({12, 16, 24, 40, 36, 40, 48, 64}),
3591 .dimensions = {1, 2, 2, 2},
3592 .isIgnored = false,
3593 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3594 .numberOfConsumers = 1,
3595 .scale = 0.25f,
3596 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3597 .zeroPoint = 0
3598 }, { // param4
3599 .channelQuant = {},
3600 .data = TestBuffer::createFromVector<int32_t>({3}),
3601 .dimensions = {},
3602 .isIgnored = false,
3603 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3604 .numberOfConsumers = 1,
3605 .scale = 0.0f,
3606 .type = TestOperandType::INT32,
3607 .zeroPoint = 0
3608 }, { // param5
3609 .channelQuant = {},
3610 .data = TestBuffer::createFromVector<int32_t>({3}),
3611 .dimensions = {},
3612 .isIgnored = false,
3613 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3614 .numberOfConsumers = 1,
3615 .scale = 0.0f,
3616 .type = TestOperandType::INT32,
3617 .zeroPoint = 0
3618 }, { // layout
3619 .channelQuant = {},
3620 .data = TestBuffer::createFromVector<bool8>({false}),
3621 .dimensions = {},
3622 .isIgnored = false,
3623 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3624 .numberOfConsumers = 1,
3625 .scale = 0.0f,
3626 .type = TestOperandType::BOOL,
3627 .zeroPoint = 0
3628 }, { // op41
3629 .channelQuant = {},
3630 .data = TestBuffer::createFromVector<uint8_t>({12, 16, 20, 32, 24, 40, 28, 32, 36, 48, 40, 56, 36, 40, 44, 56, 48, 64}),
3631 .dimensions = {1, 3, 3, 2},
3632 .isIgnored = false,
3633 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3634 .numberOfConsumers = 0,
3635 .scale = 0.25f,
3636 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3637 .zeroPoint = 0
3638 }},
3639 .operations = {{
3640 .inputs = {0, 1, 2, 3},
3641 .outputs = {4},
3642 .type = TestOperationType::RESIZE_BILINEAR
3643 }},
3644 .outputIndexes = {4}
3645 },
3646 .minSupportedVersion = TestHalVersion::V1_2,
3647 .referenced = {}
3648 };
3649 return model;
3650 }
3651
3652 const auto dummy_test_model_shape_nhwc_quant8_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_quant8_2", get_test_model_shape_nhwc_quant8_2());
3653
3654 } // namespace generated_tests::resize_bilinear_v1_2
3655
3656 namespace generated_tests::resize_bilinear_v1_2 {
3657
get_test_model_shape_nhwc_quant8_all_inputs_as_internal_2()3658 const TestModel& get_test_model_shape_nhwc_quant8_all_inputs_as_internal_2() {
3659 static TestModel model = {
3660 .expectFailure = false,
3661 .expectedMultinomialDistributionTolerance = 0,
3662 .isRelaxed = false,
3663 .main = { // shape
3664 .inputIndexes = {5},
3665 .operands = {{ // op11
3666 .channelQuant = {},
3667 .data = TestBuffer::createFromVector<uint8_t>({}),
3668 .dimensions = {1, 2, 2, 2},
3669 .isIgnored = false,
3670 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3671 .numberOfConsumers = 1,
3672 .scale = 0.25f,
3673 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3674 .zeroPoint = 0
3675 }, { // param4
3676 .channelQuant = {},
3677 .data = TestBuffer::createFromVector<int32_t>({3}),
3678 .dimensions = {},
3679 .isIgnored = false,
3680 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3681 .numberOfConsumers = 1,
3682 .scale = 0.0f,
3683 .type = TestOperandType::INT32,
3684 .zeroPoint = 0
3685 }, { // param5
3686 .channelQuant = {},
3687 .data = TestBuffer::createFromVector<int32_t>({3}),
3688 .dimensions = {},
3689 .isIgnored = false,
3690 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3691 .numberOfConsumers = 1,
3692 .scale = 0.0f,
3693 .type = TestOperandType::INT32,
3694 .zeroPoint = 0
3695 }, { // layout
3696 .channelQuant = {},
3697 .data = TestBuffer::createFromVector<bool8>({false}),
3698 .dimensions = {},
3699 .isIgnored = false,
3700 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3701 .numberOfConsumers = 1,
3702 .scale = 0.0f,
3703 .type = TestOperandType::BOOL,
3704 .zeroPoint = 0
3705 }, { // op41
3706 .channelQuant = {},
3707 .data = TestBuffer::createFromVector<uint8_t>({12, 16, 20, 32, 24, 40, 28, 32, 36, 48, 40, 56, 36, 40, 44, 56, 48, 64}),
3708 .dimensions = {1, 3, 3, 2},
3709 .isIgnored = false,
3710 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3711 .numberOfConsumers = 0,
3712 .scale = 0.25f,
3713 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3714 .zeroPoint = 0
3715 }, { // op11_new
3716 .channelQuant = {},
3717 .data = TestBuffer::createFromVector<uint8_t>({12, 16, 24, 40, 36, 40, 48, 64}),
3718 .dimensions = {1, 2, 2, 2},
3719 .isIgnored = false,
3720 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3721 .numberOfConsumers = 1,
3722 .scale = 0.25f,
3723 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3724 .zeroPoint = 0
3725 }, { // dummy19
3726 .channelQuant = {},
3727 .data = TestBuffer::createFromVector<uint8_t>({0}),
3728 .dimensions = {1},
3729 .isIgnored = false,
3730 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3731 .numberOfConsumers = 1,
3732 .scale = 0.25f,
3733 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
3734 .zeroPoint = 0
3735 }, { // param61
3736 .channelQuant = {},
3737 .data = TestBuffer::createFromVector<int32_t>({0}),
3738 .dimensions = {},
3739 .isIgnored = false,
3740 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3741 .numberOfConsumers = 1,
3742 .scale = 0.0f,
3743 .type = TestOperandType::INT32,
3744 .zeroPoint = 0
3745 }},
3746 .operations = {{
3747 .inputs = {5, 6, 7},
3748 .outputs = {0},
3749 .type = TestOperationType::ADD
3750 }, {
3751 .inputs = {0, 1, 2, 3},
3752 .outputs = {4},
3753 .type = TestOperationType::RESIZE_BILINEAR
3754 }},
3755 .outputIndexes = {4}
3756 },
3757 .minSupportedVersion = TestHalVersion::V1_2,
3758 .referenced = {}
3759 };
3760 return model;
3761 }
3762
3763 const auto dummy_test_model_shape_nhwc_quant8_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nhwc_quant8_all_inputs_as_internal_2", get_test_model_shape_nhwc_quant8_all_inputs_as_internal_2());
3764
3765 } // namespace generated_tests::resize_bilinear_v1_2
3766
3767 namespace generated_tests::resize_bilinear_v1_2 {
3768
get_test_model_shape_nchw_2()3769 const TestModel& get_test_model_shape_nchw_2() {
3770 static TestModel model = {
3771 .expectFailure = false,
3772 .expectedMultinomialDistributionTolerance = 0,
3773 .isRelaxed = false,
3774 .main = { // shape
3775 .inputIndexes = {0},
3776 .operands = {{ // op11
3777 .channelQuant = {},
3778 .data = TestBuffer::createFromVector<float>({3.0f, 6.0f, 9.0f, 12.0f, 4.0f, 10.0f, 10.0f, 16.0f}),
3779 .dimensions = {1, 2, 2, 2},
3780 .isIgnored = false,
3781 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3782 .numberOfConsumers = 1,
3783 .scale = 0.0f,
3784 .type = TestOperandType::TENSOR_FLOAT32,
3785 .zeroPoint = 0
3786 }, { // param4
3787 .channelQuant = {},
3788 .data = TestBuffer::createFromVector<int32_t>({3}),
3789 .dimensions = {},
3790 .isIgnored = false,
3791 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3792 .numberOfConsumers = 1,
3793 .scale = 0.0f,
3794 .type = TestOperandType::INT32,
3795 .zeroPoint = 0
3796 }, { // param5
3797 .channelQuant = {},
3798 .data = TestBuffer::createFromVector<int32_t>({3}),
3799 .dimensions = {},
3800 .isIgnored = false,
3801 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3802 .numberOfConsumers = 1,
3803 .scale = 0.0f,
3804 .type = TestOperandType::INT32,
3805 .zeroPoint = 0
3806 }, { // layout
3807 .channelQuant = {},
3808 .data = TestBuffer::createFromVector<bool8>({true}),
3809 .dimensions = {},
3810 .isIgnored = false,
3811 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3812 .numberOfConsumers = 1,
3813 .scale = 0.0f,
3814 .type = TestOperandType::BOOL,
3815 .zeroPoint = 0
3816 }, { // op41
3817 .channelQuant = {},
3818 .data = TestBuffer::createFromVector<float>({3.0f, 5.0f, 6.0f, 7.0f, 9.0f, 10.0f, 9.0f, 11.0f, 12.0f, 4.0f, 8.0f, 10.0f, 8.0f, 12.0f, 14.0f, 10.0f, 14.0f, 16.0f}),
3819 .dimensions = {1, 2, 3, 3},
3820 .isIgnored = false,
3821 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3822 .numberOfConsumers = 0,
3823 .scale = 0.0f,
3824 .type = TestOperandType::TENSOR_FLOAT32,
3825 .zeroPoint = 0
3826 }},
3827 .operations = {{
3828 .inputs = {0, 1, 2, 3},
3829 .outputs = {4},
3830 .type = TestOperationType::RESIZE_BILINEAR
3831 }},
3832 .outputIndexes = {4}
3833 },
3834 .minSupportedVersion = TestHalVersion::V1_2,
3835 .referenced = {}
3836 };
3837 return model;
3838 }
3839
3840 const auto dummy_test_model_shape_nchw_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_2", get_test_model_shape_nchw_2());
3841
3842 } // namespace generated_tests::resize_bilinear_v1_2
3843
3844 namespace generated_tests::resize_bilinear_v1_2 {
3845
get_test_model_shape_nchw_all_inputs_as_internal_2()3846 const TestModel& get_test_model_shape_nchw_all_inputs_as_internal_2() {
3847 static TestModel model = {
3848 .expectFailure = false,
3849 .expectedMultinomialDistributionTolerance = 0,
3850 .isRelaxed = false,
3851 .main = { // shape
3852 .inputIndexes = {5},
3853 .operands = {{ // op11
3854 .channelQuant = {},
3855 .data = TestBuffer::createFromVector<float>({}),
3856 .dimensions = {1, 2, 2, 2},
3857 .isIgnored = false,
3858 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
3859 .numberOfConsumers = 1,
3860 .scale = 0.0f,
3861 .type = TestOperandType::TENSOR_FLOAT32,
3862 .zeroPoint = 0
3863 }, { // param4
3864 .channelQuant = {},
3865 .data = TestBuffer::createFromVector<int32_t>({3}),
3866 .dimensions = {},
3867 .isIgnored = false,
3868 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3869 .numberOfConsumers = 1,
3870 .scale = 0.0f,
3871 .type = TestOperandType::INT32,
3872 .zeroPoint = 0
3873 }, { // param5
3874 .channelQuant = {},
3875 .data = TestBuffer::createFromVector<int32_t>({3}),
3876 .dimensions = {},
3877 .isIgnored = false,
3878 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3879 .numberOfConsumers = 1,
3880 .scale = 0.0f,
3881 .type = TestOperandType::INT32,
3882 .zeroPoint = 0
3883 }, { // layout
3884 .channelQuant = {},
3885 .data = TestBuffer::createFromVector<bool8>({true}),
3886 .dimensions = {},
3887 .isIgnored = false,
3888 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3889 .numberOfConsumers = 1,
3890 .scale = 0.0f,
3891 .type = TestOperandType::BOOL,
3892 .zeroPoint = 0
3893 }, { // op41
3894 .channelQuant = {},
3895 .data = TestBuffer::createFromVector<float>({3.0f, 5.0f, 6.0f, 7.0f, 9.0f, 10.0f, 9.0f, 11.0f, 12.0f, 4.0f, 8.0f, 10.0f, 8.0f, 12.0f, 14.0f, 10.0f, 14.0f, 16.0f}),
3896 .dimensions = {1, 2, 3, 3},
3897 .isIgnored = false,
3898 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
3899 .numberOfConsumers = 0,
3900 .scale = 0.0f,
3901 .type = TestOperandType::TENSOR_FLOAT32,
3902 .zeroPoint = 0
3903 }, { // op11_new
3904 .channelQuant = {},
3905 .data = TestBuffer::createFromVector<float>({3.0f, 6.0f, 9.0f, 12.0f, 4.0f, 10.0f, 10.0f, 16.0f}),
3906 .dimensions = {1, 2, 2, 2},
3907 .isIgnored = false,
3908 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3909 .numberOfConsumers = 1,
3910 .scale = 0.0f,
3911 .type = TestOperandType::TENSOR_FLOAT32,
3912 .zeroPoint = 0
3913 }, { // dummy20
3914 .channelQuant = {},
3915 .data = TestBuffer::createFromVector<float>({0.0f}),
3916 .dimensions = {1},
3917 .isIgnored = false,
3918 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3919 .numberOfConsumers = 1,
3920 .scale = 0.0f,
3921 .type = TestOperandType::TENSOR_FLOAT32,
3922 .zeroPoint = 0
3923 }, { // param62
3924 .channelQuant = {},
3925 .data = TestBuffer::createFromVector<int32_t>({0}),
3926 .dimensions = {},
3927 .isIgnored = false,
3928 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3929 .numberOfConsumers = 1,
3930 .scale = 0.0f,
3931 .type = TestOperandType::INT32,
3932 .zeroPoint = 0
3933 }},
3934 .operations = {{
3935 .inputs = {5, 6, 7},
3936 .outputs = {0},
3937 .type = TestOperationType::ADD
3938 }, {
3939 .inputs = {0, 1, 2, 3},
3940 .outputs = {4},
3941 .type = TestOperationType::RESIZE_BILINEAR
3942 }},
3943 .outputIndexes = {4}
3944 },
3945 .minSupportedVersion = TestHalVersion::V1_2,
3946 .referenced = {}
3947 };
3948 return model;
3949 }
3950
3951 const auto dummy_test_model_shape_nchw_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_all_inputs_as_internal_2", get_test_model_shape_nchw_all_inputs_as_internal_2());
3952
3953 } // namespace generated_tests::resize_bilinear_v1_2
3954
3955 namespace generated_tests::resize_bilinear_v1_2 {
3956
get_test_model_shape_nchw_relaxed_2()3957 const TestModel& get_test_model_shape_nchw_relaxed_2() {
3958 static TestModel model = {
3959 .expectFailure = false,
3960 .expectedMultinomialDistributionTolerance = 0,
3961 .isRelaxed = true,
3962 .main = { // shape
3963 .inputIndexes = {0},
3964 .operands = {{ // op11
3965 .channelQuant = {},
3966 .data = TestBuffer::createFromVector<float>({3.0f, 6.0f, 9.0f, 12.0f, 4.0f, 10.0f, 10.0f, 16.0f}),
3967 .dimensions = {1, 2, 2, 2},
3968 .isIgnored = false,
3969 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
3970 .numberOfConsumers = 1,
3971 .scale = 0.0f,
3972 .type = TestOperandType::TENSOR_FLOAT32,
3973 .zeroPoint = 0
3974 }, { // param4
3975 .channelQuant = {},
3976 .data = TestBuffer::createFromVector<int32_t>({3}),
3977 .dimensions = {},
3978 .isIgnored = false,
3979 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3980 .numberOfConsumers = 1,
3981 .scale = 0.0f,
3982 .type = TestOperandType::INT32,
3983 .zeroPoint = 0
3984 }, { // param5
3985 .channelQuant = {},
3986 .data = TestBuffer::createFromVector<int32_t>({3}),
3987 .dimensions = {},
3988 .isIgnored = false,
3989 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
3990 .numberOfConsumers = 1,
3991 .scale = 0.0f,
3992 .type = TestOperandType::INT32,
3993 .zeroPoint = 0
3994 }, { // layout
3995 .channelQuant = {},
3996 .data = TestBuffer::createFromVector<bool8>({true}),
3997 .dimensions = {},
3998 .isIgnored = false,
3999 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4000 .numberOfConsumers = 1,
4001 .scale = 0.0f,
4002 .type = TestOperandType::BOOL,
4003 .zeroPoint = 0
4004 }, { // op41
4005 .channelQuant = {},
4006 .data = TestBuffer::createFromVector<float>({3.0f, 5.0f, 6.0f, 7.0f, 9.0f, 10.0f, 9.0f, 11.0f, 12.0f, 4.0f, 8.0f, 10.0f, 8.0f, 12.0f, 14.0f, 10.0f, 14.0f, 16.0f}),
4007 .dimensions = {1, 2, 3, 3},
4008 .isIgnored = false,
4009 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4010 .numberOfConsumers = 0,
4011 .scale = 0.0f,
4012 .type = TestOperandType::TENSOR_FLOAT32,
4013 .zeroPoint = 0
4014 }},
4015 .operations = {{
4016 .inputs = {0, 1, 2, 3},
4017 .outputs = {4},
4018 .type = TestOperationType::RESIZE_BILINEAR
4019 }},
4020 .outputIndexes = {4}
4021 },
4022 .minSupportedVersion = TestHalVersion::UNKNOWN,
4023 .referenced = {}
4024 };
4025 return model;
4026 }
4027
4028 const auto dummy_test_model_shape_nchw_relaxed_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_relaxed_2", get_test_model_shape_nchw_relaxed_2());
4029
4030 } // namespace generated_tests::resize_bilinear_v1_2
4031
4032 namespace generated_tests::resize_bilinear_v1_2 {
4033
get_test_model_shape_nchw_relaxed_all_inputs_as_internal_2()4034 const TestModel& get_test_model_shape_nchw_relaxed_all_inputs_as_internal_2() {
4035 static TestModel model = {
4036 .expectFailure = false,
4037 .expectedMultinomialDistributionTolerance = 0,
4038 .isRelaxed = true,
4039 .main = { // shape
4040 .inputIndexes = {5},
4041 .operands = {{ // op11
4042 .channelQuant = {},
4043 .data = TestBuffer::createFromVector<float>({}),
4044 .dimensions = {1, 2, 2, 2},
4045 .isIgnored = false,
4046 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
4047 .numberOfConsumers = 1,
4048 .scale = 0.0f,
4049 .type = TestOperandType::TENSOR_FLOAT32,
4050 .zeroPoint = 0
4051 }, { // param4
4052 .channelQuant = {},
4053 .data = TestBuffer::createFromVector<int32_t>({3}),
4054 .dimensions = {},
4055 .isIgnored = false,
4056 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4057 .numberOfConsumers = 1,
4058 .scale = 0.0f,
4059 .type = TestOperandType::INT32,
4060 .zeroPoint = 0
4061 }, { // param5
4062 .channelQuant = {},
4063 .data = TestBuffer::createFromVector<int32_t>({3}),
4064 .dimensions = {},
4065 .isIgnored = false,
4066 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4067 .numberOfConsumers = 1,
4068 .scale = 0.0f,
4069 .type = TestOperandType::INT32,
4070 .zeroPoint = 0
4071 }, { // layout
4072 .channelQuant = {},
4073 .data = TestBuffer::createFromVector<bool8>({true}),
4074 .dimensions = {},
4075 .isIgnored = false,
4076 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4077 .numberOfConsumers = 1,
4078 .scale = 0.0f,
4079 .type = TestOperandType::BOOL,
4080 .zeroPoint = 0
4081 }, { // op41
4082 .channelQuant = {},
4083 .data = TestBuffer::createFromVector<float>({3.0f, 5.0f, 6.0f, 7.0f, 9.0f, 10.0f, 9.0f, 11.0f, 12.0f, 4.0f, 8.0f, 10.0f, 8.0f, 12.0f, 14.0f, 10.0f, 14.0f, 16.0f}),
4084 .dimensions = {1, 2, 3, 3},
4085 .isIgnored = false,
4086 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4087 .numberOfConsumers = 0,
4088 .scale = 0.0f,
4089 .type = TestOperandType::TENSOR_FLOAT32,
4090 .zeroPoint = 0
4091 }, { // op11_new
4092 .channelQuant = {},
4093 .data = TestBuffer::createFromVector<float>({3.0f, 6.0f, 9.0f, 12.0f, 4.0f, 10.0f, 10.0f, 16.0f}),
4094 .dimensions = {1, 2, 2, 2},
4095 .isIgnored = false,
4096 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4097 .numberOfConsumers = 1,
4098 .scale = 0.0f,
4099 .type = TestOperandType::TENSOR_FLOAT32,
4100 .zeroPoint = 0
4101 }, { // dummy21
4102 .channelQuant = {},
4103 .data = TestBuffer::createFromVector<float>({0.0f}),
4104 .dimensions = {1},
4105 .isIgnored = false,
4106 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4107 .numberOfConsumers = 1,
4108 .scale = 0.0f,
4109 .type = TestOperandType::TENSOR_FLOAT32,
4110 .zeroPoint = 0
4111 }, { // param63
4112 .channelQuant = {},
4113 .data = TestBuffer::createFromVector<int32_t>({0}),
4114 .dimensions = {},
4115 .isIgnored = false,
4116 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4117 .numberOfConsumers = 1,
4118 .scale = 0.0f,
4119 .type = TestOperandType::INT32,
4120 .zeroPoint = 0
4121 }},
4122 .operations = {{
4123 .inputs = {5, 6, 7},
4124 .outputs = {0},
4125 .type = TestOperationType::ADD
4126 }, {
4127 .inputs = {0, 1, 2, 3},
4128 .outputs = {4},
4129 .type = TestOperationType::RESIZE_BILINEAR
4130 }},
4131 .outputIndexes = {4}
4132 },
4133 .minSupportedVersion = TestHalVersion::UNKNOWN,
4134 .referenced = {}
4135 };
4136 return model;
4137 }
4138
4139 const auto dummy_test_model_shape_nchw_relaxed_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_relaxed_all_inputs_as_internal_2", get_test_model_shape_nchw_relaxed_all_inputs_as_internal_2());
4140
4141 } // namespace generated_tests::resize_bilinear_v1_2
4142
4143 namespace generated_tests::resize_bilinear_v1_2 {
4144
get_test_model_shape_nchw_float16_2()4145 const TestModel& get_test_model_shape_nchw_float16_2() {
4146 static TestModel model = {
4147 .expectFailure = false,
4148 .expectedMultinomialDistributionTolerance = 0,
4149 .isRelaxed = false,
4150 .main = { // shape
4151 .inputIndexes = {0},
4152 .operands = {{ // op11
4153 .channelQuant = {},
4154 .data = TestBuffer::createFromVector<_Float16>({3.0f, 6.0f, 9.0f, 12.0f, 4.0f, 10.0f, 10.0f, 16.0f}),
4155 .dimensions = {1, 2, 2, 2},
4156 .isIgnored = false,
4157 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4158 .numberOfConsumers = 1,
4159 .scale = 0.0f,
4160 .type = TestOperandType::TENSOR_FLOAT16,
4161 .zeroPoint = 0
4162 }, { // param4
4163 .channelQuant = {},
4164 .data = TestBuffer::createFromVector<int32_t>({3}),
4165 .dimensions = {},
4166 .isIgnored = false,
4167 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4168 .numberOfConsumers = 1,
4169 .scale = 0.0f,
4170 .type = TestOperandType::INT32,
4171 .zeroPoint = 0
4172 }, { // param5
4173 .channelQuant = {},
4174 .data = TestBuffer::createFromVector<int32_t>({3}),
4175 .dimensions = {},
4176 .isIgnored = false,
4177 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4178 .numberOfConsumers = 1,
4179 .scale = 0.0f,
4180 .type = TestOperandType::INT32,
4181 .zeroPoint = 0
4182 }, { // layout
4183 .channelQuant = {},
4184 .data = TestBuffer::createFromVector<bool8>({true}),
4185 .dimensions = {},
4186 .isIgnored = false,
4187 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4188 .numberOfConsumers = 1,
4189 .scale = 0.0f,
4190 .type = TestOperandType::BOOL,
4191 .zeroPoint = 0
4192 }, { // op41
4193 .channelQuant = {},
4194 .data = TestBuffer::createFromVector<_Float16>({3.0f, 5.0f, 6.0f, 7.0f, 9.0f, 10.0f, 9.0f, 11.0f, 12.0f, 4.0f, 8.0f, 10.0f, 8.0f, 12.0f, 14.0f, 10.0f, 14.0f, 16.0f}),
4195 .dimensions = {1, 2, 3, 3},
4196 .isIgnored = false,
4197 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4198 .numberOfConsumers = 0,
4199 .scale = 0.0f,
4200 .type = TestOperandType::TENSOR_FLOAT16,
4201 .zeroPoint = 0
4202 }},
4203 .operations = {{
4204 .inputs = {0, 1, 2, 3},
4205 .outputs = {4},
4206 .type = TestOperationType::RESIZE_BILINEAR
4207 }},
4208 .outputIndexes = {4}
4209 },
4210 .minSupportedVersion = TestHalVersion::V1_2,
4211 .referenced = {}
4212 };
4213 return model;
4214 }
4215
4216 const auto dummy_test_model_shape_nchw_float16_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_float16_2", get_test_model_shape_nchw_float16_2());
4217
4218 } // namespace generated_tests::resize_bilinear_v1_2
4219
4220 namespace generated_tests::resize_bilinear_v1_2 {
4221
get_test_model_shape_nchw_float16_all_inputs_as_internal_2()4222 const TestModel& get_test_model_shape_nchw_float16_all_inputs_as_internal_2() {
4223 static TestModel model = {
4224 .expectFailure = false,
4225 .expectedMultinomialDistributionTolerance = 0,
4226 .isRelaxed = false,
4227 .main = { // shape
4228 .inputIndexes = {5},
4229 .operands = {{ // op11
4230 .channelQuant = {},
4231 .data = TestBuffer::createFromVector<_Float16>({}),
4232 .dimensions = {1, 2, 2, 2},
4233 .isIgnored = false,
4234 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
4235 .numberOfConsumers = 1,
4236 .scale = 0.0f,
4237 .type = TestOperandType::TENSOR_FLOAT16,
4238 .zeroPoint = 0
4239 }, { // param4
4240 .channelQuant = {},
4241 .data = TestBuffer::createFromVector<int32_t>({3}),
4242 .dimensions = {},
4243 .isIgnored = false,
4244 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4245 .numberOfConsumers = 1,
4246 .scale = 0.0f,
4247 .type = TestOperandType::INT32,
4248 .zeroPoint = 0
4249 }, { // param5
4250 .channelQuant = {},
4251 .data = TestBuffer::createFromVector<int32_t>({3}),
4252 .dimensions = {},
4253 .isIgnored = false,
4254 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4255 .numberOfConsumers = 1,
4256 .scale = 0.0f,
4257 .type = TestOperandType::INT32,
4258 .zeroPoint = 0
4259 }, { // layout
4260 .channelQuant = {},
4261 .data = TestBuffer::createFromVector<bool8>({true}),
4262 .dimensions = {},
4263 .isIgnored = false,
4264 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4265 .numberOfConsumers = 1,
4266 .scale = 0.0f,
4267 .type = TestOperandType::BOOL,
4268 .zeroPoint = 0
4269 }, { // op41
4270 .channelQuant = {},
4271 .data = TestBuffer::createFromVector<_Float16>({3.0f, 5.0f, 6.0f, 7.0f, 9.0f, 10.0f, 9.0f, 11.0f, 12.0f, 4.0f, 8.0f, 10.0f, 8.0f, 12.0f, 14.0f, 10.0f, 14.0f, 16.0f}),
4272 .dimensions = {1, 2, 3, 3},
4273 .isIgnored = false,
4274 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4275 .numberOfConsumers = 0,
4276 .scale = 0.0f,
4277 .type = TestOperandType::TENSOR_FLOAT16,
4278 .zeroPoint = 0
4279 }, { // op11_new
4280 .channelQuant = {},
4281 .data = TestBuffer::createFromVector<_Float16>({3.0f, 6.0f, 9.0f, 12.0f, 4.0f, 10.0f, 10.0f, 16.0f}),
4282 .dimensions = {1, 2, 2, 2},
4283 .isIgnored = false,
4284 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4285 .numberOfConsumers = 1,
4286 .scale = 0.0f,
4287 .type = TestOperandType::TENSOR_FLOAT16,
4288 .zeroPoint = 0
4289 }, { // dummy22
4290 .channelQuant = {},
4291 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
4292 .dimensions = {1},
4293 .isIgnored = false,
4294 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4295 .numberOfConsumers = 1,
4296 .scale = 0.0f,
4297 .type = TestOperandType::TENSOR_FLOAT16,
4298 .zeroPoint = 0
4299 }, { // param64
4300 .channelQuant = {},
4301 .data = TestBuffer::createFromVector<int32_t>({0}),
4302 .dimensions = {},
4303 .isIgnored = false,
4304 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4305 .numberOfConsumers = 1,
4306 .scale = 0.0f,
4307 .type = TestOperandType::INT32,
4308 .zeroPoint = 0
4309 }},
4310 .operations = {{
4311 .inputs = {5, 6, 7},
4312 .outputs = {0},
4313 .type = TestOperationType::ADD
4314 }, {
4315 .inputs = {0, 1, 2, 3},
4316 .outputs = {4},
4317 .type = TestOperationType::RESIZE_BILINEAR
4318 }},
4319 .outputIndexes = {4}
4320 },
4321 .minSupportedVersion = TestHalVersion::V1_2,
4322 .referenced = {}
4323 };
4324 return model;
4325 }
4326
4327 const auto dummy_test_model_shape_nchw_float16_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_float16_all_inputs_as_internal_2", get_test_model_shape_nchw_float16_all_inputs_as_internal_2());
4328
4329 } // namespace generated_tests::resize_bilinear_v1_2
4330
4331 namespace generated_tests::resize_bilinear_v1_2 {
4332
get_test_model_shape_nchw_quant8_2()4333 const TestModel& get_test_model_shape_nchw_quant8_2() {
4334 static TestModel model = {
4335 .expectFailure = false,
4336 .expectedMultinomialDistributionTolerance = 0,
4337 .isRelaxed = false,
4338 .main = { // shape
4339 .inputIndexes = {0},
4340 .operands = {{ // op11
4341 .channelQuant = {},
4342 .data = TestBuffer::createFromVector<uint8_t>({12, 24, 36, 48, 16, 40, 40, 64}),
4343 .dimensions = {1, 2, 2, 2},
4344 .isIgnored = false,
4345 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4346 .numberOfConsumers = 1,
4347 .scale = 0.25f,
4348 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
4349 .zeroPoint = 0
4350 }, { // param4
4351 .channelQuant = {},
4352 .data = TestBuffer::createFromVector<int32_t>({3}),
4353 .dimensions = {},
4354 .isIgnored = false,
4355 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4356 .numberOfConsumers = 1,
4357 .scale = 0.0f,
4358 .type = TestOperandType::INT32,
4359 .zeroPoint = 0
4360 }, { // param5
4361 .channelQuant = {},
4362 .data = TestBuffer::createFromVector<int32_t>({3}),
4363 .dimensions = {},
4364 .isIgnored = false,
4365 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4366 .numberOfConsumers = 1,
4367 .scale = 0.0f,
4368 .type = TestOperandType::INT32,
4369 .zeroPoint = 0
4370 }, { // layout
4371 .channelQuant = {},
4372 .data = TestBuffer::createFromVector<bool8>({true}),
4373 .dimensions = {},
4374 .isIgnored = false,
4375 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4376 .numberOfConsumers = 1,
4377 .scale = 0.0f,
4378 .type = TestOperandType::BOOL,
4379 .zeroPoint = 0
4380 }, { // op41
4381 .channelQuant = {},
4382 .data = TestBuffer::createFromVector<uint8_t>({12, 20, 24, 28, 36, 40, 36, 44, 48, 16, 32, 40, 32, 48, 56, 40, 56, 64}),
4383 .dimensions = {1, 2, 3, 3},
4384 .isIgnored = false,
4385 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4386 .numberOfConsumers = 0,
4387 .scale = 0.25f,
4388 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
4389 .zeroPoint = 0
4390 }},
4391 .operations = {{
4392 .inputs = {0, 1, 2, 3},
4393 .outputs = {4},
4394 .type = TestOperationType::RESIZE_BILINEAR
4395 }},
4396 .outputIndexes = {4}
4397 },
4398 .minSupportedVersion = TestHalVersion::V1_2,
4399 .referenced = {}
4400 };
4401 return model;
4402 }
4403
4404 const auto dummy_test_model_shape_nchw_quant8_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_quant8_2", get_test_model_shape_nchw_quant8_2());
4405
4406 } // namespace generated_tests::resize_bilinear_v1_2
4407
4408 namespace generated_tests::resize_bilinear_v1_2 {
4409
get_test_model_shape_nchw_quant8_all_inputs_as_internal_2()4410 const TestModel& get_test_model_shape_nchw_quant8_all_inputs_as_internal_2() {
4411 static TestModel model = {
4412 .expectFailure = false,
4413 .expectedMultinomialDistributionTolerance = 0,
4414 .isRelaxed = false,
4415 .main = { // shape
4416 .inputIndexes = {5},
4417 .operands = {{ // op11
4418 .channelQuant = {},
4419 .data = TestBuffer::createFromVector<uint8_t>({}),
4420 .dimensions = {1, 2, 2, 2},
4421 .isIgnored = false,
4422 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
4423 .numberOfConsumers = 1,
4424 .scale = 0.25f,
4425 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
4426 .zeroPoint = 0
4427 }, { // param4
4428 .channelQuant = {},
4429 .data = TestBuffer::createFromVector<int32_t>({3}),
4430 .dimensions = {},
4431 .isIgnored = false,
4432 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4433 .numberOfConsumers = 1,
4434 .scale = 0.0f,
4435 .type = TestOperandType::INT32,
4436 .zeroPoint = 0
4437 }, { // param5
4438 .channelQuant = {},
4439 .data = TestBuffer::createFromVector<int32_t>({3}),
4440 .dimensions = {},
4441 .isIgnored = false,
4442 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4443 .numberOfConsumers = 1,
4444 .scale = 0.0f,
4445 .type = TestOperandType::INT32,
4446 .zeroPoint = 0
4447 }, { // layout
4448 .channelQuant = {},
4449 .data = TestBuffer::createFromVector<bool8>({true}),
4450 .dimensions = {},
4451 .isIgnored = false,
4452 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4453 .numberOfConsumers = 1,
4454 .scale = 0.0f,
4455 .type = TestOperandType::BOOL,
4456 .zeroPoint = 0
4457 }, { // op41
4458 .channelQuant = {},
4459 .data = TestBuffer::createFromVector<uint8_t>({12, 20, 24, 28, 36, 40, 36, 44, 48, 16, 32, 40, 32, 48, 56, 40, 56, 64}),
4460 .dimensions = {1, 2, 3, 3},
4461 .isIgnored = false,
4462 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4463 .numberOfConsumers = 0,
4464 .scale = 0.25f,
4465 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
4466 .zeroPoint = 0
4467 }, { // op11_new
4468 .channelQuant = {},
4469 .data = TestBuffer::createFromVector<uint8_t>({12, 24, 36, 48, 16, 40, 40, 64}),
4470 .dimensions = {1, 2, 2, 2},
4471 .isIgnored = false,
4472 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4473 .numberOfConsumers = 1,
4474 .scale = 0.25f,
4475 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
4476 .zeroPoint = 0
4477 }, { // dummy23
4478 .channelQuant = {},
4479 .data = TestBuffer::createFromVector<uint8_t>({0}),
4480 .dimensions = {1},
4481 .isIgnored = false,
4482 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4483 .numberOfConsumers = 1,
4484 .scale = 0.25f,
4485 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
4486 .zeroPoint = 0
4487 }, { // param65
4488 .channelQuant = {},
4489 .data = TestBuffer::createFromVector<int32_t>({0}),
4490 .dimensions = {},
4491 .isIgnored = false,
4492 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4493 .numberOfConsumers = 1,
4494 .scale = 0.0f,
4495 .type = TestOperandType::INT32,
4496 .zeroPoint = 0
4497 }},
4498 .operations = {{
4499 .inputs = {5, 6, 7},
4500 .outputs = {0},
4501 .type = TestOperationType::ADD
4502 }, {
4503 .inputs = {0, 1, 2, 3},
4504 .outputs = {4},
4505 .type = TestOperationType::RESIZE_BILINEAR
4506 }},
4507 .outputIndexes = {4}
4508 },
4509 .minSupportedVersion = TestHalVersion::V1_2,
4510 .referenced = {}
4511 };
4512 return model;
4513 }
4514
4515 const auto dummy_test_model_shape_nchw_quant8_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_shape_nchw_quant8_all_inputs_as_internal_2", get_test_model_shape_nchw_quant8_all_inputs_as_internal_2());
4516
4517 } // namespace generated_tests::resize_bilinear_v1_2
4518
4519 namespace generated_tests::resize_bilinear_v1_2 {
4520
get_test_model_scale_nhwc_2()4521 const TestModel& get_test_model_scale_nhwc_2() {
4522 static TestModel model = {
4523 .expectFailure = false,
4524 .expectedMultinomialDistributionTolerance = 0,
4525 .isRelaxed = false,
4526 .main = { // scale
4527 .inputIndexes = {0},
4528 .operands = {{ // op11
4529 .channelQuant = {},
4530 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 6.0f, 10.0f, 9.0f, 10.0f, 12.0f, 16.0f}),
4531 .dimensions = {1, 2, 2, 2},
4532 .isIgnored = false,
4533 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4534 .numberOfConsumers = 1,
4535 .scale = 0.0f,
4536 .type = TestOperandType::TENSOR_FLOAT32,
4537 .zeroPoint = 0
4538 }, { // param6
4539 .channelQuant = {},
4540 .data = TestBuffer::createFromVector<float>({1.6f}),
4541 .dimensions = {},
4542 .isIgnored = false,
4543 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4544 .numberOfConsumers = 1,
4545 .scale = 0.0f,
4546 .type = TestOperandType::FLOAT32,
4547 .zeroPoint = 0
4548 }, { // param7
4549 .channelQuant = {},
4550 .data = TestBuffer::createFromVector<float>({1.6f}),
4551 .dimensions = {},
4552 .isIgnored = false,
4553 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4554 .numberOfConsumers = 1,
4555 .scale = 0.0f,
4556 .type = TestOperandType::FLOAT32,
4557 .zeroPoint = 0
4558 }, { // layout
4559 .channelQuant = {},
4560 .data = TestBuffer::createFromVector<bool8>({false}),
4561 .dimensions = {},
4562 .isIgnored = false,
4563 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4564 .numberOfConsumers = 1,
4565 .scale = 0.0f,
4566 .type = TestOperandType::BOOL,
4567 .zeroPoint = 0
4568 }, { // op41
4569 .channelQuant = {},
4570 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 5.0f, 8.0f, 6.0f, 10.0f, 7.0f, 8.0f, 9.0f, 12.0f, 10.0f, 14.0f, 9.0f, 10.0f, 11.0f, 14.0f, 12.0f, 16.0f}),
4571 .dimensions = {1, 3, 3, 2},
4572 .isIgnored = false,
4573 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4574 .numberOfConsumers = 0,
4575 .scale = 0.0f,
4576 .type = TestOperandType::TENSOR_FLOAT32,
4577 .zeroPoint = 0
4578 }},
4579 .operations = {{
4580 .inputs = {0, 1, 2, 3},
4581 .outputs = {4},
4582 .type = TestOperationType::RESIZE_BILINEAR
4583 }},
4584 .outputIndexes = {4}
4585 },
4586 .minSupportedVersion = TestHalVersion::V1_2,
4587 .referenced = {}
4588 };
4589 return model;
4590 }
4591
4592 const auto dummy_test_model_scale_nhwc_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_2", get_test_model_scale_nhwc_2());
4593
4594 } // namespace generated_tests::resize_bilinear_v1_2
4595
4596 namespace generated_tests::resize_bilinear_v1_2 {
4597
get_test_model_scale_nhwc_all_inputs_as_internal_2()4598 const TestModel& get_test_model_scale_nhwc_all_inputs_as_internal_2() {
4599 static TestModel model = {
4600 .expectFailure = false,
4601 .expectedMultinomialDistributionTolerance = 0,
4602 .isRelaxed = false,
4603 .main = { // scale
4604 .inputIndexes = {5},
4605 .operands = {{ // op11
4606 .channelQuant = {},
4607 .data = TestBuffer::createFromVector<float>({}),
4608 .dimensions = {1, 2, 2, 2},
4609 .isIgnored = false,
4610 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
4611 .numberOfConsumers = 1,
4612 .scale = 0.0f,
4613 .type = TestOperandType::TENSOR_FLOAT32,
4614 .zeroPoint = 0
4615 }, { // param6
4616 .channelQuant = {},
4617 .data = TestBuffer::createFromVector<float>({1.6f}),
4618 .dimensions = {},
4619 .isIgnored = false,
4620 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4621 .numberOfConsumers = 1,
4622 .scale = 0.0f,
4623 .type = TestOperandType::FLOAT32,
4624 .zeroPoint = 0
4625 }, { // param7
4626 .channelQuant = {},
4627 .data = TestBuffer::createFromVector<float>({1.6f}),
4628 .dimensions = {},
4629 .isIgnored = false,
4630 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4631 .numberOfConsumers = 1,
4632 .scale = 0.0f,
4633 .type = TestOperandType::FLOAT32,
4634 .zeroPoint = 0
4635 }, { // layout
4636 .channelQuant = {},
4637 .data = TestBuffer::createFromVector<bool8>({false}),
4638 .dimensions = {},
4639 .isIgnored = false,
4640 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4641 .numberOfConsumers = 1,
4642 .scale = 0.0f,
4643 .type = TestOperandType::BOOL,
4644 .zeroPoint = 0
4645 }, { // op41
4646 .channelQuant = {},
4647 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 5.0f, 8.0f, 6.0f, 10.0f, 7.0f, 8.0f, 9.0f, 12.0f, 10.0f, 14.0f, 9.0f, 10.0f, 11.0f, 14.0f, 12.0f, 16.0f}),
4648 .dimensions = {1, 3, 3, 2},
4649 .isIgnored = false,
4650 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4651 .numberOfConsumers = 0,
4652 .scale = 0.0f,
4653 .type = TestOperandType::TENSOR_FLOAT32,
4654 .zeroPoint = 0
4655 }, { // op11_new
4656 .channelQuant = {},
4657 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 6.0f, 10.0f, 9.0f, 10.0f, 12.0f, 16.0f}),
4658 .dimensions = {1, 2, 2, 2},
4659 .isIgnored = false,
4660 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4661 .numberOfConsumers = 1,
4662 .scale = 0.0f,
4663 .type = TestOperandType::TENSOR_FLOAT32,
4664 .zeroPoint = 0
4665 }, { // dummy24
4666 .channelQuant = {},
4667 .data = TestBuffer::createFromVector<float>({0.0f}),
4668 .dimensions = {1},
4669 .isIgnored = false,
4670 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4671 .numberOfConsumers = 1,
4672 .scale = 0.0f,
4673 .type = TestOperandType::TENSOR_FLOAT32,
4674 .zeroPoint = 0
4675 }, { // param66
4676 .channelQuant = {},
4677 .data = TestBuffer::createFromVector<int32_t>({0}),
4678 .dimensions = {},
4679 .isIgnored = false,
4680 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4681 .numberOfConsumers = 1,
4682 .scale = 0.0f,
4683 .type = TestOperandType::INT32,
4684 .zeroPoint = 0
4685 }},
4686 .operations = {{
4687 .inputs = {5, 6, 7},
4688 .outputs = {0},
4689 .type = TestOperationType::ADD
4690 }, {
4691 .inputs = {0, 1, 2, 3},
4692 .outputs = {4},
4693 .type = TestOperationType::RESIZE_BILINEAR
4694 }},
4695 .outputIndexes = {4}
4696 },
4697 .minSupportedVersion = TestHalVersion::V1_2,
4698 .referenced = {}
4699 };
4700 return model;
4701 }
4702
4703 const auto dummy_test_model_scale_nhwc_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_all_inputs_as_internal_2", get_test_model_scale_nhwc_all_inputs_as_internal_2());
4704
4705 } // namespace generated_tests::resize_bilinear_v1_2
4706
4707 namespace generated_tests::resize_bilinear_v1_2 {
4708
get_test_model_scale_nhwc_relaxed_2()4709 const TestModel& get_test_model_scale_nhwc_relaxed_2() {
4710 static TestModel model = {
4711 .expectFailure = false,
4712 .expectedMultinomialDistributionTolerance = 0,
4713 .isRelaxed = true,
4714 .main = { // scale
4715 .inputIndexes = {0},
4716 .operands = {{ // op11
4717 .channelQuant = {},
4718 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 6.0f, 10.0f, 9.0f, 10.0f, 12.0f, 16.0f}),
4719 .dimensions = {1, 2, 2, 2},
4720 .isIgnored = false,
4721 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4722 .numberOfConsumers = 1,
4723 .scale = 0.0f,
4724 .type = TestOperandType::TENSOR_FLOAT32,
4725 .zeroPoint = 0
4726 }, { // param6
4727 .channelQuant = {},
4728 .data = TestBuffer::createFromVector<float>({1.6f}),
4729 .dimensions = {},
4730 .isIgnored = false,
4731 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4732 .numberOfConsumers = 1,
4733 .scale = 0.0f,
4734 .type = TestOperandType::FLOAT32,
4735 .zeroPoint = 0
4736 }, { // param7
4737 .channelQuant = {},
4738 .data = TestBuffer::createFromVector<float>({1.6f}),
4739 .dimensions = {},
4740 .isIgnored = false,
4741 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4742 .numberOfConsumers = 1,
4743 .scale = 0.0f,
4744 .type = TestOperandType::FLOAT32,
4745 .zeroPoint = 0
4746 }, { // layout
4747 .channelQuant = {},
4748 .data = TestBuffer::createFromVector<bool8>({false}),
4749 .dimensions = {},
4750 .isIgnored = false,
4751 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4752 .numberOfConsumers = 1,
4753 .scale = 0.0f,
4754 .type = TestOperandType::BOOL,
4755 .zeroPoint = 0
4756 }, { // op41
4757 .channelQuant = {},
4758 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 5.0f, 8.0f, 6.0f, 10.0f, 7.0f, 8.0f, 9.0f, 12.0f, 10.0f, 14.0f, 9.0f, 10.0f, 11.0f, 14.0f, 12.0f, 16.0f}),
4759 .dimensions = {1, 3, 3, 2},
4760 .isIgnored = false,
4761 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4762 .numberOfConsumers = 0,
4763 .scale = 0.0f,
4764 .type = TestOperandType::TENSOR_FLOAT32,
4765 .zeroPoint = 0
4766 }},
4767 .operations = {{
4768 .inputs = {0, 1, 2, 3},
4769 .outputs = {4},
4770 .type = TestOperationType::RESIZE_BILINEAR
4771 }},
4772 .outputIndexes = {4}
4773 },
4774 .minSupportedVersion = TestHalVersion::UNKNOWN,
4775 .referenced = {}
4776 };
4777 return model;
4778 }
4779
4780 const auto dummy_test_model_scale_nhwc_relaxed_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_relaxed_2", get_test_model_scale_nhwc_relaxed_2());
4781
4782 } // namespace generated_tests::resize_bilinear_v1_2
4783
4784 namespace generated_tests::resize_bilinear_v1_2 {
4785
get_test_model_scale_nhwc_relaxed_all_inputs_as_internal_2()4786 const TestModel& get_test_model_scale_nhwc_relaxed_all_inputs_as_internal_2() {
4787 static TestModel model = {
4788 .expectFailure = false,
4789 .expectedMultinomialDistributionTolerance = 0,
4790 .isRelaxed = true,
4791 .main = { // scale
4792 .inputIndexes = {5},
4793 .operands = {{ // op11
4794 .channelQuant = {},
4795 .data = TestBuffer::createFromVector<float>({}),
4796 .dimensions = {1, 2, 2, 2},
4797 .isIgnored = false,
4798 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
4799 .numberOfConsumers = 1,
4800 .scale = 0.0f,
4801 .type = TestOperandType::TENSOR_FLOAT32,
4802 .zeroPoint = 0
4803 }, { // param6
4804 .channelQuant = {},
4805 .data = TestBuffer::createFromVector<float>({1.6f}),
4806 .dimensions = {},
4807 .isIgnored = false,
4808 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4809 .numberOfConsumers = 1,
4810 .scale = 0.0f,
4811 .type = TestOperandType::FLOAT32,
4812 .zeroPoint = 0
4813 }, { // param7
4814 .channelQuant = {},
4815 .data = TestBuffer::createFromVector<float>({1.6f}),
4816 .dimensions = {},
4817 .isIgnored = false,
4818 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4819 .numberOfConsumers = 1,
4820 .scale = 0.0f,
4821 .type = TestOperandType::FLOAT32,
4822 .zeroPoint = 0
4823 }, { // layout
4824 .channelQuant = {},
4825 .data = TestBuffer::createFromVector<bool8>({false}),
4826 .dimensions = {},
4827 .isIgnored = false,
4828 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4829 .numberOfConsumers = 1,
4830 .scale = 0.0f,
4831 .type = TestOperandType::BOOL,
4832 .zeroPoint = 0
4833 }, { // op41
4834 .channelQuant = {},
4835 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 5.0f, 8.0f, 6.0f, 10.0f, 7.0f, 8.0f, 9.0f, 12.0f, 10.0f, 14.0f, 9.0f, 10.0f, 11.0f, 14.0f, 12.0f, 16.0f}),
4836 .dimensions = {1, 3, 3, 2},
4837 .isIgnored = false,
4838 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4839 .numberOfConsumers = 0,
4840 .scale = 0.0f,
4841 .type = TestOperandType::TENSOR_FLOAT32,
4842 .zeroPoint = 0
4843 }, { // op11_new
4844 .channelQuant = {},
4845 .data = TestBuffer::createFromVector<float>({3.0f, 4.0f, 6.0f, 10.0f, 9.0f, 10.0f, 12.0f, 16.0f}),
4846 .dimensions = {1, 2, 2, 2},
4847 .isIgnored = false,
4848 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4849 .numberOfConsumers = 1,
4850 .scale = 0.0f,
4851 .type = TestOperandType::TENSOR_FLOAT32,
4852 .zeroPoint = 0
4853 }, { // dummy25
4854 .channelQuant = {},
4855 .data = TestBuffer::createFromVector<float>({0.0f}),
4856 .dimensions = {1},
4857 .isIgnored = false,
4858 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4859 .numberOfConsumers = 1,
4860 .scale = 0.0f,
4861 .type = TestOperandType::TENSOR_FLOAT32,
4862 .zeroPoint = 0
4863 }, { // param67
4864 .channelQuant = {},
4865 .data = TestBuffer::createFromVector<int32_t>({0}),
4866 .dimensions = {},
4867 .isIgnored = false,
4868 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4869 .numberOfConsumers = 1,
4870 .scale = 0.0f,
4871 .type = TestOperandType::INT32,
4872 .zeroPoint = 0
4873 }},
4874 .operations = {{
4875 .inputs = {5, 6, 7},
4876 .outputs = {0},
4877 .type = TestOperationType::ADD
4878 }, {
4879 .inputs = {0, 1, 2, 3},
4880 .outputs = {4},
4881 .type = TestOperationType::RESIZE_BILINEAR
4882 }},
4883 .outputIndexes = {4}
4884 },
4885 .minSupportedVersion = TestHalVersion::UNKNOWN,
4886 .referenced = {}
4887 };
4888 return model;
4889 }
4890
4891 const auto dummy_test_model_scale_nhwc_relaxed_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_relaxed_all_inputs_as_internal_2", get_test_model_scale_nhwc_relaxed_all_inputs_as_internal_2());
4892
4893 } // namespace generated_tests::resize_bilinear_v1_2
4894
4895 namespace generated_tests::resize_bilinear_v1_2 {
4896
get_test_model_scale_nhwc_float16_2()4897 const TestModel& get_test_model_scale_nhwc_float16_2() {
4898 static TestModel model = {
4899 .expectFailure = false,
4900 .expectedMultinomialDistributionTolerance = 0,
4901 .isRelaxed = false,
4902 .main = { // scale
4903 .inputIndexes = {0},
4904 .operands = {{ // op11
4905 .channelQuant = {},
4906 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f, 6.0f, 10.0f, 9.0f, 10.0f, 12.0f, 16.0f}),
4907 .dimensions = {1, 2, 2, 2},
4908 .isIgnored = false,
4909 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
4910 .numberOfConsumers = 1,
4911 .scale = 0.0f,
4912 .type = TestOperandType::TENSOR_FLOAT16,
4913 .zeroPoint = 0
4914 }, { // param6
4915 .channelQuant = {},
4916 .data = TestBuffer::createFromVector<_Float16>({1.600000023841858f}),
4917 .dimensions = {},
4918 .isIgnored = false,
4919 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4920 .numberOfConsumers = 1,
4921 .scale = 0.0f,
4922 .type = TestOperandType::FLOAT16,
4923 .zeroPoint = 0
4924 }, { // param7
4925 .channelQuant = {},
4926 .data = TestBuffer::createFromVector<_Float16>({1.600000023841858f}),
4927 .dimensions = {},
4928 .isIgnored = false,
4929 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4930 .numberOfConsumers = 1,
4931 .scale = 0.0f,
4932 .type = TestOperandType::FLOAT16,
4933 .zeroPoint = 0
4934 }, { // layout
4935 .channelQuant = {},
4936 .data = TestBuffer::createFromVector<bool8>({false}),
4937 .dimensions = {},
4938 .isIgnored = false,
4939 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4940 .numberOfConsumers = 1,
4941 .scale = 0.0f,
4942 .type = TestOperandType::BOOL,
4943 .zeroPoint = 0
4944 }, { // op41
4945 .channelQuant = {},
4946 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f, 5.0f, 8.0f, 6.0f, 10.0f, 7.0f, 8.0f, 9.0f, 12.0f, 10.0f, 14.0f, 9.0f, 10.0f, 11.0f, 14.0f, 12.0f, 16.0f}),
4947 .dimensions = {1, 3, 3, 2},
4948 .isIgnored = false,
4949 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
4950 .numberOfConsumers = 0,
4951 .scale = 0.0f,
4952 .type = TestOperandType::TENSOR_FLOAT16,
4953 .zeroPoint = 0
4954 }},
4955 .operations = {{
4956 .inputs = {0, 1, 2, 3},
4957 .outputs = {4},
4958 .type = TestOperationType::RESIZE_BILINEAR
4959 }},
4960 .outputIndexes = {4}
4961 },
4962 .minSupportedVersion = TestHalVersion::V1_2,
4963 .referenced = {}
4964 };
4965 return model;
4966 }
4967
4968 const auto dummy_test_model_scale_nhwc_float16_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_float16_2", get_test_model_scale_nhwc_float16_2());
4969
4970 } // namespace generated_tests::resize_bilinear_v1_2
4971
4972 namespace generated_tests::resize_bilinear_v1_2 {
4973
get_test_model_scale_nhwc_float16_all_inputs_as_internal_2()4974 const TestModel& get_test_model_scale_nhwc_float16_all_inputs_as_internal_2() {
4975 static TestModel model = {
4976 .expectFailure = false,
4977 .expectedMultinomialDistributionTolerance = 0,
4978 .isRelaxed = false,
4979 .main = { // scale
4980 .inputIndexes = {5},
4981 .operands = {{ // op11
4982 .channelQuant = {},
4983 .data = TestBuffer::createFromVector<_Float16>({}),
4984 .dimensions = {1, 2, 2, 2},
4985 .isIgnored = false,
4986 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
4987 .numberOfConsumers = 1,
4988 .scale = 0.0f,
4989 .type = TestOperandType::TENSOR_FLOAT16,
4990 .zeroPoint = 0
4991 }, { // param6
4992 .channelQuant = {},
4993 .data = TestBuffer::createFromVector<_Float16>({1.600000023841858f}),
4994 .dimensions = {},
4995 .isIgnored = false,
4996 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
4997 .numberOfConsumers = 1,
4998 .scale = 0.0f,
4999 .type = TestOperandType::FLOAT16,
5000 .zeroPoint = 0
5001 }, { // param7
5002 .channelQuant = {},
5003 .data = TestBuffer::createFromVector<_Float16>({1.600000023841858f}),
5004 .dimensions = {},
5005 .isIgnored = false,
5006 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5007 .numberOfConsumers = 1,
5008 .scale = 0.0f,
5009 .type = TestOperandType::FLOAT16,
5010 .zeroPoint = 0
5011 }, { // layout
5012 .channelQuant = {},
5013 .data = TestBuffer::createFromVector<bool8>({false}),
5014 .dimensions = {},
5015 .isIgnored = false,
5016 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5017 .numberOfConsumers = 1,
5018 .scale = 0.0f,
5019 .type = TestOperandType::BOOL,
5020 .zeroPoint = 0
5021 }, { // op41
5022 .channelQuant = {},
5023 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f, 5.0f, 8.0f, 6.0f, 10.0f, 7.0f, 8.0f, 9.0f, 12.0f, 10.0f, 14.0f, 9.0f, 10.0f, 11.0f, 14.0f, 12.0f, 16.0f}),
5024 .dimensions = {1, 3, 3, 2},
5025 .isIgnored = false,
5026 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5027 .numberOfConsumers = 0,
5028 .scale = 0.0f,
5029 .type = TestOperandType::TENSOR_FLOAT16,
5030 .zeroPoint = 0
5031 }, { // op11_new
5032 .channelQuant = {},
5033 .data = TestBuffer::createFromVector<_Float16>({3.0f, 4.0f, 6.0f, 10.0f, 9.0f, 10.0f, 12.0f, 16.0f}),
5034 .dimensions = {1, 2, 2, 2},
5035 .isIgnored = false,
5036 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5037 .numberOfConsumers = 1,
5038 .scale = 0.0f,
5039 .type = TestOperandType::TENSOR_FLOAT16,
5040 .zeroPoint = 0
5041 }, { // dummy26
5042 .channelQuant = {},
5043 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
5044 .dimensions = {1},
5045 .isIgnored = false,
5046 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5047 .numberOfConsumers = 1,
5048 .scale = 0.0f,
5049 .type = TestOperandType::TENSOR_FLOAT16,
5050 .zeroPoint = 0
5051 }, { // param68
5052 .channelQuant = {},
5053 .data = TestBuffer::createFromVector<int32_t>({0}),
5054 .dimensions = {},
5055 .isIgnored = false,
5056 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5057 .numberOfConsumers = 1,
5058 .scale = 0.0f,
5059 .type = TestOperandType::INT32,
5060 .zeroPoint = 0
5061 }},
5062 .operations = {{
5063 .inputs = {5, 6, 7},
5064 .outputs = {0},
5065 .type = TestOperationType::ADD
5066 }, {
5067 .inputs = {0, 1, 2, 3},
5068 .outputs = {4},
5069 .type = TestOperationType::RESIZE_BILINEAR
5070 }},
5071 .outputIndexes = {4}
5072 },
5073 .minSupportedVersion = TestHalVersion::V1_2,
5074 .referenced = {}
5075 };
5076 return model;
5077 }
5078
5079 const auto dummy_test_model_scale_nhwc_float16_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_float16_all_inputs_as_internal_2", get_test_model_scale_nhwc_float16_all_inputs_as_internal_2());
5080
5081 } // namespace generated_tests::resize_bilinear_v1_2
5082
5083 namespace generated_tests::resize_bilinear_v1_2 {
5084
get_test_model_scale_nhwc_quant8_2()5085 const TestModel& get_test_model_scale_nhwc_quant8_2() {
5086 static TestModel model = {
5087 .expectFailure = false,
5088 .expectedMultinomialDistributionTolerance = 0,
5089 .isRelaxed = false,
5090 .main = { // scale
5091 .inputIndexes = {0},
5092 .operands = {{ // op11
5093 .channelQuant = {},
5094 .data = TestBuffer::createFromVector<uint8_t>({12, 16, 24, 40, 36, 40, 48, 64}),
5095 .dimensions = {1, 2, 2, 2},
5096 .isIgnored = false,
5097 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5098 .numberOfConsumers = 1,
5099 .scale = 0.25f,
5100 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
5101 .zeroPoint = 0
5102 }, { // param6
5103 .channelQuant = {},
5104 .data = TestBuffer::createFromVector<float>({1.6f}),
5105 .dimensions = {},
5106 .isIgnored = false,
5107 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5108 .numberOfConsumers = 1,
5109 .scale = 0.0f,
5110 .type = TestOperandType::FLOAT32,
5111 .zeroPoint = 0
5112 }, { // param7
5113 .channelQuant = {},
5114 .data = TestBuffer::createFromVector<float>({1.6f}),
5115 .dimensions = {},
5116 .isIgnored = false,
5117 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5118 .numberOfConsumers = 1,
5119 .scale = 0.0f,
5120 .type = TestOperandType::FLOAT32,
5121 .zeroPoint = 0
5122 }, { // layout
5123 .channelQuant = {},
5124 .data = TestBuffer::createFromVector<bool8>({false}),
5125 .dimensions = {},
5126 .isIgnored = false,
5127 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5128 .numberOfConsumers = 1,
5129 .scale = 0.0f,
5130 .type = TestOperandType::BOOL,
5131 .zeroPoint = 0
5132 }, { // op41
5133 .channelQuant = {},
5134 .data = TestBuffer::createFromVector<uint8_t>({12, 16, 20, 32, 24, 40, 28, 32, 36, 48, 40, 56, 36, 40, 44, 56, 48, 64}),
5135 .dimensions = {1, 3, 3, 2},
5136 .isIgnored = false,
5137 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5138 .numberOfConsumers = 0,
5139 .scale = 0.25f,
5140 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
5141 .zeroPoint = 0
5142 }},
5143 .operations = {{
5144 .inputs = {0, 1, 2, 3},
5145 .outputs = {4},
5146 .type = TestOperationType::RESIZE_BILINEAR
5147 }},
5148 .outputIndexes = {4}
5149 },
5150 .minSupportedVersion = TestHalVersion::V1_2,
5151 .referenced = {}
5152 };
5153 return model;
5154 }
5155
5156 const auto dummy_test_model_scale_nhwc_quant8_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_quant8_2", get_test_model_scale_nhwc_quant8_2());
5157
5158 } // namespace generated_tests::resize_bilinear_v1_2
5159
5160 namespace generated_tests::resize_bilinear_v1_2 {
5161
get_test_model_scale_nhwc_quant8_all_inputs_as_internal_2()5162 const TestModel& get_test_model_scale_nhwc_quant8_all_inputs_as_internal_2() {
5163 static TestModel model = {
5164 .expectFailure = false,
5165 .expectedMultinomialDistributionTolerance = 0,
5166 .isRelaxed = false,
5167 .main = { // scale
5168 .inputIndexes = {5},
5169 .operands = {{ // op11
5170 .channelQuant = {},
5171 .data = TestBuffer::createFromVector<uint8_t>({}),
5172 .dimensions = {1, 2, 2, 2},
5173 .isIgnored = false,
5174 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
5175 .numberOfConsumers = 1,
5176 .scale = 0.25f,
5177 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
5178 .zeroPoint = 0
5179 }, { // param6
5180 .channelQuant = {},
5181 .data = TestBuffer::createFromVector<float>({1.6f}),
5182 .dimensions = {},
5183 .isIgnored = false,
5184 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5185 .numberOfConsumers = 1,
5186 .scale = 0.0f,
5187 .type = TestOperandType::FLOAT32,
5188 .zeroPoint = 0
5189 }, { // param7
5190 .channelQuant = {},
5191 .data = TestBuffer::createFromVector<float>({1.6f}),
5192 .dimensions = {},
5193 .isIgnored = false,
5194 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5195 .numberOfConsumers = 1,
5196 .scale = 0.0f,
5197 .type = TestOperandType::FLOAT32,
5198 .zeroPoint = 0
5199 }, { // layout
5200 .channelQuant = {},
5201 .data = TestBuffer::createFromVector<bool8>({false}),
5202 .dimensions = {},
5203 .isIgnored = false,
5204 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5205 .numberOfConsumers = 1,
5206 .scale = 0.0f,
5207 .type = TestOperandType::BOOL,
5208 .zeroPoint = 0
5209 }, { // op41
5210 .channelQuant = {},
5211 .data = TestBuffer::createFromVector<uint8_t>({12, 16, 20, 32, 24, 40, 28, 32, 36, 48, 40, 56, 36, 40, 44, 56, 48, 64}),
5212 .dimensions = {1, 3, 3, 2},
5213 .isIgnored = false,
5214 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5215 .numberOfConsumers = 0,
5216 .scale = 0.25f,
5217 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
5218 .zeroPoint = 0
5219 }, { // op11_new
5220 .channelQuant = {},
5221 .data = TestBuffer::createFromVector<uint8_t>({12, 16, 24, 40, 36, 40, 48, 64}),
5222 .dimensions = {1, 2, 2, 2},
5223 .isIgnored = false,
5224 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5225 .numberOfConsumers = 1,
5226 .scale = 0.25f,
5227 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
5228 .zeroPoint = 0
5229 }, { // dummy27
5230 .channelQuant = {},
5231 .data = TestBuffer::createFromVector<uint8_t>({0}),
5232 .dimensions = {1},
5233 .isIgnored = false,
5234 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5235 .numberOfConsumers = 1,
5236 .scale = 0.25f,
5237 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
5238 .zeroPoint = 0
5239 }, { // param69
5240 .channelQuant = {},
5241 .data = TestBuffer::createFromVector<int32_t>({0}),
5242 .dimensions = {},
5243 .isIgnored = false,
5244 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5245 .numberOfConsumers = 1,
5246 .scale = 0.0f,
5247 .type = TestOperandType::INT32,
5248 .zeroPoint = 0
5249 }},
5250 .operations = {{
5251 .inputs = {5, 6, 7},
5252 .outputs = {0},
5253 .type = TestOperationType::ADD
5254 }, {
5255 .inputs = {0, 1, 2, 3},
5256 .outputs = {4},
5257 .type = TestOperationType::RESIZE_BILINEAR
5258 }},
5259 .outputIndexes = {4}
5260 },
5261 .minSupportedVersion = TestHalVersion::V1_2,
5262 .referenced = {}
5263 };
5264 return model;
5265 }
5266
5267 const auto dummy_test_model_scale_nhwc_quant8_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nhwc_quant8_all_inputs_as_internal_2", get_test_model_scale_nhwc_quant8_all_inputs_as_internal_2());
5268
5269 } // namespace generated_tests::resize_bilinear_v1_2
5270
5271 namespace generated_tests::resize_bilinear_v1_2 {
5272
get_test_model_scale_nchw_2()5273 const TestModel& get_test_model_scale_nchw_2() {
5274 static TestModel model = {
5275 .expectFailure = false,
5276 .expectedMultinomialDistributionTolerance = 0,
5277 .isRelaxed = false,
5278 .main = { // scale
5279 .inputIndexes = {0},
5280 .operands = {{ // op11
5281 .channelQuant = {},
5282 .data = TestBuffer::createFromVector<float>({3.0f, 6.0f, 9.0f, 12.0f, 4.0f, 10.0f, 10.0f, 16.0f}),
5283 .dimensions = {1, 2, 2, 2},
5284 .isIgnored = false,
5285 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5286 .numberOfConsumers = 1,
5287 .scale = 0.0f,
5288 .type = TestOperandType::TENSOR_FLOAT32,
5289 .zeroPoint = 0
5290 }, { // param6
5291 .channelQuant = {},
5292 .data = TestBuffer::createFromVector<float>({1.6f}),
5293 .dimensions = {},
5294 .isIgnored = false,
5295 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5296 .numberOfConsumers = 1,
5297 .scale = 0.0f,
5298 .type = TestOperandType::FLOAT32,
5299 .zeroPoint = 0
5300 }, { // param7
5301 .channelQuant = {},
5302 .data = TestBuffer::createFromVector<float>({1.6f}),
5303 .dimensions = {},
5304 .isIgnored = false,
5305 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5306 .numberOfConsumers = 1,
5307 .scale = 0.0f,
5308 .type = TestOperandType::FLOAT32,
5309 .zeroPoint = 0
5310 }, { // layout
5311 .channelQuant = {},
5312 .data = TestBuffer::createFromVector<bool8>({true}),
5313 .dimensions = {},
5314 .isIgnored = false,
5315 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5316 .numberOfConsumers = 1,
5317 .scale = 0.0f,
5318 .type = TestOperandType::BOOL,
5319 .zeroPoint = 0
5320 }, { // op41
5321 .channelQuant = {},
5322 .data = TestBuffer::createFromVector<float>({3.0f, 5.0f, 6.0f, 7.0f, 9.0f, 10.0f, 9.0f, 11.0f, 12.0f, 4.0f, 8.0f, 10.0f, 8.0f, 12.0f, 14.0f, 10.0f, 14.0f, 16.0f}),
5323 .dimensions = {1, 2, 3, 3},
5324 .isIgnored = false,
5325 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5326 .numberOfConsumers = 0,
5327 .scale = 0.0f,
5328 .type = TestOperandType::TENSOR_FLOAT32,
5329 .zeroPoint = 0
5330 }},
5331 .operations = {{
5332 .inputs = {0, 1, 2, 3},
5333 .outputs = {4},
5334 .type = TestOperationType::RESIZE_BILINEAR
5335 }},
5336 .outputIndexes = {4}
5337 },
5338 .minSupportedVersion = TestHalVersion::V1_2,
5339 .referenced = {}
5340 };
5341 return model;
5342 }
5343
5344 const auto dummy_test_model_scale_nchw_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_2", get_test_model_scale_nchw_2());
5345
5346 } // namespace generated_tests::resize_bilinear_v1_2
5347
5348 namespace generated_tests::resize_bilinear_v1_2 {
5349
get_test_model_scale_nchw_all_inputs_as_internal_2()5350 const TestModel& get_test_model_scale_nchw_all_inputs_as_internal_2() {
5351 static TestModel model = {
5352 .expectFailure = false,
5353 .expectedMultinomialDistributionTolerance = 0,
5354 .isRelaxed = false,
5355 .main = { // scale
5356 .inputIndexes = {5},
5357 .operands = {{ // op11
5358 .channelQuant = {},
5359 .data = TestBuffer::createFromVector<float>({}),
5360 .dimensions = {1, 2, 2, 2},
5361 .isIgnored = false,
5362 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
5363 .numberOfConsumers = 1,
5364 .scale = 0.0f,
5365 .type = TestOperandType::TENSOR_FLOAT32,
5366 .zeroPoint = 0
5367 }, { // param6
5368 .channelQuant = {},
5369 .data = TestBuffer::createFromVector<float>({1.6f}),
5370 .dimensions = {},
5371 .isIgnored = false,
5372 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5373 .numberOfConsumers = 1,
5374 .scale = 0.0f,
5375 .type = TestOperandType::FLOAT32,
5376 .zeroPoint = 0
5377 }, { // param7
5378 .channelQuant = {},
5379 .data = TestBuffer::createFromVector<float>({1.6f}),
5380 .dimensions = {},
5381 .isIgnored = false,
5382 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5383 .numberOfConsumers = 1,
5384 .scale = 0.0f,
5385 .type = TestOperandType::FLOAT32,
5386 .zeroPoint = 0
5387 }, { // layout
5388 .channelQuant = {},
5389 .data = TestBuffer::createFromVector<bool8>({true}),
5390 .dimensions = {},
5391 .isIgnored = false,
5392 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5393 .numberOfConsumers = 1,
5394 .scale = 0.0f,
5395 .type = TestOperandType::BOOL,
5396 .zeroPoint = 0
5397 }, { // op41
5398 .channelQuant = {},
5399 .data = TestBuffer::createFromVector<float>({3.0f, 5.0f, 6.0f, 7.0f, 9.0f, 10.0f, 9.0f, 11.0f, 12.0f, 4.0f, 8.0f, 10.0f, 8.0f, 12.0f, 14.0f, 10.0f, 14.0f, 16.0f}),
5400 .dimensions = {1, 2, 3, 3},
5401 .isIgnored = false,
5402 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5403 .numberOfConsumers = 0,
5404 .scale = 0.0f,
5405 .type = TestOperandType::TENSOR_FLOAT32,
5406 .zeroPoint = 0
5407 }, { // op11_new
5408 .channelQuant = {},
5409 .data = TestBuffer::createFromVector<float>({3.0f, 6.0f, 9.0f, 12.0f, 4.0f, 10.0f, 10.0f, 16.0f}),
5410 .dimensions = {1, 2, 2, 2},
5411 .isIgnored = false,
5412 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5413 .numberOfConsumers = 1,
5414 .scale = 0.0f,
5415 .type = TestOperandType::TENSOR_FLOAT32,
5416 .zeroPoint = 0
5417 }, { // dummy28
5418 .channelQuant = {},
5419 .data = TestBuffer::createFromVector<float>({0.0f}),
5420 .dimensions = {1},
5421 .isIgnored = false,
5422 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5423 .numberOfConsumers = 1,
5424 .scale = 0.0f,
5425 .type = TestOperandType::TENSOR_FLOAT32,
5426 .zeroPoint = 0
5427 }, { // param70
5428 .channelQuant = {},
5429 .data = TestBuffer::createFromVector<int32_t>({0}),
5430 .dimensions = {},
5431 .isIgnored = false,
5432 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5433 .numberOfConsumers = 1,
5434 .scale = 0.0f,
5435 .type = TestOperandType::INT32,
5436 .zeroPoint = 0
5437 }},
5438 .operations = {{
5439 .inputs = {5, 6, 7},
5440 .outputs = {0},
5441 .type = TestOperationType::ADD
5442 }, {
5443 .inputs = {0, 1, 2, 3},
5444 .outputs = {4},
5445 .type = TestOperationType::RESIZE_BILINEAR
5446 }},
5447 .outputIndexes = {4}
5448 },
5449 .minSupportedVersion = TestHalVersion::V1_2,
5450 .referenced = {}
5451 };
5452 return model;
5453 }
5454
5455 const auto dummy_test_model_scale_nchw_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_all_inputs_as_internal_2", get_test_model_scale_nchw_all_inputs_as_internal_2());
5456
5457 } // namespace generated_tests::resize_bilinear_v1_2
5458
5459 namespace generated_tests::resize_bilinear_v1_2 {
5460
get_test_model_scale_nchw_relaxed_2()5461 const TestModel& get_test_model_scale_nchw_relaxed_2() {
5462 static TestModel model = {
5463 .expectFailure = false,
5464 .expectedMultinomialDistributionTolerance = 0,
5465 .isRelaxed = true,
5466 .main = { // scale
5467 .inputIndexes = {0},
5468 .operands = {{ // op11
5469 .channelQuant = {},
5470 .data = TestBuffer::createFromVector<float>({3.0f, 6.0f, 9.0f, 12.0f, 4.0f, 10.0f, 10.0f, 16.0f}),
5471 .dimensions = {1, 2, 2, 2},
5472 .isIgnored = false,
5473 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5474 .numberOfConsumers = 1,
5475 .scale = 0.0f,
5476 .type = TestOperandType::TENSOR_FLOAT32,
5477 .zeroPoint = 0
5478 }, { // param6
5479 .channelQuant = {},
5480 .data = TestBuffer::createFromVector<float>({1.6f}),
5481 .dimensions = {},
5482 .isIgnored = false,
5483 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5484 .numberOfConsumers = 1,
5485 .scale = 0.0f,
5486 .type = TestOperandType::FLOAT32,
5487 .zeroPoint = 0
5488 }, { // param7
5489 .channelQuant = {},
5490 .data = TestBuffer::createFromVector<float>({1.6f}),
5491 .dimensions = {},
5492 .isIgnored = false,
5493 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5494 .numberOfConsumers = 1,
5495 .scale = 0.0f,
5496 .type = TestOperandType::FLOAT32,
5497 .zeroPoint = 0
5498 }, { // layout
5499 .channelQuant = {},
5500 .data = TestBuffer::createFromVector<bool8>({true}),
5501 .dimensions = {},
5502 .isIgnored = false,
5503 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5504 .numberOfConsumers = 1,
5505 .scale = 0.0f,
5506 .type = TestOperandType::BOOL,
5507 .zeroPoint = 0
5508 }, { // op41
5509 .channelQuant = {},
5510 .data = TestBuffer::createFromVector<float>({3.0f, 5.0f, 6.0f, 7.0f, 9.0f, 10.0f, 9.0f, 11.0f, 12.0f, 4.0f, 8.0f, 10.0f, 8.0f, 12.0f, 14.0f, 10.0f, 14.0f, 16.0f}),
5511 .dimensions = {1, 2, 3, 3},
5512 .isIgnored = false,
5513 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5514 .numberOfConsumers = 0,
5515 .scale = 0.0f,
5516 .type = TestOperandType::TENSOR_FLOAT32,
5517 .zeroPoint = 0
5518 }},
5519 .operations = {{
5520 .inputs = {0, 1, 2, 3},
5521 .outputs = {4},
5522 .type = TestOperationType::RESIZE_BILINEAR
5523 }},
5524 .outputIndexes = {4}
5525 },
5526 .minSupportedVersion = TestHalVersion::UNKNOWN,
5527 .referenced = {}
5528 };
5529 return model;
5530 }
5531
5532 const auto dummy_test_model_scale_nchw_relaxed_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_relaxed_2", get_test_model_scale_nchw_relaxed_2());
5533
5534 } // namespace generated_tests::resize_bilinear_v1_2
5535
5536 namespace generated_tests::resize_bilinear_v1_2 {
5537
get_test_model_scale_nchw_relaxed_all_inputs_as_internal_2()5538 const TestModel& get_test_model_scale_nchw_relaxed_all_inputs_as_internal_2() {
5539 static TestModel model = {
5540 .expectFailure = false,
5541 .expectedMultinomialDistributionTolerance = 0,
5542 .isRelaxed = true,
5543 .main = { // scale
5544 .inputIndexes = {5},
5545 .operands = {{ // op11
5546 .channelQuant = {},
5547 .data = TestBuffer::createFromVector<float>({}),
5548 .dimensions = {1, 2, 2, 2},
5549 .isIgnored = false,
5550 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
5551 .numberOfConsumers = 1,
5552 .scale = 0.0f,
5553 .type = TestOperandType::TENSOR_FLOAT32,
5554 .zeroPoint = 0
5555 }, { // param6
5556 .channelQuant = {},
5557 .data = TestBuffer::createFromVector<float>({1.6f}),
5558 .dimensions = {},
5559 .isIgnored = false,
5560 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5561 .numberOfConsumers = 1,
5562 .scale = 0.0f,
5563 .type = TestOperandType::FLOAT32,
5564 .zeroPoint = 0
5565 }, { // param7
5566 .channelQuant = {},
5567 .data = TestBuffer::createFromVector<float>({1.6f}),
5568 .dimensions = {},
5569 .isIgnored = false,
5570 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5571 .numberOfConsumers = 1,
5572 .scale = 0.0f,
5573 .type = TestOperandType::FLOAT32,
5574 .zeroPoint = 0
5575 }, { // layout
5576 .channelQuant = {},
5577 .data = TestBuffer::createFromVector<bool8>({true}),
5578 .dimensions = {},
5579 .isIgnored = false,
5580 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5581 .numberOfConsumers = 1,
5582 .scale = 0.0f,
5583 .type = TestOperandType::BOOL,
5584 .zeroPoint = 0
5585 }, { // op41
5586 .channelQuant = {},
5587 .data = TestBuffer::createFromVector<float>({3.0f, 5.0f, 6.0f, 7.0f, 9.0f, 10.0f, 9.0f, 11.0f, 12.0f, 4.0f, 8.0f, 10.0f, 8.0f, 12.0f, 14.0f, 10.0f, 14.0f, 16.0f}),
5588 .dimensions = {1, 2, 3, 3},
5589 .isIgnored = false,
5590 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5591 .numberOfConsumers = 0,
5592 .scale = 0.0f,
5593 .type = TestOperandType::TENSOR_FLOAT32,
5594 .zeroPoint = 0
5595 }, { // op11_new
5596 .channelQuant = {},
5597 .data = TestBuffer::createFromVector<float>({3.0f, 6.0f, 9.0f, 12.0f, 4.0f, 10.0f, 10.0f, 16.0f}),
5598 .dimensions = {1, 2, 2, 2},
5599 .isIgnored = false,
5600 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5601 .numberOfConsumers = 1,
5602 .scale = 0.0f,
5603 .type = TestOperandType::TENSOR_FLOAT32,
5604 .zeroPoint = 0
5605 }, { // dummy29
5606 .channelQuant = {},
5607 .data = TestBuffer::createFromVector<float>({0.0f}),
5608 .dimensions = {1},
5609 .isIgnored = false,
5610 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5611 .numberOfConsumers = 1,
5612 .scale = 0.0f,
5613 .type = TestOperandType::TENSOR_FLOAT32,
5614 .zeroPoint = 0
5615 }, { // param71
5616 .channelQuant = {},
5617 .data = TestBuffer::createFromVector<int32_t>({0}),
5618 .dimensions = {},
5619 .isIgnored = false,
5620 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5621 .numberOfConsumers = 1,
5622 .scale = 0.0f,
5623 .type = TestOperandType::INT32,
5624 .zeroPoint = 0
5625 }},
5626 .operations = {{
5627 .inputs = {5, 6, 7},
5628 .outputs = {0},
5629 .type = TestOperationType::ADD
5630 }, {
5631 .inputs = {0, 1, 2, 3},
5632 .outputs = {4},
5633 .type = TestOperationType::RESIZE_BILINEAR
5634 }},
5635 .outputIndexes = {4}
5636 },
5637 .minSupportedVersion = TestHalVersion::UNKNOWN,
5638 .referenced = {}
5639 };
5640 return model;
5641 }
5642
5643 const auto dummy_test_model_scale_nchw_relaxed_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_relaxed_all_inputs_as_internal_2", get_test_model_scale_nchw_relaxed_all_inputs_as_internal_2());
5644
5645 } // namespace generated_tests::resize_bilinear_v1_2
5646
5647 namespace generated_tests::resize_bilinear_v1_2 {
5648
get_test_model_scale_nchw_float16_2()5649 const TestModel& get_test_model_scale_nchw_float16_2() {
5650 static TestModel model = {
5651 .expectFailure = false,
5652 .expectedMultinomialDistributionTolerance = 0,
5653 .isRelaxed = false,
5654 .main = { // scale
5655 .inputIndexes = {0},
5656 .operands = {{ // op11
5657 .channelQuant = {},
5658 .data = TestBuffer::createFromVector<_Float16>({3.0f, 6.0f, 9.0f, 12.0f, 4.0f, 10.0f, 10.0f, 16.0f}),
5659 .dimensions = {1, 2, 2, 2},
5660 .isIgnored = false,
5661 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5662 .numberOfConsumers = 1,
5663 .scale = 0.0f,
5664 .type = TestOperandType::TENSOR_FLOAT16,
5665 .zeroPoint = 0
5666 }, { // param6
5667 .channelQuant = {},
5668 .data = TestBuffer::createFromVector<_Float16>({1.600000023841858f}),
5669 .dimensions = {},
5670 .isIgnored = false,
5671 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5672 .numberOfConsumers = 1,
5673 .scale = 0.0f,
5674 .type = TestOperandType::FLOAT16,
5675 .zeroPoint = 0
5676 }, { // param7
5677 .channelQuant = {},
5678 .data = TestBuffer::createFromVector<_Float16>({1.600000023841858f}),
5679 .dimensions = {},
5680 .isIgnored = false,
5681 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5682 .numberOfConsumers = 1,
5683 .scale = 0.0f,
5684 .type = TestOperandType::FLOAT16,
5685 .zeroPoint = 0
5686 }, { // layout
5687 .channelQuant = {},
5688 .data = TestBuffer::createFromVector<bool8>({true}),
5689 .dimensions = {},
5690 .isIgnored = false,
5691 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5692 .numberOfConsumers = 1,
5693 .scale = 0.0f,
5694 .type = TestOperandType::BOOL,
5695 .zeroPoint = 0
5696 }, { // op41
5697 .channelQuant = {},
5698 .data = TestBuffer::createFromVector<_Float16>({3.0f, 5.0f, 6.0f, 7.0f, 9.0f, 10.0f, 9.0f, 11.0f, 12.0f, 4.0f, 8.0f, 10.0f, 8.0f, 12.0f, 14.0f, 10.0f, 14.0f, 16.0f}),
5699 .dimensions = {1, 2, 3, 3},
5700 .isIgnored = false,
5701 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5702 .numberOfConsumers = 0,
5703 .scale = 0.0f,
5704 .type = TestOperandType::TENSOR_FLOAT16,
5705 .zeroPoint = 0
5706 }},
5707 .operations = {{
5708 .inputs = {0, 1, 2, 3},
5709 .outputs = {4},
5710 .type = TestOperationType::RESIZE_BILINEAR
5711 }},
5712 .outputIndexes = {4}
5713 },
5714 .minSupportedVersion = TestHalVersion::V1_2,
5715 .referenced = {}
5716 };
5717 return model;
5718 }
5719
5720 const auto dummy_test_model_scale_nchw_float16_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_float16_2", get_test_model_scale_nchw_float16_2());
5721
5722 } // namespace generated_tests::resize_bilinear_v1_2
5723
5724 namespace generated_tests::resize_bilinear_v1_2 {
5725
get_test_model_scale_nchw_float16_all_inputs_as_internal_2()5726 const TestModel& get_test_model_scale_nchw_float16_all_inputs_as_internal_2() {
5727 static TestModel model = {
5728 .expectFailure = false,
5729 .expectedMultinomialDistributionTolerance = 0,
5730 .isRelaxed = false,
5731 .main = { // scale
5732 .inputIndexes = {5},
5733 .operands = {{ // op11
5734 .channelQuant = {},
5735 .data = TestBuffer::createFromVector<_Float16>({}),
5736 .dimensions = {1, 2, 2, 2},
5737 .isIgnored = false,
5738 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
5739 .numberOfConsumers = 1,
5740 .scale = 0.0f,
5741 .type = TestOperandType::TENSOR_FLOAT16,
5742 .zeroPoint = 0
5743 }, { // param6
5744 .channelQuant = {},
5745 .data = TestBuffer::createFromVector<_Float16>({1.600000023841858f}),
5746 .dimensions = {},
5747 .isIgnored = false,
5748 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5749 .numberOfConsumers = 1,
5750 .scale = 0.0f,
5751 .type = TestOperandType::FLOAT16,
5752 .zeroPoint = 0
5753 }, { // param7
5754 .channelQuant = {},
5755 .data = TestBuffer::createFromVector<_Float16>({1.600000023841858f}),
5756 .dimensions = {},
5757 .isIgnored = false,
5758 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5759 .numberOfConsumers = 1,
5760 .scale = 0.0f,
5761 .type = TestOperandType::FLOAT16,
5762 .zeroPoint = 0
5763 }, { // layout
5764 .channelQuant = {},
5765 .data = TestBuffer::createFromVector<bool8>({true}),
5766 .dimensions = {},
5767 .isIgnored = false,
5768 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5769 .numberOfConsumers = 1,
5770 .scale = 0.0f,
5771 .type = TestOperandType::BOOL,
5772 .zeroPoint = 0
5773 }, { // op41
5774 .channelQuant = {},
5775 .data = TestBuffer::createFromVector<_Float16>({3.0f, 5.0f, 6.0f, 7.0f, 9.0f, 10.0f, 9.0f, 11.0f, 12.0f, 4.0f, 8.0f, 10.0f, 8.0f, 12.0f, 14.0f, 10.0f, 14.0f, 16.0f}),
5776 .dimensions = {1, 2, 3, 3},
5777 .isIgnored = false,
5778 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5779 .numberOfConsumers = 0,
5780 .scale = 0.0f,
5781 .type = TestOperandType::TENSOR_FLOAT16,
5782 .zeroPoint = 0
5783 }, { // op11_new
5784 .channelQuant = {},
5785 .data = TestBuffer::createFromVector<_Float16>({3.0f, 6.0f, 9.0f, 12.0f, 4.0f, 10.0f, 10.0f, 16.0f}),
5786 .dimensions = {1, 2, 2, 2},
5787 .isIgnored = false,
5788 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5789 .numberOfConsumers = 1,
5790 .scale = 0.0f,
5791 .type = TestOperandType::TENSOR_FLOAT16,
5792 .zeroPoint = 0
5793 }, { // dummy30
5794 .channelQuant = {},
5795 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
5796 .dimensions = {1},
5797 .isIgnored = false,
5798 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5799 .numberOfConsumers = 1,
5800 .scale = 0.0f,
5801 .type = TestOperandType::TENSOR_FLOAT16,
5802 .zeroPoint = 0
5803 }, { // param72
5804 .channelQuant = {},
5805 .data = TestBuffer::createFromVector<int32_t>({0}),
5806 .dimensions = {},
5807 .isIgnored = false,
5808 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5809 .numberOfConsumers = 1,
5810 .scale = 0.0f,
5811 .type = TestOperandType::INT32,
5812 .zeroPoint = 0
5813 }},
5814 .operations = {{
5815 .inputs = {5, 6, 7},
5816 .outputs = {0},
5817 .type = TestOperationType::ADD
5818 }, {
5819 .inputs = {0, 1, 2, 3},
5820 .outputs = {4},
5821 .type = TestOperationType::RESIZE_BILINEAR
5822 }},
5823 .outputIndexes = {4}
5824 },
5825 .minSupportedVersion = TestHalVersion::V1_2,
5826 .referenced = {}
5827 };
5828 return model;
5829 }
5830
5831 const auto dummy_test_model_scale_nchw_float16_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_float16_all_inputs_as_internal_2", get_test_model_scale_nchw_float16_all_inputs_as_internal_2());
5832
5833 } // namespace generated_tests::resize_bilinear_v1_2
5834
5835 namespace generated_tests::resize_bilinear_v1_2 {
5836
get_test_model_scale_nchw_quant8_2()5837 const TestModel& get_test_model_scale_nchw_quant8_2() {
5838 static TestModel model = {
5839 .expectFailure = false,
5840 .expectedMultinomialDistributionTolerance = 0,
5841 .isRelaxed = false,
5842 .main = { // scale
5843 .inputIndexes = {0},
5844 .operands = {{ // op11
5845 .channelQuant = {},
5846 .data = TestBuffer::createFromVector<uint8_t>({12, 24, 36, 48, 16, 40, 40, 64}),
5847 .dimensions = {1, 2, 2, 2},
5848 .isIgnored = false,
5849 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5850 .numberOfConsumers = 1,
5851 .scale = 0.25f,
5852 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
5853 .zeroPoint = 0
5854 }, { // param6
5855 .channelQuant = {},
5856 .data = TestBuffer::createFromVector<float>({1.6f}),
5857 .dimensions = {},
5858 .isIgnored = false,
5859 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5860 .numberOfConsumers = 1,
5861 .scale = 0.0f,
5862 .type = TestOperandType::FLOAT32,
5863 .zeroPoint = 0
5864 }, { // param7
5865 .channelQuant = {},
5866 .data = TestBuffer::createFromVector<float>({1.6f}),
5867 .dimensions = {},
5868 .isIgnored = false,
5869 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5870 .numberOfConsumers = 1,
5871 .scale = 0.0f,
5872 .type = TestOperandType::FLOAT32,
5873 .zeroPoint = 0
5874 }, { // layout
5875 .channelQuant = {},
5876 .data = TestBuffer::createFromVector<bool8>({true}),
5877 .dimensions = {},
5878 .isIgnored = false,
5879 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5880 .numberOfConsumers = 1,
5881 .scale = 0.0f,
5882 .type = TestOperandType::BOOL,
5883 .zeroPoint = 0
5884 }, { // op41
5885 .channelQuant = {},
5886 .data = TestBuffer::createFromVector<uint8_t>({12, 20, 24, 28, 36, 40, 36, 44, 48, 16, 32, 40, 32, 48, 56, 40, 56, 64}),
5887 .dimensions = {1, 2, 3, 3},
5888 .isIgnored = false,
5889 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5890 .numberOfConsumers = 0,
5891 .scale = 0.25f,
5892 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
5893 .zeroPoint = 0
5894 }},
5895 .operations = {{
5896 .inputs = {0, 1, 2, 3},
5897 .outputs = {4},
5898 .type = TestOperationType::RESIZE_BILINEAR
5899 }},
5900 .outputIndexes = {4}
5901 },
5902 .minSupportedVersion = TestHalVersion::V1_2,
5903 .referenced = {}
5904 };
5905 return model;
5906 }
5907
5908 const auto dummy_test_model_scale_nchw_quant8_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_quant8_2", get_test_model_scale_nchw_quant8_2());
5909
5910 } // namespace generated_tests::resize_bilinear_v1_2
5911
5912 namespace generated_tests::resize_bilinear_v1_2 {
5913
get_test_model_scale_nchw_quant8_all_inputs_as_internal_2()5914 const TestModel& get_test_model_scale_nchw_quant8_all_inputs_as_internal_2() {
5915 static TestModel model = {
5916 .expectFailure = false,
5917 .expectedMultinomialDistributionTolerance = 0,
5918 .isRelaxed = false,
5919 .main = { // scale
5920 .inputIndexes = {5},
5921 .operands = {{ // op11
5922 .channelQuant = {},
5923 .data = TestBuffer::createFromVector<uint8_t>({}),
5924 .dimensions = {1, 2, 2, 2},
5925 .isIgnored = false,
5926 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
5927 .numberOfConsumers = 1,
5928 .scale = 0.25f,
5929 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
5930 .zeroPoint = 0
5931 }, { // param6
5932 .channelQuant = {},
5933 .data = TestBuffer::createFromVector<float>({1.6f}),
5934 .dimensions = {},
5935 .isIgnored = false,
5936 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5937 .numberOfConsumers = 1,
5938 .scale = 0.0f,
5939 .type = TestOperandType::FLOAT32,
5940 .zeroPoint = 0
5941 }, { // param7
5942 .channelQuant = {},
5943 .data = TestBuffer::createFromVector<float>({1.6f}),
5944 .dimensions = {},
5945 .isIgnored = false,
5946 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5947 .numberOfConsumers = 1,
5948 .scale = 0.0f,
5949 .type = TestOperandType::FLOAT32,
5950 .zeroPoint = 0
5951 }, { // layout
5952 .channelQuant = {},
5953 .data = TestBuffer::createFromVector<bool8>({true}),
5954 .dimensions = {},
5955 .isIgnored = false,
5956 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5957 .numberOfConsumers = 1,
5958 .scale = 0.0f,
5959 .type = TestOperandType::BOOL,
5960 .zeroPoint = 0
5961 }, { // op41
5962 .channelQuant = {},
5963 .data = TestBuffer::createFromVector<uint8_t>({12, 20, 24, 28, 36, 40, 36, 44, 48, 16, 32, 40, 32, 48, 56, 40, 56, 64}),
5964 .dimensions = {1, 2, 3, 3},
5965 .isIgnored = false,
5966 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
5967 .numberOfConsumers = 0,
5968 .scale = 0.25f,
5969 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
5970 .zeroPoint = 0
5971 }, { // op11_new
5972 .channelQuant = {},
5973 .data = TestBuffer::createFromVector<uint8_t>({12, 24, 36, 48, 16, 40, 40, 64}),
5974 .dimensions = {1, 2, 2, 2},
5975 .isIgnored = false,
5976 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
5977 .numberOfConsumers = 1,
5978 .scale = 0.25f,
5979 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
5980 .zeroPoint = 0
5981 }, { // dummy31
5982 .channelQuant = {},
5983 .data = TestBuffer::createFromVector<uint8_t>({0}),
5984 .dimensions = {1},
5985 .isIgnored = false,
5986 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5987 .numberOfConsumers = 1,
5988 .scale = 0.25f,
5989 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
5990 .zeroPoint = 0
5991 }, { // param73
5992 .channelQuant = {},
5993 .data = TestBuffer::createFromVector<int32_t>({0}),
5994 .dimensions = {},
5995 .isIgnored = false,
5996 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
5997 .numberOfConsumers = 1,
5998 .scale = 0.0f,
5999 .type = TestOperandType::INT32,
6000 .zeroPoint = 0
6001 }},
6002 .operations = {{
6003 .inputs = {5, 6, 7},
6004 .outputs = {0},
6005 .type = TestOperationType::ADD
6006 }, {
6007 .inputs = {0, 1, 2, 3},
6008 .outputs = {4},
6009 .type = TestOperationType::RESIZE_BILINEAR
6010 }},
6011 .outputIndexes = {4}
6012 },
6013 .minSupportedVersion = TestHalVersion::V1_2,
6014 .referenced = {}
6015 };
6016 return model;
6017 }
6018
6019 const auto dummy_test_model_scale_nchw_quant8_all_inputs_as_internal_2 = TestModelManager::get().add("resize_bilinear_v1_2_scale_nchw_quant8_all_inputs_as_internal_2", get_test_model_scale_nchw_quant8_all_inputs_as_internal_2());
6020
6021 } // namespace generated_tests::resize_bilinear_v1_2
6022
6023 namespace generated_tests::resize_bilinear_v1_2 {
6024
get_test_model_shape_float16()6025 const TestModel& get_test_model_shape_float16() {
6026 static TestModel model = {
6027 .expectFailure = false,
6028 .expectedMultinomialDistributionTolerance = 0,
6029 .isRelaxed = false,
6030 .main = { // shape
6031 .inputIndexes = {0},
6032 .operands = {{ // op12
6033 .channelQuant = {},
6034 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 2.0f, 2.0f}),
6035 .dimensions = {1, 2, 2, 1},
6036 .isIgnored = false,
6037 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6038 .numberOfConsumers = 1,
6039 .scale = 0.0f,
6040 .type = TestOperandType::TENSOR_FLOAT16,
6041 .zeroPoint = 0
6042 }, { // param8
6043 .channelQuant = {},
6044 .data = TestBuffer::createFromVector<int32_t>({3}),
6045 .dimensions = {},
6046 .isIgnored = false,
6047 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6048 .numberOfConsumers = 1,
6049 .scale = 0.0f,
6050 .type = TestOperandType::INT32,
6051 .zeroPoint = 0
6052 }, { // param9
6053 .channelQuant = {},
6054 .data = TestBuffer::createFromVector<int32_t>({3}),
6055 .dimensions = {},
6056 .isIgnored = false,
6057 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6058 .numberOfConsumers = 1,
6059 .scale = 0.0f,
6060 .type = TestOperandType::INT32,
6061 .zeroPoint = 0
6062 }, { // op42
6063 .channelQuant = {},
6064 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 1.0f, 1.6666666269302368f, 1.6666666269302368f, 1.6666666269302368f, 2.0f, 2.0f, 2.0f}),
6065 .dimensions = {1, 3, 3, 1},
6066 .isIgnored = false,
6067 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6068 .numberOfConsumers = 0,
6069 .scale = 0.0f,
6070 .type = TestOperandType::TENSOR_FLOAT16,
6071 .zeroPoint = 0
6072 }},
6073 .operations = {{
6074 .inputs = {0, 1, 2},
6075 .outputs = {3},
6076 .type = TestOperationType::RESIZE_BILINEAR
6077 }},
6078 .outputIndexes = {3}
6079 },
6080 .minSupportedVersion = TestHalVersion::V1_2,
6081 .referenced = {}
6082 };
6083 return model;
6084 }
6085
6086 const auto dummy_test_model_shape_float16 = TestModelManager::get().add("resize_bilinear_v1_2_shape_float16", get_test_model_shape_float16());
6087
6088 } // namespace generated_tests::resize_bilinear_v1_2
6089
6090 namespace generated_tests::resize_bilinear_v1_2 {
6091
get_test_model_shape_float16_all_inputs_as_internal()6092 const TestModel& get_test_model_shape_float16_all_inputs_as_internal() {
6093 static TestModel model = {
6094 .expectFailure = false,
6095 .expectedMultinomialDistributionTolerance = 0,
6096 .isRelaxed = false,
6097 .main = { // shape
6098 .inputIndexes = {4},
6099 .operands = {{ // op12
6100 .channelQuant = {},
6101 .data = TestBuffer::createFromVector<_Float16>({}),
6102 .dimensions = {1, 2, 2, 1},
6103 .isIgnored = false,
6104 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
6105 .numberOfConsumers = 1,
6106 .scale = 0.0f,
6107 .type = TestOperandType::TENSOR_FLOAT16,
6108 .zeroPoint = 0
6109 }, { // param8
6110 .channelQuant = {},
6111 .data = TestBuffer::createFromVector<int32_t>({3}),
6112 .dimensions = {},
6113 .isIgnored = false,
6114 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6115 .numberOfConsumers = 1,
6116 .scale = 0.0f,
6117 .type = TestOperandType::INT32,
6118 .zeroPoint = 0
6119 }, { // param9
6120 .channelQuant = {},
6121 .data = TestBuffer::createFromVector<int32_t>({3}),
6122 .dimensions = {},
6123 .isIgnored = false,
6124 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6125 .numberOfConsumers = 1,
6126 .scale = 0.0f,
6127 .type = TestOperandType::INT32,
6128 .zeroPoint = 0
6129 }, { // op42
6130 .channelQuant = {},
6131 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 1.0f, 1.6666666269302368f, 1.6666666269302368f, 1.6666666269302368f, 2.0f, 2.0f, 2.0f}),
6132 .dimensions = {1, 3, 3, 1},
6133 .isIgnored = false,
6134 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6135 .numberOfConsumers = 0,
6136 .scale = 0.0f,
6137 .type = TestOperandType::TENSOR_FLOAT16,
6138 .zeroPoint = 0
6139 }, { // op12_new
6140 .channelQuant = {},
6141 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 2.0f, 2.0f}),
6142 .dimensions = {1, 2, 2, 1},
6143 .isIgnored = false,
6144 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6145 .numberOfConsumers = 1,
6146 .scale = 0.0f,
6147 .type = TestOperandType::TENSOR_FLOAT16,
6148 .zeroPoint = 0
6149 }, { // dummy32
6150 .channelQuant = {},
6151 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
6152 .dimensions = {1},
6153 .isIgnored = false,
6154 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6155 .numberOfConsumers = 1,
6156 .scale = 0.0f,
6157 .type = TestOperandType::TENSOR_FLOAT16,
6158 .zeroPoint = 0
6159 }, { // param74
6160 .channelQuant = {},
6161 .data = TestBuffer::createFromVector<int32_t>({0}),
6162 .dimensions = {},
6163 .isIgnored = false,
6164 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6165 .numberOfConsumers = 1,
6166 .scale = 0.0f,
6167 .type = TestOperandType::INT32,
6168 .zeroPoint = 0
6169 }},
6170 .operations = {{
6171 .inputs = {4, 5, 6},
6172 .outputs = {0},
6173 .type = TestOperationType::ADD
6174 }, {
6175 .inputs = {0, 1, 2},
6176 .outputs = {3},
6177 .type = TestOperationType::RESIZE_BILINEAR
6178 }},
6179 .outputIndexes = {3}
6180 },
6181 .minSupportedVersion = TestHalVersion::V1_2,
6182 .referenced = {}
6183 };
6184 return model;
6185 }
6186
6187 const auto dummy_test_model_shape_float16_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_shape_float16_all_inputs_as_internal", get_test_model_shape_float16_all_inputs_as_internal());
6188
6189 } // namespace generated_tests::resize_bilinear_v1_2
6190
6191 namespace generated_tests::resize_bilinear_v1_2 {
6192
get_test_model_shape_quant8()6193 const TestModel& get_test_model_shape_quant8() {
6194 static TestModel model = {
6195 .expectFailure = false,
6196 .expectedMultinomialDistributionTolerance = 0,
6197 .isRelaxed = false,
6198 .main = { // shape
6199 .inputIndexes = {0},
6200 .operands = {{ // op12
6201 .channelQuant = {},
6202 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 200, 200}),
6203 .dimensions = {1, 2, 2, 1},
6204 .isIgnored = false,
6205 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6206 .numberOfConsumers = 1,
6207 .scale = 0.01f,
6208 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
6209 .zeroPoint = 0
6210 }, { // param8
6211 .channelQuant = {},
6212 .data = TestBuffer::createFromVector<int32_t>({3}),
6213 .dimensions = {},
6214 .isIgnored = false,
6215 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6216 .numberOfConsumers = 1,
6217 .scale = 0.0f,
6218 .type = TestOperandType::INT32,
6219 .zeroPoint = 0
6220 }, { // param9
6221 .channelQuant = {},
6222 .data = TestBuffer::createFromVector<int32_t>({3}),
6223 .dimensions = {},
6224 .isIgnored = false,
6225 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6226 .numberOfConsumers = 1,
6227 .scale = 0.0f,
6228 .type = TestOperandType::INT32,
6229 .zeroPoint = 0
6230 }, { // op42
6231 .channelQuant = {},
6232 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 100, 167, 167, 167, 200, 200, 200}),
6233 .dimensions = {1, 3, 3, 1},
6234 .isIgnored = false,
6235 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6236 .numberOfConsumers = 0,
6237 .scale = 0.01f,
6238 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
6239 .zeroPoint = 0
6240 }},
6241 .operations = {{
6242 .inputs = {0, 1, 2},
6243 .outputs = {3},
6244 .type = TestOperationType::RESIZE_BILINEAR
6245 }},
6246 .outputIndexes = {3}
6247 },
6248 .minSupportedVersion = TestHalVersion::V1_2,
6249 .referenced = {}
6250 };
6251 return model;
6252 }
6253
6254 const auto dummy_test_model_shape_quant8 = TestModelManager::get().add("resize_bilinear_v1_2_shape_quant8", get_test_model_shape_quant8());
6255
6256 } // namespace generated_tests::resize_bilinear_v1_2
6257
6258 namespace generated_tests::resize_bilinear_v1_2 {
6259
get_test_model_shape_quant8_all_inputs_as_internal()6260 const TestModel& get_test_model_shape_quant8_all_inputs_as_internal() {
6261 static TestModel model = {
6262 .expectFailure = false,
6263 .expectedMultinomialDistributionTolerance = 0,
6264 .isRelaxed = false,
6265 .main = { // shape
6266 .inputIndexes = {4},
6267 .operands = {{ // op12
6268 .channelQuant = {},
6269 .data = TestBuffer::createFromVector<uint8_t>({}),
6270 .dimensions = {1, 2, 2, 1},
6271 .isIgnored = false,
6272 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
6273 .numberOfConsumers = 1,
6274 .scale = 0.01f,
6275 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
6276 .zeroPoint = 0
6277 }, { // param8
6278 .channelQuant = {},
6279 .data = TestBuffer::createFromVector<int32_t>({3}),
6280 .dimensions = {},
6281 .isIgnored = false,
6282 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6283 .numberOfConsumers = 1,
6284 .scale = 0.0f,
6285 .type = TestOperandType::INT32,
6286 .zeroPoint = 0
6287 }, { // param9
6288 .channelQuant = {},
6289 .data = TestBuffer::createFromVector<int32_t>({3}),
6290 .dimensions = {},
6291 .isIgnored = false,
6292 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6293 .numberOfConsumers = 1,
6294 .scale = 0.0f,
6295 .type = TestOperandType::INT32,
6296 .zeroPoint = 0
6297 }, { // op42
6298 .channelQuant = {},
6299 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 100, 167, 167, 167, 200, 200, 200}),
6300 .dimensions = {1, 3, 3, 1},
6301 .isIgnored = false,
6302 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6303 .numberOfConsumers = 0,
6304 .scale = 0.01f,
6305 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
6306 .zeroPoint = 0
6307 }, { // op12_new
6308 .channelQuant = {},
6309 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 200, 200}),
6310 .dimensions = {1, 2, 2, 1},
6311 .isIgnored = false,
6312 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6313 .numberOfConsumers = 1,
6314 .scale = 0.01f,
6315 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
6316 .zeroPoint = 0
6317 }, { // dummy33
6318 .channelQuant = {},
6319 .data = TestBuffer::createFromVector<uint8_t>({0}),
6320 .dimensions = {1},
6321 .isIgnored = false,
6322 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6323 .numberOfConsumers = 1,
6324 .scale = 0.01f,
6325 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
6326 .zeroPoint = 0
6327 }, { // param75
6328 .channelQuant = {},
6329 .data = TestBuffer::createFromVector<int32_t>({0}),
6330 .dimensions = {},
6331 .isIgnored = false,
6332 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6333 .numberOfConsumers = 1,
6334 .scale = 0.0f,
6335 .type = TestOperandType::INT32,
6336 .zeroPoint = 0
6337 }},
6338 .operations = {{
6339 .inputs = {4, 5, 6},
6340 .outputs = {0},
6341 .type = TestOperationType::ADD
6342 }, {
6343 .inputs = {0, 1, 2},
6344 .outputs = {3},
6345 .type = TestOperationType::RESIZE_BILINEAR
6346 }},
6347 .outputIndexes = {3}
6348 },
6349 .minSupportedVersion = TestHalVersion::V1_2,
6350 .referenced = {}
6351 };
6352 return model;
6353 }
6354
6355 const auto dummy_test_model_shape_quant8_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_shape_quant8_all_inputs_as_internal", get_test_model_shape_quant8_all_inputs_as_internal());
6356
6357 } // namespace generated_tests::resize_bilinear_v1_2
6358
6359 namespace generated_tests::resize_bilinear_v1_2 {
6360
get_test_model_scale_float16()6361 const TestModel& get_test_model_scale_float16() {
6362 static TestModel model = {
6363 .expectFailure = false,
6364 .expectedMultinomialDistributionTolerance = 0,
6365 .isRelaxed = false,
6366 .main = { // scale
6367 .inputIndexes = {0},
6368 .operands = {{ // op12
6369 .channelQuant = {},
6370 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 2.0f, 2.0f}),
6371 .dimensions = {1, 2, 2, 1},
6372 .isIgnored = false,
6373 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6374 .numberOfConsumers = 1,
6375 .scale = 0.0f,
6376 .type = TestOperandType::TENSOR_FLOAT16,
6377 .zeroPoint = 0
6378 }, { // param10
6379 .channelQuant = {},
6380 .data = TestBuffer::createFromVector<_Float16>({1.7999999523162842f}),
6381 .dimensions = {},
6382 .isIgnored = false,
6383 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6384 .numberOfConsumers = 1,
6385 .scale = 0.0f,
6386 .type = TestOperandType::FLOAT16,
6387 .zeroPoint = 0
6388 }, { // param11
6389 .channelQuant = {},
6390 .data = TestBuffer::createFromVector<_Float16>({1.7999999523162842f}),
6391 .dimensions = {},
6392 .isIgnored = false,
6393 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6394 .numberOfConsumers = 1,
6395 .scale = 0.0f,
6396 .type = TestOperandType::FLOAT16,
6397 .zeroPoint = 0
6398 }, { // op42
6399 .channelQuant = {},
6400 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 1.0f, 1.6666666269302368f, 1.6666666269302368f, 1.6666666269302368f, 2.0f, 2.0f, 2.0f}),
6401 .dimensions = {1, 3, 3, 1},
6402 .isIgnored = false,
6403 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6404 .numberOfConsumers = 0,
6405 .scale = 0.0f,
6406 .type = TestOperandType::TENSOR_FLOAT16,
6407 .zeroPoint = 0
6408 }},
6409 .operations = {{
6410 .inputs = {0, 1, 2},
6411 .outputs = {3},
6412 .type = TestOperationType::RESIZE_BILINEAR
6413 }},
6414 .outputIndexes = {3}
6415 },
6416 .minSupportedVersion = TestHalVersion::V1_2,
6417 .referenced = {}
6418 };
6419 return model;
6420 }
6421
6422 const auto dummy_test_model_scale_float16 = TestModelManager::get().add("resize_bilinear_v1_2_scale_float16", get_test_model_scale_float16());
6423
6424 } // namespace generated_tests::resize_bilinear_v1_2
6425
6426 namespace generated_tests::resize_bilinear_v1_2 {
6427
get_test_model_scale_float16_all_inputs_as_internal()6428 const TestModel& get_test_model_scale_float16_all_inputs_as_internal() {
6429 static TestModel model = {
6430 .expectFailure = false,
6431 .expectedMultinomialDistributionTolerance = 0,
6432 .isRelaxed = false,
6433 .main = { // scale
6434 .inputIndexes = {4},
6435 .operands = {{ // op12
6436 .channelQuant = {},
6437 .data = TestBuffer::createFromVector<_Float16>({}),
6438 .dimensions = {1, 2, 2, 1},
6439 .isIgnored = false,
6440 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
6441 .numberOfConsumers = 1,
6442 .scale = 0.0f,
6443 .type = TestOperandType::TENSOR_FLOAT16,
6444 .zeroPoint = 0
6445 }, { // param10
6446 .channelQuant = {},
6447 .data = TestBuffer::createFromVector<_Float16>({1.7999999523162842f}),
6448 .dimensions = {},
6449 .isIgnored = false,
6450 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6451 .numberOfConsumers = 1,
6452 .scale = 0.0f,
6453 .type = TestOperandType::FLOAT16,
6454 .zeroPoint = 0
6455 }, { // param11
6456 .channelQuant = {},
6457 .data = TestBuffer::createFromVector<_Float16>({1.7999999523162842f}),
6458 .dimensions = {},
6459 .isIgnored = false,
6460 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6461 .numberOfConsumers = 1,
6462 .scale = 0.0f,
6463 .type = TestOperandType::FLOAT16,
6464 .zeroPoint = 0
6465 }, { // op42
6466 .channelQuant = {},
6467 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 1.0f, 1.6666666269302368f, 1.6666666269302368f, 1.6666666269302368f, 2.0f, 2.0f, 2.0f}),
6468 .dimensions = {1, 3, 3, 1},
6469 .isIgnored = false,
6470 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6471 .numberOfConsumers = 0,
6472 .scale = 0.0f,
6473 .type = TestOperandType::TENSOR_FLOAT16,
6474 .zeroPoint = 0
6475 }, { // op12_new
6476 .channelQuant = {},
6477 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 2.0f, 2.0f}),
6478 .dimensions = {1, 2, 2, 1},
6479 .isIgnored = false,
6480 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6481 .numberOfConsumers = 1,
6482 .scale = 0.0f,
6483 .type = TestOperandType::TENSOR_FLOAT16,
6484 .zeroPoint = 0
6485 }, { // dummy34
6486 .channelQuant = {},
6487 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
6488 .dimensions = {1},
6489 .isIgnored = false,
6490 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6491 .numberOfConsumers = 1,
6492 .scale = 0.0f,
6493 .type = TestOperandType::TENSOR_FLOAT16,
6494 .zeroPoint = 0
6495 }, { // param76
6496 .channelQuant = {},
6497 .data = TestBuffer::createFromVector<int32_t>({0}),
6498 .dimensions = {},
6499 .isIgnored = false,
6500 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6501 .numberOfConsumers = 1,
6502 .scale = 0.0f,
6503 .type = TestOperandType::INT32,
6504 .zeroPoint = 0
6505 }},
6506 .operations = {{
6507 .inputs = {4, 5, 6},
6508 .outputs = {0},
6509 .type = TestOperationType::ADD
6510 }, {
6511 .inputs = {0, 1, 2},
6512 .outputs = {3},
6513 .type = TestOperationType::RESIZE_BILINEAR
6514 }},
6515 .outputIndexes = {3}
6516 },
6517 .minSupportedVersion = TestHalVersion::V1_2,
6518 .referenced = {}
6519 };
6520 return model;
6521 }
6522
6523 const auto dummy_test_model_scale_float16_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_scale_float16_all_inputs_as_internal", get_test_model_scale_float16_all_inputs_as_internal());
6524
6525 } // namespace generated_tests::resize_bilinear_v1_2
6526
6527 namespace generated_tests::resize_bilinear_v1_2 {
6528
get_test_model_scale_quant8()6529 const TestModel& get_test_model_scale_quant8() {
6530 static TestModel model = {
6531 .expectFailure = false,
6532 .expectedMultinomialDistributionTolerance = 0,
6533 .isRelaxed = false,
6534 .main = { // scale
6535 .inputIndexes = {0},
6536 .operands = {{ // op12
6537 .channelQuant = {},
6538 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 200, 200}),
6539 .dimensions = {1, 2, 2, 1},
6540 .isIgnored = false,
6541 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6542 .numberOfConsumers = 1,
6543 .scale = 0.01f,
6544 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
6545 .zeroPoint = 0
6546 }, { // param10
6547 .channelQuant = {},
6548 .data = TestBuffer::createFromVector<float>({1.8f}),
6549 .dimensions = {},
6550 .isIgnored = false,
6551 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6552 .numberOfConsumers = 1,
6553 .scale = 0.0f,
6554 .type = TestOperandType::FLOAT32,
6555 .zeroPoint = 0
6556 }, { // param11
6557 .channelQuant = {},
6558 .data = TestBuffer::createFromVector<float>({1.8f}),
6559 .dimensions = {},
6560 .isIgnored = false,
6561 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6562 .numberOfConsumers = 1,
6563 .scale = 0.0f,
6564 .type = TestOperandType::FLOAT32,
6565 .zeroPoint = 0
6566 }, { // op42
6567 .channelQuant = {},
6568 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 100, 167, 167, 167, 200, 200, 200}),
6569 .dimensions = {1, 3, 3, 1},
6570 .isIgnored = false,
6571 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6572 .numberOfConsumers = 0,
6573 .scale = 0.01f,
6574 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
6575 .zeroPoint = 0
6576 }},
6577 .operations = {{
6578 .inputs = {0, 1, 2},
6579 .outputs = {3},
6580 .type = TestOperationType::RESIZE_BILINEAR
6581 }},
6582 .outputIndexes = {3}
6583 },
6584 .minSupportedVersion = TestHalVersion::V1_2,
6585 .referenced = {}
6586 };
6587 return model;
6588 }
6589
6590 const auto dummy_test_model_scale_quant8 = TestModelManager::get().add("resize_bilinear_v1_2_scale_quant8", get_test_model_scale_quant8());
6591
6592 } // namespace generated_tests::resize_bilinear_v1_2
6593
6594 namespace generated_tests::resize_bilinear_v1_2 {
6595
get_test_model_scale_quant8_all_inputs_as_internal()6596 const TestModel& get_test_model_scale_quant8_all_inputs_as_internal() {
6597 static TestModel model = {
6598 .expectFailure = false,
6599 .expectedMultinomialDistributionTolerance = 0,
6600 .isRelaxed = false,
6601 .main = { // scale
6602 .inputIndexes = {4},
6603 .operands = {{ // op12
6604 .channelQuant = {},
6605 .data = TestBuffer::createFromVector<uint8_t>({}),
6606 .dimensions = {1, 2, 2, 1},
6607 .isIgnored = false,
6608 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
6609 .numberOfConsumers = 1,
6610 .scale = 0.01f,
6611 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
6612 .zeroPoint = 0
6613 }, { // param10
6614 .channelQuant = {},
6615 .data = TestBuffer::createFromVector<float>({1.8f}),
6616 .dimensions = {},
6617 .isIgnored = false,
6618 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6619 .numberOfConsumers = 1,
6620 .scale = 0.0f,
6621 .type = TestOperandType::FLOAT32,
6622 .zeroPoint = 0
6623 }, { // param11
6624 .channelQuant = {},
6625 .data = TestBuffer::createFromVector<float>({1.8f}),
6626 .dimensions = {},
6627 .isIgnored = false,
6628 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6629 .numberOfConsumers = 1,
6630 .scale = 0.0f,
6631 .type = TestOperandType::FLOAT32,
6632 .zeroPoint = 0
6633 }, { // op42
6634 .channelQuant = {},
6635 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 100, 167, 167, 167, 200, 200, 200}),
6636 .dimensions = {1, 3, 3, 1},
6637 .isIgnored = false,
6638 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6639 .numberOfConsumers = 0,
6640 .scale = 0.01f,
6641 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
6642 .zeroPoint = 0
6643 }, { // op12_new
6644 .channelQuant = {},
6645 .data = TestBuffer::createFromVector<uint8_t>({100, 100, 200, 200}),
6646 .dimensions = {1, 2, 2, 1},
6647 .isIgnored = false,
6648 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6649 .numberOfConsumers = 1,
6650 .scale = 0.01f,
6651 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
6652 .zeroPoint = 0
6653 }, { // dummy35
6654 .channelQuant = {},
6655 .data = TestBuffer::createFromVector<uint8_t>({0}),
6656 .dimensions = {1},
6657 .isIgnored = false,
6658 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6659 .numberOfConsumers = 1,
6660 .scale = 0.01f,
6661 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
6662 .zeroPoint = 0
6663 }, { // param77
6664 .channelQuant = {},
6665 .data = TestBuffer::createFromVector<int32_t>({0}),
6666 .dimensions = {},
6667 .isIgnored = false,
6668 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6669 .numberOfConsumers = 1,
6670 .scale = 0.0f,
6671 .type = TestOperandType::INT32,
6672 .zeroPoint = 0
6673 }},
6674 .operations = {{
6675 .inputs = {4, 5, 6},
6676 .outputs = {0},
6677 .type = TestOperationType::ADD
6678 }, {
6679 .inputs = {0, 1, 2},
6680 .outputs = {3},
6681 .type = TestOperationType::RESIZE_BILINEAR
6682 }},
6683 .outputIndexes = {3}
6684 },
6685 .minSupportedVersion = TestHalVersion::V1_2,
6686 .referenced = {}
6687 };
6688 return model;
6689 }
6690
6691 const auto dummy_test_model_scale_quant8_all_inputs_as_internal = TestModelManager::get().add("resize_bilinear_v1_2_scale_quant8_all_inputs_as_internal", get_test_model_scale_quant8_all_inputs_as_internal());
6692
6693 } // namespace generated_tests::resize_bilinear_v1_2
6694
6695 namespace generated_tests::resize_bilinear_v1_2 {
6696
get_test_model_zero_sized_nhwc()6697 const TestModel& get_test_model_zero_sized_nhwc() {
6698 static TestModel model = {
6699 .expectFailure = false,
6700 .expectedMultinomialDistributionTolerance = 0,
6701 .isRelaxed = false,
6702 .main = { // zero_sized
6703 .inputIndexes = {13},
6704 .operands = {{ // scores
6705 .channelQuant = {},
6706 .data = TestBuffer::createFromVector<float>({0.9f, 0.1f}),
6707 .dimensions = {1, 2},
6708 .isIgnored = false,
6709 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6710 .numberOfConsumers = 1,
6711 .scale = 0.0f,
6712 .type = TestOperandType::TENSOR_FLOAT32,
6713 .zeroPoint = 0
6714 }, { // roi
6715 .channelQuant = {},
6716 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
6717 .dimensions = {1, 8},
6718 .isIgnored = false,
6719 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6720 .numberOfConsumers = 1,
6721 .scale = 0.0f,
6722 .type = TestOperandType::TENSOR_FLOAT32,
6723 .zeroPoint = 0
6724 }, { // param12
6725 .channelQuant = {},
6726 .data = TestBuffer::createFromVector<int32_t>({0}),
6727 .dimensions = {1},
6728 .isIgnored = false,
6729 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6730 .numberOfConsumers = 1,
6731 .scale = 0.0f,
6732 .type = TestOperandType::TENSOR_INT32,
6733 .zeroPoint = 0
6734 }, { // param13
6735 .channelQuant = {},
6736 .data = TestBuffer::createFromVector<float>({0.3f}),
6737 .dimensions = {},
6738 .isIgnored = false,
6739 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6740 .numberOfConsumers = 1,
6741 .scale = 0.0f,
6742 .type = TestOperandType::FLOAT32,
6743 .zeroPoint = 0
6744 }, { // param14
6745 .channelQuant = {},
6746 .data = TestBuffer::createFromVector<int32_t>({-1}),
6747 .dimensions = {},
6748 .isIgnored = false,
6749 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6750 .numberOfConsumers = 1,
6751 .scale = 0.0f,
6752 .type = TestOperandType::INT32,
6753 .zeroPoint = 0
6754 }, { // param15
6755 .channelQuant = {},
6756 .data = TestBuffer::createFromVector<int32_t>({0}),
6757 .dimensions = {},
6758 .isIgnored = false,
6759 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6760 .numberOfConsumers = 1,
6761 .scale = 0.0f,
6762 .type = TestOperandType::INT32,
6763 .zeroPoint = 0
6764 }, { // param16
6765 .channelQuant = {},
6766 .data = TestBuffer::createFromVector<float>({0.4f}),
6767 .dimensions = {},
6768 .isIgnored = false,
6769 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6770 .numberOfConsumers = 1,
6771 .scale = 0.0f,
6772 .type = TestOperandType::FLOAT32,
6773 .zeroPoint = 0
6774 }, { // param17
6775 .channelQuant = {},
6776 .data = TestBuffer::createFromVector<float>({1.0f}),
6777 .dimensions = {},
6778 .isIgnored = false,
6779 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6780 .numberOfConsumers = 1,
6781 .scale = 0.0f,
6782 .type = TestOperandType::FLOAT32,
6783 .zeroPoint = 0
6784 }, { // param18
6785 .channelQuant = {},
6786 .data = TestBuffer::createFromVector<float>({0.3f}),
6787 .dimensions = {},
6788 .isIgnored = false,
6789 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6790 .numberOfConsumers = 1,
6791 .scale = 0.0f,
6792 .type = TestOperandType::FLOAT32,
6793 .zeroPoint = 0
6794 }, { // scoresOut
6795 .channelQuant = {},
6796 .data = TestBuffer::createFromVector<float>({}),
6797 .dimensions = {0},
6798 .isIgnored = false,
6799 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6800 .numberOfConsumers = 0,
6801 .scale = 0.0f,
6802 .type = TestOperandType::TENSOR_FLOAT32,
6803 .zeroPoint = 0
6804 }, { // roiOut
6805 .channelQuant = {},
6806 .data = TestBuffer::createFromVector<float>({}),
6807 .dimensions = {0, 4},
6808 .isIgnored = false,
6809 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
6810 .numberOfConsumers = 1,
6811 .scale = 0.0f,
6812 .type = TestOperandType::TENSOR_FLOAT32,
6813 .zeroPoint = 0
6814 }, { // classesOut
6815 .channelQuant = {},
6816 .data = TestBuffer::createFromVector<int32_t>({}),
6817 .dimensions = {0},
6818 .isIgnored = false,
6819 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6820 .numberOfConsumers = 0,
6821 .scale = 0.0f,
6822 .type = TestOperandType::TENSOR_INT32,
6823 .zeroPoint = 0
6824 }, { // batchSplitOut
6825 .channelQuant = {},
6826 .data = TestBuffer::createFromVector<int32_t>({}),
6827 .dimensions = {0},
6828 .isIgnored = false,
6829 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
6830 .numberOfConsumers = 1,
6831 .scale = 0.0f,
6832 .type = TestOperandType::TENSOR_INT32,
6833 .zeroPoint = 0
6834 }, { // in
6835 .channelQuant = {},
6836 .data = TestBuffer::createFromVector<float>({1.0f}),
6837 .dimensions = {1, 1, 1, 1},
6838 .isIgnored = false,
6839 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
6840 .numberOfConsumers = 1,
6841 .scale = 0.0f,
6842 .type = TestOperandType::TENSOR_FLOAT32,
6843 .zeroPoint = 0
6844 }, { // param19
6845 .channelQuant = {},
6846 .data = TestBuffer::createFromVector<int32_t>({2}),
6847 .dimensions = {},
6848 .isIgnored = false,
6849 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6850 .numberOfConsumers = 1,
6851 .scale = 0.0f,
6852 .type = TestOperandType::INT32,
6853 .zeroPoint = 0
6854 }, { // param20
6855 .channelQuant = {},
6856 .data = TestBuffer::createFromVector<int32_t>({2}),
6857 .dimensions = {},
6858 .isIgnored = false,
6859 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6860 .numberOfConsumers = 1,
6861 .scale = 0.0f,
6862 .type = TestOperandType::INT32,
6863 .zeroPoint = 0
6864 }, { // param21
6865 .channelQuant = {},
6866 .data = TestBuffer::createFromVector<float>({2.0f}),
6867 .dimensions = {},
6868 .isIgnored = false,
6869 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6870 .numberOfConsumers = 1,
6871 .scale = 0.0f,
6872 .type = TestOperandType::FLOAT32,
6873 .zeroPoint = 0
6874 }, { // param22
6875 .channelQuant = {},
6876 .data = TestBuffer::createFromVector<float>({2.0f}),
6877 .dimensions = {},
6878 .isIgnored = false,
6879 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6880 .numberOfConsumers = 1,
6881 .scale = 0.0f,
6882 .type = TestOperandType::FLOAT32,
6883 .zeroPoint = 0
6884 }, { // param23
6885 .channelQuant = {},
6886 .data = TestBuffer::createFromVector<int32_t>({4}),
6887 .dimensions = {},
6888 .isIgnored = false,
6889 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6890 .numberOfConsumers = 1,
6891 .scale = 0.0f,
6892 .type = TestOperandType::INT32,
6893 .zeroPoint = 0
6894 }, { // param24
6895 .channelQuant = {},
6896 .data = TestBuffer::createFromVector<int32_t>({4}),
6897 .dimensions = {},
6898 .isIgnored = false,
6899 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6900 .numberOfConsumers = 1,
6901 .scale = 0.0f,
6902 .type = TestOperandType::INT32,
6903 .zeroPoint = 0
6904 }, { // layout
6905 .channelQuant = {},
6906 .data = TestBuffer::createFromVector<bool8>({false}),
6907 .dimensions = {},
6908 .isIgnored = false,
6909 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6910 .numberOfConsumers = 2,
6911 .scale = 0.0f,
6912 .type = TestOperandType::BOOL,
6913 .zeroPoint = 0
6914 }, { // featureMap
6915 .channelQuant = {},
6916 .data = TestBuffer::createFromVector<float>({}),
6917 .dimensions = {0, 2, 2, 1},
6918 .isIgnored = false,
6919 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
6920 .numberOfConsumers = 1,
6921 .scale = 0.0f,
6922 .type = TestOperandType::TENSOR_FLOAT32,
6923 .zeroPoint = 0
6924 }, { // param25
6925 .channelQuant = {},
6926 .data = TestBuffer::createFromVector<int32_t>({3}),
6927 .dimensions = {},
6928 .isIgnored = false,
6929 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6930 .numberOfConsumers = 1,
6931 .scale = 0.0f,
6932 .type = TestOperandType::INT32,
6933 .zeroPoint = 0
6934 }, { // param26
6935 .channelQuant = {},
6936 .data = TestBuffer::createFromVector<int32_t>({3}),
6937 .dimensions = {},
6938 .isIgnored = false,
6939 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6940 .numberOfConsumers = 1,
6941 .scale = 0.0f,
6942 .type = TestOperandType::INT32,
6943 .zeroPoint = 0
6944 }, { // out
6945 .channelQuant = {},
6946 .data = TestBuffer::createFromVector<float>({}),
6947 .dimensions = {0, 3, 3, 1},
6948 .isIgnored = false,
6949 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
6950 .numberOfConsumers = 0,
6951 .scale = 0.0f,
6952 .type = TestOperandType::TENSOR_FLOAT32,
6953 .zeroPoint = 0
6954 }},
6955 .operations = {{
6956 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
6957 .outputs = {9, 10, 11, 12},
6958 .type = TestOperationType::BOX_WITH_NMS_LIMIT
6959 }, {
6960 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
6961 .outputs = {21},
6962 .type = TestOperationType::ROI_ALIGN
6963 }, {
6964 .inputs = {21, 22, 23, 20},
6965 .outputs = {24},
6966 .type = TestOperationType::RESIZE_BILINEAR
6967 }},
6968 .outputIndexes = {9, 11, 24}
6969 },
6970 .minSupportedVersion = TestHalVersion::V1_2,
6971 .referenced = {}
6972 };
6973 return model;
6974 }
6975
6976 const auto dummy_test_model_zero_sized_nhwc = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nhwc", get_test_model_zero_sized_nhwc());
6977
6978 } // namespace generated_tests::resize_bilinear_v1_2
6979
6980 namespace generated_tests::resize_bilinear_v1_2 {
6981
get_test_model_zero_sized_nhwc_relaxed()6982 const TestModel& get_test_model_zero_sized_nhwc_relaxed() {
6983 static TestModel model = {
6984 .expectFailure = false,
6985 .expectedMultinomialDistributionTolerance = 0,
6986 .isRelaxed = true,
6987 .main = { // zero_sized
6988 .inputIndexes = {13},
6989 .operands = {{ // scores
6990 .channelQuant = {},
6991 .data = TestBuffer::createFromVector<float>({0.9f, 0.1f}),
6992 .dimensions = {1, 2},
6993 .isIgnored = false,
6994 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
6995 .numberOfConsumers = 1,
6996 .scale = 0.0f,
6997 .type = TestOperandType::TENSOR_FLOAT32,
6998 .zeroPoint = 0
6999 }, { // roi
7000 .channelQuant = {},
7001 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
7002 .dimensions = {1, 8},
7003 .isIgnored = false,
7004 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7005 .numberOfConsumers = 1,
7006 .scale = 0.0f,
7007 .type = TestOperandType::TENSOR_FLOAT32,
7008 .zeroPoint = 0
7009 }, { // param12
7010 .channelQuant = {},
7011 .data = TestBuffer::createFromVector<int32_t>({0}),
7012 .dimensions = {1},
7013 .isIgnored = false,
7014 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7015 .numberOfConsumers = 1,
7016 .scale = 0.0f,
7017 .type = TestOperandType::TENSOR_INT32,
7018 .zeroPoint = 0
7019 }, { // param13
7020 .channelQuant = {},
7021 .data = TestBuffer::createFromVector<float>({0.3f}),
7022 .dimensions = {},
7023 .isIgnored = false,
7024 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7025 .numberOfConsumers = 1,
7026 .scale = 0.0f,
7027 .type = TestOperandType::FLOAT32,
7028 .zeroPoint = 0
7029 }, { // param14
7030 .channelQuant = {},
7031 .data = TestBuffer::createFromVector<int32_t>({-1}),
7032 .dimensions = {},
7033 .isIgnored = false,
7034 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7035 .numberOfConsumers = 1,
7036 .scale = 0.0f,
7037 .type = TestOperandType::INT32,
7038 .zeroPoint = 0
7039 }, { // param15
7040 .channelQuant = {},
7041 .data = TestBuffer::createFromVector<int32_t>({0}),
7042 .dimensions = {},
7043 .isIgnored = false,
7044 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7045 .numberOfConsumers = 1,
7046 .scale = 0.0f,
7047 .type = TestOperandType::INT32,
7048 .zeroPoint = 0
7049 }, { // param16
7050 .channelQuant = {},
7051 .data = TestBuffer::createFromVector<float>({0.4f}),
7052 .dimensions = {},
7053 .isIgnored = false,
7054 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7055 .numberOfConsumers = 1,
7056 .scale = 0.0f,
7057 .type = TestOperandType::FLOAT32,
7058 .zeroPoint = 0
7059 }, { // param17
7060 .channelQuant = {},
7061 .data = TestBuffer::createFromVector<float>({1.0f}),
7062 .dimensions = {},
7063 .isIgnored = false,
7064 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7065 .numberOfConsumers = 1,
7066 .scale = 0.0f,
7067 .type = TestOperandType::FLOAT32,
7068 .zeroPoint = 0
7069 }, { // param18
7070 .channelQuant = {},
7071 .data = TestBuffer::createFromVector<float>({0.3f}),
7072 .dimensions = {},
7073 .isIgnored = false,
7074 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7075 .numberOfConsumers = 1,
7076 .scale = 0.0f,
7077 .type = TestOperandType::FLOAT32,
7078 .zeroPoint = 0
7079 }, { // scoresOut
7080 .channelQuant = {},
7081 .data = TestBuffer::createFromVector<float>({}),
7082 .dimensions = {0},
7083 .isIgnored = false,
7084 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7085 .numberOfConsumers = 0,
7086 .scale = 0.0f,
7087 .type = TestOperandType::TENSOR_FLOAT32,
7088 .zeroPoint = 0
7089 }, { // roiOut
7090 .channelQuant = {},
7091 .data = TestBuffer::createFromVector<float>({}),
7092 .dimensions = {0, 4},
7093 .isIgnored = false,
7094 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7095 .numberOfConsumers = 1,
7096 .scale = 0.0f,
7097 .type = TestOperandType::TENSOR_FLOAT32,
7098 .zeroPoint = 0
7099 }, { // classesOut
7100 .channelQuant = {},
7101 .data = TestBuffer::createFromVector<int32_t>({}),
7102 .dimensions = {0},
7103 .isIgnored = false,
7104 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7105 .numberOfConsumers = 0,
7106 .scale = 0.0f,
7107 .type = TestOperandType::TENSOR_INT32,
7108 .zeroPoint = 0
7109 }, { // batchSplitOut
7110 .channelQuant = {},
7111 .data = TestBuffer::createFromVector<int32_t>({}),
7112 .dimensions = {0},
7113 .isIgnored = false,
7114 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7115 .numberOfConsumers = 1,
7116 .scale = 0.0f,
7117 .type = TestOperandType::TENSOR_INT32,
7118 .zeroPoint = 0
7119 }, { // in
7120 .channelQuant = {},
7121 .data = TestBuffer::createFromVector<float>({1.0f}),
7122 .dimensions = {1, 1, 1, 1},
7123 .isIgnored = false,
7124 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7125 .numberOfConsumers = 1,
7126 .scale = 0.0f,
7127 .type = TestOperandType::TENSOR_FLOAT32,
7128 .zeroPoint = 0
7129 }, { // param19
7130 .channelQuant = {},
7131 .data = TestBuffer::createFromVector<int32_t>({2}),
7132 .dimensions = {},
7133 .isIgnored = false,
7134 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7135 .numberOfConsumers = 1,
7136 .scale = 0.0f,
7137 .type = TestOperandType::INT32,
7138 .zeroPoint = 0
7139 }, { // param20
7140 .channelQuant = {},
7141 .data = TestBuffer::createFromVector<int32_t>({2}),
7142 .dimensions = {},
7143 .isIgnored = false,
7144 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7145 .numberOfConsumers = 1,
7146 .scale = 0.0f,
7147 .type = TestOperandType::INT32,
7148 .zeroPoint = 0
7149 }, { // param21
7150 .channelQuant = {},
7151 .data = TestBuffer::createFromVector<float>({2.0f}),
7152 .dimensions = {},
7153 .isIgnored = false,
7154 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7155 .numberOfConsumers = 1,
7156 .scale = 0.0f,
7157 .type = TestOperandType::FLOAT32,
7158 .zeroPoint = 0
7159 }, { // param22
7160 .channelQuant = {},
7161 .data = TestBuffer::createFromVector<float>({2.0f}),
7162 .dimensions = {},
7163 .isIgnored = false,
7164 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7165 .numberOfConsumers = 1,
7166 .scale = 0.0f,
7167 .type = TestOperandType::FLOAT32,
7168 .zeroPoint = 0
7169 }, { // param23
7170 .channelQuant = {},
7171 .data = TestBuffer::createFromVector<int32_t>({4}),
7172 .dimensions = {},
7173 .isIgnored = false,
7174 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7175 .numberOfConsumers = 1,
7176 .scale = 0.0f,
7177 .type = TestOperandType::INT32,
7178 .zeroPoint = 0
7179 }, { // param24
7180 .channelQuant = {},
7181 .data = TestBuffer::createFromVector<int32_t>({4}),
7182 .dimensions = {},
7183 .isIgnored = false,
7184 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7185 .numberOfConsumers = 1,
7186 .scale = 0.0f,
7187 .type = TestOperandType::INT32,
7188 .zeroPoint = 0
7189 }, { // layout
7190 .channelQuant = {},
7191 .data = TestBuffer::createFromVector<bool8>({false}),
7192 .dimensions = {},
7193 .isIgnored = false,
7194 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7195 .numberOfConsumers = 2,
7196 .scale = 0.0f,
7197 .type = TestOperandType::BOOL,
7198 .zeroPoint = 0
7199 }, { // featureMap
7200 .channelQuant = {},
7201 .data = TestBuffer::createFromVector<float>({}),
7202 .dimensions = {0, 2, 2, 1},
7203 .isIgnored = false,
7204 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7205 .numberOfConsumers = 1,
7206 .scale = 0.0f,
7207 .type = TestOperandType::TENSOR_FLOAT32,
7208 .zeroPoint = 0
7209 }, { // param25
7210 .channelQuant = {},
7211 .data = TestBuffer::createFromVector<int32_t>({3}),
7212 .dimensions = {},
7213 .isIgnored = false,
7214 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7215 .numberOfConsumers = 1,
7216 .scale = 0.0f,
7217 .type = TestOperandType::INT32,
7218 .zeroPoint = 0
7219 }, { // param26
7220 .channelQuant = {},
7221 .data = TestBuffer::createFromVector<int32_t>({3}),
7222 .dimensions = {},
7223 .isIgnored = false,
7224 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7225 .numberOfConsumers = 1,
7226 .scale = 0.0f,
7227 .type = TestOperandType::INT32,
7228 .zeroPoint = 0
7229 }, { // out
7230 .channelQuant = {},
7231 .data = TestBuffer::createFromVector<float>({}),
7232 .dimensions = {0, 3, 3, 1},
7233 .isIgnored = false,
7234 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7235 .numberOfConsumers = 0,
7236 .scale = 0.0f,
7237 .type = TestOperandType::TENSOR_FLOAT32,
7238 .zeroPoint = 0
7239 }},
7240 .operations = {{
7241 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
7242 .outputs = {9, 10, 11, 12},
7243 .type = TestOperationType::BOX_WITH_NMS_LIMIT
7244 }, {
7245 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
7246 .outputs = {21},
7247 .type = TestOperationType::ROI_ALIGN
7248 }, {
7249 .inputs = {21, 22, 23, 20},
7250 .outputs = {24},
7251 .type = TestOperationType::RESIZE_BILINEAR
7252 }},
7253 .outputIndexes = {9, 11, 24}
7254 },
7255 .minSupportedVersion = TestHalVersion::UNKNOWN,
7256 .referenced = {}
7257 };
7258 return model;
7259 }
7260
7261 const auto dummy_test_model_zero_sized_nhwc_relaxed = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nhwc_relaxed", get_test_model_zero_sized_nhwc_relaxed());
7262
7263 } // namespace generated_tests::resize_bilinear_v1_2
7264
7265 namespace generated_tests::resize_bilinear_v1_2 {
7266
get_test_model_zero_sized_nhwc_quant8()7267 const TestModel& get_test_model_zero_sized_nhwc_quant8() {
7268 static TestModel model = {
7269 .expectFailure = false,
7270 .expectedMultinomialDistributionTolerance = 0,
7271 .isRelaxed = false,
7272 .main = { // zero_sized
7273 .inputIndexes = {13},
7274 .operands = {{ // scores
7275 .channelQuant = {},
7276 .data = TestBuffer::createFromVector<uint8_t>({137, 129}),
7277 .dimensions = {1, 2},
7278 .isIgnored = false,
7279 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7280 .numberOfConsumers = 1,
7281 .scale = 0.1f,
7282 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
7283 .zeroPoint = 128
7284 }, { // roi
7285 .channelQuant = {},
7286 .data = TestBuffer::createFromVector<uint16_t>({8, 8, 80, 80, 0, 0, 80, 80}),
7287 .dimensions = {1, 8},
7288 .isIgnored = false,
7289 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7290 .numberOfConsumers = 1,
7291 .scale = 0.125f,
7292 .type = TestOperandType::TENSOR_QUANT16_ASYMM,
7293 .zeroPoint = 0
7294 }, { // param12
7295 .channelQuant = {},
7296 .data = TestBuffer::createFromVector<int32_t>({0}),
7297 .dimensions = {1},
7298 .isIgnored = false,
7299 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7300 .numberOfConsumers = 1,
7301 .scale = 0.0f,
7302 .type = TestOperandType::TENSOR_INT32,
7303 .zeroPoint = 0
7304 }, { // param13
7305 .channelQuant = {},
7306 .data = TestBuffer::createFromVector<float>({0.3f}),
7307 .dimensions = {},
7308 .isIgnored = false,
7309 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7310 .numberOfConsumers = 1,
7311 .scale = 0.0f,
7312 .type = TestOperandType::FLOAT32,
7313 .zeroPoint = 0
7314 }, { // param14
7315 .channelQuant = {},
7316 .data = TestBuffer::createFromVector<int32_t>({-1}),
7317 .dimensions = {},
7318 .isIgnored = false,
7319 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7320 .numberOfConsumers = 1,
7321 .scale = 0.0f,
7322 .type = TestOperandType::INT32,
7323 .zeroPoint = 0
7324 }, { // param15
7325 .channelQuant = {},
7326 .data = TestBuffer::createFromVector<int32_t>({0}),
7327 .dimensions = {},
7328 .isIgnored = false,
7329 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7330 .numberOfConsumers = 1,
7331 .scale = 0.0f,
7332 .type = TestOperandType::INT32,
7333 .zeroPoint = 0
7334 }, { // param16
7335 .channelQuant = {},
7336 .data = TestBuffer::createFromVector<float>({0.4f}),
7337 .dimensions = {},
7338 .isIgnored = false,
7339 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7340 .numberOfConsumers = 1,
7341 .scale = 0.0f,
7342 .type = TestOperandType::FLOAT32,
7343 .zeroPoint = 0
7344 }, { // param17
7345 .channelQuant = {},
7346 .data = TestBuffer::createFromVector<float>({1.0f}),
7347 .dimensions = {},
7348 .isIgnored = false,
7349 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7350 .numberOfConsumers = 1,
7351 .scale = 0.0f,
7352 .type = TestOperandType::FLOAT32,
7353 .zeroPoint = 0
7354 }, { // param18
7355 .channelQuant = {},
7356 .data = TestBuffer::createFromVector<float>({0.3f}),
7357 .dimensions = {},
7358 .isIgnored = false,
7359 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7360 .numberOfConsumers = 1,
7361 .scale = 0.0f,
7362 .type = TestOperandType::FLOAT32,
7363 .zeroPoint = 0
7364 }, { // scoresOut
7365 .channelQuant = {},
7366 .data = TestBuffer::createFromVector<uint8_t>({}),
7367 .dimensions = {0},
7368 .isIgnored = false,
7369 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7370 .numberOfConsumers = 0,
7371 .scale = 0.1f,
7372 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
7373 .zeroPoint = 128
7374 }, { // roiOut
7375 .channelQuant = {},
7376 .data = TestBuffer::createFromVector<uint16_t>({}),
7377 .dimensions = {0, 4},
7378 .isIgnored = false,
7379 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7380 .numberOfConsumers = 1,
7381 .scale = 0.125f,
7382 .type = TestOperandType::TENSOR_QUANT16_ASYMM,
7383 .zeroPoint = 0
7384 }, { // classesOut
7385 .channelQuant = {},
7386 .data = TestBuffer::createFromVector<int32_t>({}),
7387 .dimensions = {0},
7388 .isIgnored = false,
7389 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7390 .numberOfConsumers = 0,
7391 .scale = 0.0f,
7392 .type = TestOperandType::TENSOR_INT32,
7393 .zeroPoint = 0
7394 }, { // batchSplitOut
7395 .channelQuant = {},
7396 .data = TestBuffer::createFromVector<int32_t>({}),
7397 .dimensions = {0},
7398 .isIgnored = false,
7399 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7400 .numberOfConsumers = 1,
7401 .scale = 0.0f,
7402 .type = TestOperandType::TENSOR_INT32,
7403 .zeroPoint = 0
7404 }, { // in
7405 .channelQuant = {},
7406 .data = TestBuffer::createFromVector<uint8_t>({138}),
7407 .dimensions = {1, 1, 1, 1},
7408 .isIgnored = false,
7409 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7410 .numberOfConsumers = 1,
7411 .scale = 0.1f,
7412 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
7413 .zeroPoint = 128
7414 }, { // param19
7415 .channelQuant = {},
7416 .data = TestBuffer::createFromVector<int32_t>({2}),
7417 .dimensions = {},
7418 .isIgnored = false,
7419 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7420 .numberOfConsumers = 1,
7421 .scale = 0.0f,
7422 .type = TestOperandType::INT32,
7423 .zeroPoint = 0
7424 }, { // param20
7425 .channelQuant = {},
7426 .data = TestBuffer::createFromVector<int32_t>({2}),
7427 .dimensions = {},
7428 .isIgnored = false,
7429 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7430 .numberOfConsumers = 1,
7431 .scale = 0.0f,
7432 .type = TestOperandType::INT32,
7433 .zeroPoint = 0
7434 }, { // param21
7435 .channelQuant = {},
7436 .data = TestBuffer::createFromVector<float>({2.0f}),
7437 .dimensions = {},
7438 .isIgnored = false,
7439 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7440 .numberOfConsumers = 1,
7441 .scale = 0.0f,
7442 .type = TestOperandType::FLOAT32,
7443 .zeroPoint = 0
7444 }, { // param22
7445 .channelQuant = {},
7446 .data = TestBuffer::createFromVector<float>({2.0f}),
7447 .dimensions = {},
7448 .isIgnored = false,
7449 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7450 .numberOfConsumers = 1,
7451 .scale = 0.0f,
7452 .type = TestOperandType::FLOAT32,
7453 .zeroPoint = 0
7454 }, { // param23
7455 .channelQuant = {},
7456 .data = TestBuffer::createFromVector<int32_t>({4}),
7457 .dimensions = {},
7458 .isIgnored = false,
7459 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7460 .numberOfConsumers = 1,
7461 .scale = 0.0f,
7462 .type = TestOperandType::INT32,
7463 .zeroPoint = 0
7464 }, { // param24
7465 .channelQuant = {},
7466 .data = TestBuffer::createFromVector<int32_t>({4}),
7467 .dimensions = {},
7468 .isIgnored = false,
7469 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7470 .numberOfConsumers = 1,
7471 .scale = 0.0f,
7472 .type = TestOperandType::INT32,
7473 .zeroPoint = 0
7474 }, { // layout
7475 .channelQuant = {},
7476 .data = TestBuffer::createFromVector<bool8>({false}),
7477 .dimensions = {},
7478 .isIgnored = false,
7479 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7480 .numberOfConsumers = 2,
7481 .scale = 0.0f,
7482 .type = TestOperandType::BOOL,
7483 .zeroPoint = 0
7484 }, { // featureMap
7485 .channelQuant = {},
7486 .data = TestBuffer::createFromVector<uint8_t>({}),
7487 .dimensions = {0, 2, 2, 1},
7488 .isIgnored = false,
7489 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7490 .numberOfConsumers = 1,
7491 .scale = 0.1f,
7492 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
7493 .zeroPoint = 128
7494 }, { // param25
7495 .channelQuant = {},
7496 .data = TestBuffer::createFromVector<int32_t>({3}),
7497 .dimensions = {},
7498 .isIgnored = false,
7499 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7500 .numberOfConsumers = 1,
7501 .scale = 0.0f,
7502 .type = TestOperandType::INT32,
7503 .zeroPoint = 0
7504 }, { // param26
7505 .channelQuant = {},
7506 .data = TestBuffer::createFromVector<int32_t>({3}),
7507 .dimensions = {},
7508 .isIgnored = false,
7509 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7510 .numberOfConsumers = 1,
7511 .scale = 0.0f,
7512 .type = TestOperandType::INT32,
7513 .zeroPoint = 0
7514 }, { // out
7515 .channelQuant = {},
7516 .data = TestBuffer::createFromVector<uint8_t>({}),
7517 .dimensions = {0, 3, 3, 1},
7518 .isIgnored = false,
7519 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7520 .numberOfConsumers = 0,
7521 .scale = 0.1f,
7522 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
7523 .zeroPoint = 128
7524 }},
7525 .operations = {{
7526 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
7527 .outputs = {9, 10, 11, 12},
7528 .type = TestOperationType::BOX_WITH_NMS_LIMIT
7529 }, {
7530 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
7531 .outputs = {21},
7532 .type = TestOperationType::ROI_ALIGN
7533 }, {
7534 .inputs = {21, 22, 23, 20},
7535 .outputs = {24},
7536 .type = TestOperationType::RESIZE_BILINEAR
7537 }},
7538 .outputIndexes = {9, 11, 24}
7539 },
7540 .minSupportedVersion = TestHalVersion::V1_2,
7541 .referenced = {}
7542 };
7543 return model;
7544 }
7545
7546 const auto dummy_test_model_zero_sized_nhwc_quant8 = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nhwc_quant8", get_test_model_zero_sized_nhwc_quant8());
7547
7548 } // namespace generated_tests::resize_bilinear_v1_2
7549
7550 namespace generated_tests::resize_bilinear_v1_2 {
7551
get_test_model_zero_sized_nhwc_float16()7552 const TestModel& get_test_model_zero_sized_nhwc_float16() {
7553 static TestModel model = {
7554 .expectFailure = false,
7555 .expectedMultinomialDistributionTolerance = 0,
7556 .isRelaxed = false,
7557 .main = { // zero_sized
7558 .inputIndexes = {13},
7559 .operands = {{ // scores
7560 .channelQuant = {},
7561 .data = TestBuffer::createFromVector<_Float16>({0.8999999761581421f, 0.10000000149011612f}),
7562 .dimensions = {1, 2},
7563 .isIgnored = false,
7564 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7565 .numberOfConsumers = 1,
7566 .scale = 0.0f,
7567 .type = TestOperandType::TENSOR_FLOAT16,
7568 .zeroPoint = 0
7569 }, { // roi
7570 .channelQuant = {},
7571 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
7572 .dimensions = {1, 8},
7573 .isIgnored = false,
7574 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7575 .numberOfConsumers = 1,
7576 .scale = 0.0f,
7577 .type = TestOperandType::TENSOR_FLOAT16,
7578 .zeroPoint = 0
7579 }, { // param12
7580 .channelQuant = {},
7581 .data = TestBuffer::createFromVector<int32_t>({0}),
7582 .dimensions = {1},
7583 .isIgnored = false,
7584 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7585 .numberOfConsumers = 1,
7586 .scale = 0.0f,
7587 .type = TestOperandType::TENSOR_INT32,
7588 .zeroPoint = 0
7589 }, { // param13
7590 .channelQuant = {},
7591 .data = TestBuffer::createFromVector<_Float16>({0.30000001192092896f}),
7592 .dimensions = {},
7593 .isIgnored = false,
7594 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7595 .numberOfConsumers = 1,
7596 .scale = 0.0f,
7597 .type = TestOperandType::FLOAT16,
7598 .zeroPoint = 0
7599 }, { // param14
7600 .channelQuant = {},
7601 .data = TestBuffer::createFromVector<int32_t>({-1}),
7602 .dimensions = {},
7603 .isIgnored = false,
7604 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7605 .numberOfConsumers = 1,
7606 .scale = 0.0f,
7607 .type = TestOperandType::INT32,
7608 .zeroPoint = 0
7609 }, { // param15
7610 .channelQuant = {},
7611 .data = TestBuffer::createFromVector<int32_t>({0}),
7612 .dimensions = {},
7613 .isIgnored = false,
7614 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7615 .numberOfConsumers = 1,
7616 .scale = 0.0f,
7617 .type = TestOperandType::INT32,
7618 .zeroPoint = 0
7619 }, { // param16
7620 .channelQuant = {},
7621 .data = TestBuffer::createFromVector<_Float16>({0.4000000059604645f}),
7622 .dimensions = {},
7623 .isIgnored = false,
7624 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7625 .numberOfConsumers = 1,
7626 .scale = 0.0f,
7627 .type = TestOperandType::FLOAT16,
7628 .zeroPoint = 0
7629 }, { // param17
7630 .channelQuant = {},
7631 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
7632 .dimensions = {},
7633 .isIgnored = false,
7634 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7635 .numberOfConsumers = 1,
7636 .scale = 0.0f,
7637 .type = TestOperandType::FLOAT16,
7638 .zeroPoint = 0
7639 }, { // param18
7640 .channelQuant = {},
7641 .data = TestBuffer::createFromVector<_Float16>({0.30000001192092896f}),
7642 .dimensions = {},
7643 .isIgnored = false,
7644 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7645 .numberOfConsumers = 1,
7646 .scale = 0.0f,
7647 .type = TestOperandType::FLOAT16,
7648 .zeroPoint = 0
7649 }, { // scoresOut
7650 .channelQuant = {},
7651 .data = TestBuffer::createFromVector<_Float16>({}),
7652 .dimensions = {0},
7653 .isIgnored = false,
7654 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7655 .numberOfConsumers = 0,
7656 .scale = 0.0f,
7657 .type = TestOperandType::TENSOR_FLOAT16,
7658 .zeroPoint = 0
7659 }, { // roiOut
7660 .channelQuant = {},
7661 .data = TestBuffer::createFromVector<_Float16>({}),
7662 .dimensions = {0, 4},
7663 .isIgnored = false,
7664 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7665 .numberOfConsumers = 1,
7666 .scale = 0.0f,
7667 .type = TestOperandType::TENSOR_FLOAT16,
7668 .zeroPoint = 0
7669 }, { // classesOut
7670 .channelQuant = {},
7671 .data = TestBuffer::createFromVector<int32_t>({}),
7672 .dimensions = {0},
7673 .isIgnored = false,
7674 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7675 .numberOfConsumers = 0,
7676 .scale = 0.0f,
7677 .type = TestOperandType::TENSOR_INT32,
7678 .zeroPoint = 0
7679 }, { // batchSplitOut
7680 .channelQuant = {},
7681 .data = TestBuffer::createFromVector<int32_t>({}),
7682 .dimensions = {0},
7683 .isIgnored = false,
7684 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7685 .numberOfConsumers = 1,
7686 .scale = 0.0f,
7687 .type = TestOperandType::TENSOR_INT32,
7688 .zeroPoint = 0
7689 }, { // in
7690 .channelQuant = {},
7691 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
7692 .dimensions = {1, 1, 1, 1},
7693 .isIgnored = false,
7694 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7695 .numberOfConsumers = 1,
7696 .scale = 0.0f,
7697 .type = TestOperandType::TENSOR_FLOAT16,
7698 .zeroPoint = 0
7699 }, { // param19
7700 .channelQuant = {},
7701 .data = TestBuffer::createFromVector<int32_t>({2}),
7702 .dimensions = {},
7703 .isIgnored = false,
7704 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7705 .numberOfConsumers = 1,
7706 .scale = 0.0f,
7707 .type = TestOperandType::INT32,
7708 .zeroPoint = 0
7709 }, { // param20
7710 .channelQuant = {},
7711 .data = TestBuffer::createFromVector<int32_t>({2}),
7712 .dimensions = {},
7713 .isIgnored = false,
7714 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7715 .numberOfConsumers = 1,
7716 .scale = 0.0f,
7717 .type = TestOperandType::INT32,
7718 .zeroPoint = 0
7719 }, { // param21
7720 .channelQuant = {},
7721 .data = TestBuffer::createFromVector<_Float16>({2.0f}),
7722 .dimensions = {},
7723 .isIgnored = false,
7724 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7725 .numberOfConsumers = 1,
7726 .scale = 0.0f,
7727 .type = TestOperandType::FLOAT16,
7728 .zeroPoint = 0
7729 }, { // param22
7730 .channelQuant = {},
7731 .data = TestBuffer::createFromVector<_Float16>({2.0f}),
7732 .dimensions = {},
7733 .isIgnored = false,
7734 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7735 .numberOfConsumers = 1,
7736 .scale = 0.0f,
7737 .type = TestOperandType::FLOAT16,
7738 .zeroPoint = 0
7739 }, { // param23
7740 .channelQuant = {},
7741 .data = TestBuffer::createFromVector<int32_t>({4}),
7742 .dimensions = {},
7743 .isIgnored = false,
7744 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7745 .numberOfConsumers = 1,
7746 .scale = 0.0f,
7747 .type = TestOperandType::INT32,
7748 .zeroPoint = 0
7749 }, { // param24
7750 .channelQuant = {},
7751 .data = TestBuffer::createFromVector<int32_t>({4}),
7752 .dimensions = {},
7753 .isIgnored = false,
7754 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7755 .numberOfConsumers = 1,
7756 .scale = 0.0f,
7757 .type = TestOperandType::INT32,
7758 .zeroPoint = 0
7759 }, { // layout
7760 .channelQuant = {},
7761 .data = TestBuffer::createFromVector<bool8>({false}),
7762 .dimensions = {},
7763 .isIgnored = false,
7764 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7765 .numberOfConsumers = 2,
7766 .scale = 0.0f,
7767 .type = TestOperandType::BOOL,
7768 .zeroPoint = 0
7769 }, { // featureMap
7770 .channelQuant = {},
7771 .data = TestBuffer::createFromVector<_Float16>({}),
7772 .dimensions = {0, 2, 2, 1},
7773 .isIgnored = false,
7774 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7775 .numberOfConsumers = 1,
7776 .scale = 0.0f,
7777 .type = TestOperandType::TENSOR_FLOAT16,
7778 .zeroPoint = 0
7779 }, { // param25
7780 .channelQuant = {},
7781 .data = TestBuffer::createFromVector<int32_t>({3}),
7782 .dimensions = {},
7783 .isIgnored = false,
7784 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7785 .numberOfConsumers = 1,
7786 .scale = 0.0f,
7787 .type = TestOperandType::INT32,
7788 .zeroPoint = 0
7789 }, { // param26
7790 .channelQuant = {},
7791 .data = TestBuffer::createFromVector<int32_t>({3}),
7792 .dimensions = {},
7793 .isIgnored = false,
7794 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7795 .numberOfConsumers = 1,
7796 .scale = 0.0f,
7797 .type = TestOperandType::INT32,
7798 .zeroPoint = 0
7799 }, { // out
7800 .channelQuant = {},
7801 .data = TestBuffer::createFromVector<_Float16>({}),
7802 .dimensions = {0, 3, 3, 1},
7803 .isIgnored = false,
7804 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7805 .numberOfConsumers = 0,
7806 .scale = 0.0f,
7807 .type = TestOperandType::TENSOR_FLOAT16,
7808 .zeroPoint = 0
7809 }},
7810 .operations = {{
7811 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
7812 .outputs = {9, 10, 11, 12},
7813 .type = TestOperationType::BOX_WITH_NMS_LIMIT
7814 }, {
7815 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
7816 .outputs = {21},
7817 .type = TestOperationType::ROI_ALIGN
7818 }, {
7819 .inputs = {21, 22, 23, 20},
7820 .outputs = {24},
7821 .type = TestOperationType::RESIZE_BILINEAR
7822 }},
7823 .outputIndexes = {9, 11, 24}
7824 },
7825 .minSupportedVersion = TestHalVersion::V1_2,
7826 .referenced = {}
7827 };
7828 return model;
7829 }
7830
7831 const auto dummy_test_model_zero_sized_nhwc_float16 = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nhwc_float16", get_test_model_zero_sized_nhwc_float16());
7832
7833 } // namespace generated_tests::resize_bilinear_v1_2
7834
7835 namespace generated_tests::resize_bilinear_v1_2 {
7836
get_test_model_zero_sized_nchw()7837 const TestModel& get_test_model_zero_sized_nchw() {
7838 static TestModel model = {
7839 .expectFailure = false,
7840 .expectedMultinomialDistributionTolerance = 0,
7841 .isRelaxed = false,
7842 .main = { // zero_sized
7843 .inputIndexes = {13},
7844 .operands = {{ // scores
7845 .channelQuant = {},
7846 .data = TestBuffer::createFromVector<float>({0.9f, 0.1f}),
7847 .dimensions = {1, 2},
7848 .isIgnored = false,
7849 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7850 .numberOfConsumers = 1,
7851 .scale = 0.0f,
7852 .type = TestOperandType::TENSOR_FLOAT32,
7853 .zeroPoint = 0
7854 }, { // roi
7855 .channelQuant = {},
7856 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
7857 .dimensions = {1, 8},
7858 .isIgnored = false,
7859 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7860 .numberOfConsumers = 1,
7861 .scale = 0.0f,
7862 .type = TestOperandType::TENSOR_FLOAT32,
7863 .zeroPoint = 0
7864 }, { // param12
7865 .channelQuant = {},
7866 .data = TestBuffer::createFromVector<int32_t>({0}),
7867 .dimensions = {1},
7868 .isIgnored = false,
7869 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7870 .numberOfConsumers = 1,
7871 .scale = 0.0f,
7872 .type = TestOperandType::TENSOR_INT32,
7873 .zeroPoint = 0
7874 }, { // param13
7875 .channelQuant = {},
7876 .data = TestBuffer::createFromVector<float>({0.3f}),
7877 .dimensions = {},
7878 .isIgnored = false,
7879 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7880 .numberOfConsumers = 1,
7881 .scale = 0.0f,
7882 .type = TestOperandType::FLOAT32,
7883 .zeroPoint = 0
7884 }, { // param14
7885 .channelQuant = {},
7886 .data = TestBuffer::createFromVector<int32_t>({-1}),
7887 .dimensions = {},
7888 .isIgnored = false,
7889 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7890 .numberOfConsumers = 1,
7891 .scale = 0.0f,
7892 .type = TestOperandType::INT32,
7893 .zeroPoint = 0
7894 }, { // param15
7895 .channelQuant = {},
7896 .data = TestBuffer::createFromVector<int32_t>({0}),
7897 .dimensions = {},
7898 .isIgnored = false,
7899 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7900 .numberOfConsumers = 1,
7901 .scale = 0.0f,
7902 .type = TestOperandType::INT32,
7903 .zeroPoint = 0
7904 }, { // param16
7905 .channelQuant = {},
7906 .data = TestBuffer::createFromVector<float>({0.4f}),
7907 .dimensions = {},
7908 .isIgnored = false,
7909 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7910 .numberOfConsumers = 1,
7911 .scale = 0.0f,
7912 .type = TestOperandType::FLOAT32,
7913 .zeroPoint = 0
7914 }, { // param17
7915 .channelQuant = {},
7916 .data = TestBuffer::createFromVector<float>({1.0f}),
7917 .dimensions = {},
7918 .isIgnored = false,
7919 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7920 .numberOfConsumers = 1,
7921 .scale = 0.0f,
7922 .type = TestOperandType::FLOAT32,
7923 .zeroPoint = 0
7924 }, { // param18
7925 .channelQuant = {},
7926 .data = TestBuffer::createFromVector<float>({0.3f}),
7927 .dimensions = {},
7928 .isIgnored = false,
7929 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7930 .numberOfConsumers = 1,
7931 .scale = 0.0f,
7932 .type = TestOperandType::FLOAT32,
7933 .zeroPoint = 0
7934 }, { // scoresOut
7935 .channelQuant = {},
7936 .data = TestBuffer::createFromVector<float>({}),
7937 .dimensions = {0},
7938 .isIgnored = false,
7939 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7940 .numberOfConsumers = 0,
7941 .scale = 0.0f,
7942 .type = TestOperandType::TENSOR_FLOAT32,
7943 .zeroPoint = 0
7944 }, { // roiOut
7945 .channelQuant = {},
7946 .data = TestBuffer::createFromVector<float>({}),
7947 .dimensions = {0, 4},
7948 .isIgnored = false,
7949 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7950 .numberOfConsumers = 1,
7951 .scale = 0.0f,
7952 .type = TestOperandType::TENSOR_FLOAT32,
7953 .zeroPoint = 0
7954 }, { // classesOut
7955 .channelQuant = {},
7956 .data = TestBuffer::createFromVector<int32_t>({}),
7957 .dimensions = {0},
7958 .isIgnored = false,
7959 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
7960 .numberOfConsumers = 0,
7961 .scale = 0.0f,
7962 .type = TestOperandType::TENSOR_INT32,
7963 .zeroPoint = 0
7964 }, { // batchSplitOut
7965 .channelQuant = {},
7966 .data = TestBuffer::createFromVector<int32_t>({}),
7967 .dimensions = {0},
7968 .isIgnored = false,
7969 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
7970 .numberOfConsumers = 1,
7971 .scale = 0.0f,
7972 .type = TestOperandType::TENSOR_INT32,
7973 .zeroPoint = 0
7974 }, { // in
7975 .channelQuant = {},
7976 .data = TestBuffer::createFromVector<float>({1.0f}),
7977 .dimensions = {1, 1, 1, 1},
7978 .isIgnored = false,
7979 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
7980 .numberOfConsumers = 1,
7981 .scale = 0.0f,
7982 .type = TestOperandType::TENSOR_FLOAT32,
7983 .zeroPoint = 0
7984 }, { // param19
7985 .channelQuant = {},
7986 .data = TestBuffer::createFromVector<int32_t>({2}),
7987 .dimensions = {},
7988 .isIgnored = false,
7989 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
7990 .numberOfConsumers = 1,
7991 .scale = 0.0f,
7992 .type = TestOperandType::INT32,
7993 .zeroPoint = 0
7994 }, { // param20
7995 .channelQuant = {},
7996 .data = TestBuffer::createFromVector<int32_t>({2}),
7997 .dimensions = {},
7998 .isIgnored = false,
7999 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8000 .numberOfConsumers = 1,
8001 .scale = 0.0f,
8002 .type = TestOperandType::INT32,
8003 .zeroPoint = 0
8004 }, { // param21
8005 .channelQuant = {},
8006 .data = TestBuffer::createFromVector<float>({2.0f}),
8007 .dimensions = {},
8008 .isIgnored = false,
8009 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8010 .numberOfConsumers = 1,
8011 .scale = 0.0f,
8012 .type = TestOperandType::FLOAT32,
8013 .zeroPoint = 0
8014 }, { // param22
8015 .channelQuant = {},
8016 .data = TestBuffer::createFromVector<float>({2.0f}),
8017 .dimensions = {},
8018 .isIgnored = false,
8019 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8020 .numberOfConsumers = 1,
8021 .scale = 0.0f,
8022 .type = TestOperandType::FLOAT32,
8023 .zeroPoint = 0
8024 }, { // param23
8025 .channelQuant = {},
8026 .data = TestBuffer::createFromVector<int32_t>({4}),
8027 .dimensions = {},
8028 .isIgnored = false,
8029 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8030 .numberOfConsumers = 1,
8031 .scale = 0.0f,
8032 .type = TestOperandType::INT32,
8033 .zeroPoint = 0
8034 }, { // param24
8035 .channelQuant = {},
8036 .data = TestBuffer::createFromVector<int32_t>({4}),
8037 .dimensions = {},
8038 .isIgnored = false,
8039 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8040 .numberOfConsumers = 1,
8041 .scale = 0.0f,
8042 .type = TestOperandType::INT32,
8043 .zeroPoint = 0
8044 }, { // layout
8045 .channelQuant = {},
8046 .data = TestBuffer::createFromVector<bool8>({true}),
8047 .dimensions = {},
8048 .isIgnored = false,
8049 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8050 .numberOfConsumers = 2,
8051 .scale = 0.0f,
8052 .type = TestOperandType::BOOL,
8053 .zeroPoint = 0
8054 }, { // featureMap
8055 .channelQuant = {},
8056 .data = TestBuffer::createFromVector<float>({}),
8057 .dimensions = {0, 1, 2, 2},
8058 .isIgnored = false,
8059 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8060 .numberOfConsumers = 1,
8061 .scale = 0.0f,
8062 .type = TestOperandType::TENSOR_FLOAT32,
8063 .zeroPoint = 0
8064 }, { // param25
8065 .channelQuant = {},
8066 .data = TestBuffer::createFromVector<int32_t>({3}),
8067 .dimensions = {},
8068 .isIgnored = false,
8069 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8070 .numberOfConsumers = 1,
8071 .scale = 0.0f,
8072 .type = TestOperandType::INT32,
8073 .zeroPoint = 0
8074 }, { // param26
8075 .channelQuant = {},
8076 .data = TestBuffer::createFromVector<int32_t>({3}),
8077 .dimensions = {},
8078 .isIgnored = false,
8079 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8080 .numberOfConsumers = 1,
8081 .scale = 0.0f,
8082 .type = TestOperandType::INT32,
8083 .zeroPoint = 0
8084 }, { // out
8085 .channelQuant = {},
8086 .data = TestBuffer::createFromVector<float>({}),
8087 .dimensions = {0, 1, 3, 3},
8088 .isIgnored = false,
8089 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8090 .numberOfConsumers = 0,
8091 .scale = 0.0f,
8092 .type = TestOperandType::TENSOR_FLOAT32,
8093 .zeroPoint = 0
8094 }},
8095 .operations = {{
8096 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
8097 .outputs = {9, 10, 11, 12},
8098 .type = TestOperationType::BOX_WITH_NMS_LIMIT
8099 }, {
8100 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
8101 .outputs = {21},
8102 .type = TestOperationType::ROI_ALIGN
8103 }, {
8104 .inputs = {21, 22, 23, 20},
8105 .outputs = {24},
8106 .type = TestOperationType::RESIZE_BILINEAR
8107 }},
8108 .outputIndexes = {9, 11, 24}
8109 },
8110 .minSupportedVersion = TestHalVersion::V1_2,
8111 .referenced = {}
8112 };
8113 return model;
8114 }
8115
8116 const auto dummy_test_model_zero_sized_nchw = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nchw", get_test_model_zero_sized_nchw());
8117
8118 } // namespace generated_tests::resize_bilinear_v1_2
8119
8120 namespace generated_tests::resize_bilinear_v1_2 {
8121
get_test_model_zero_sized_nchw_relaxed()8122 const TestModel& get_test_model_zero_sized_nchw_relaxed() {
8123 static TestModel model = {
8124 .expectFailure = false,
8125 .expectedMultinomialDistributionTolerance = 0,
8126 .isRelaxed = true,
8127 .main = { // zero_sized
8128 .inputIndexes = {13},
8129 .operands = {{ // scores
8130 .channelQuant = {},
8131 .data = TestBuffer::createFromVector<float>({0.9f, 0.1f}),
8132 .dimensions = {1, 2},
8133 .isIgnored = false,
8134 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8135 .numberOfConsumers = 1,
8136 .scale = 0.0f,
8137 .type = TestOperandType::TENSOR_FLOAT32,
8138 .zeroPoint = 0
8139 }, { // roi
8140 .channelQuant = {},
8141 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
8142 .dimensions = {1, 8},
8143 .isIgnored = false,
8144 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8145 .numberOfConsumers = 1,
8146 .scale = 0.0f,
8147 .type = TestOperandType::TENSOR_FLOAT32,
8148 .zeroPoint = 0
8149 }, { // param12
8150 .channelQuant = {},
8151 .data = TestBuffer::createFromVector<int32_t>({0}),
8152 .dimensions = {1},
8153 .isIgnored = false,
8154 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8155 .numberOfConsumers = 1,
8156 .scale = 0.0f,
8157 .type = TestOperandType::TENSOR_INT32,
8158 .zeroPoint = 0
8159 }, { // param13
8160 .channelQuant = {},
8161 .data = TestBuffer::createFromVector<float>({0.3f}),
8162 .dimensions = {},
8163 .isIgnored = false,
8164 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8165 .numberOfConsumers = 1,
8166 .scale = 0.0f,
8167 .type = TestOperandType::FLOAT32,
8168 .zeroPoint = 0
8169 }, { // param14
8170 .channelQuant = {},
8171 .data = TestBuffer::createFromVector<int32_t>({-1}),
8172 .dimensions = {},
8173 .isIgnored = false,
8174 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8175 .numberOfConsumers = 1,
8176 .scale = 0.0f,
8177 .type = TestOperandType::INT32,
8178 .zeroPoint = 0
8179 }, { // param15
8180 .channelQuant = {},
8181 .data = TestBuffer::createFromVector<int32_t>({0}),
8182 .dimensions = {},
8183 .isIgnored = false,
8184 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8185 .numberOfConsumers = 1,
8186 .scale = 0.0f,
8187 .type = TestOperandType::INT32,
8188 .zeroPoint = 0
8189 }, { // param16
8190 .channelQuant = {},
8191 .data = TestBuffer::createFromVector<float>({0.4f}),
8192 .dimensions = {},
8193 .isIgnored = false,
8194 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8195 .numberOfConsumers = 1,
8196 .scale = 0.0f,
8197 .type = TestOperandType::FLOAT32,
8198 .zeroPoint = 0
8199 }, { // param17
8200 .channelQuant = {},
8201 .data = TestBuffer::createFromVector<float>({1.0f}),
8202 .dimensions = {},
8203 .isIgnored = false,
8204 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8205 .numberOfConsumers = 1,
8206 .scale = 0.0f,
8207 .type = TestOperandType::FLOAT32,
8208 .zeroPoint = 0
8209 }, { // param18
8210 .channelQuant = {},
8211 .data = TestBuffer::createFromVector<float>({0.3f}),
8212 .dimensions = {},
8213 .isIgnored = false,
8214 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8215 .numberOfConsumers = 1,
8216 .scale = 0.0f,
8217 .type = TestOperandType::FLOAT32,
8218 .zeroPoint = 0
8219 }, { // scoresOut
8220 .channelQuant = {},
8221 .data = TestBuffer::createFromVector<float>({}),
8222 .dimensions = {0},
8223 .isIgnored = false,
8224 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8225 .numberOfConsumers = 0,
8226 .scale = 0.0f,
8227 .type = TestOperandType::TENSOR_FLOAT32,
8228 .zeroPoint = 0
8229 }, { // roiOut
8230 .channelQuant = {},
8231 .data = TestBuffer::createFromVector<float>({}),
8232 .dimensions = {0, 4},
8233 .isIgnored = false,
8234 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8235 .numberOfConsumers = 1,
8236 .scale = 0.0f,
8237 .type = TestOperandType::TENSOR_FLOAT32,
8238 .zeroPoint = 0
8239 }, { // classesOut
8240 .channelQuant = {},
8241 .data = TestBuffer::createFromVector<int32_t>({}),
8242 .dimensions = {0},
8243 .isIgnored = false,
8244 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8245 .numberOfConsumers = 0,
8246 .scale = 0.0f,
8247 .type = TestOperandType::TENSOR_INT32,
8248 .zeroPoint = 0
8249 }, { // batchSplitOut
8250 .channelQuant = {},
8251 .data = TestBuffer::createFromVector<int32_t>({}),
8252 .dimensions = {0},
8253 .isIgnored = false,
8254 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8255 .numberOfConsumers = 1,
8256 .scale = 0.0f,
8257 .type = TestOperandType::TENSOR_INT32,
8258 .zeroPoint = 0
8259 }, { // in
8260 .channelQuant = {},
8261 .data = TestBuffer::createFromVector<float>({1.0f}),
8262 .dimensions = {1, 1, 1, 1},
8263 .isIgnored = false,
8264 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8265 .numberOfConsumers = 1,
8266 .scale = 0.0f,
8267 .type = TestOperandType::TENSOR_FLOAT32,
8268 .zeroPoint = 0
8269 }, { // param19
8270 .channelQuant = {},
8271 .data = TestBuffer::createFromVector<int32_t>({2}),
8272 .dimensions = {},
8273 .isIgnored = false,
8274 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8275 .numberOfConsumers = 1,
8276 .scale = 0.0f,
8277 .type = TestOperandType::INT32,
8278 .zeroPoint = 0
8279 }, { // param20
8280 .channelQuant = {},
8281 .data = TestBuffer::createFromVector<int32_t>({2}),
8282 .dimensions = {},
8283 .isIgnored = false,
8284 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8285 .numberOfConsumers = 1,
8286 .scale = 0.0f,
8287 .type = TestOperandType::INT32,
8288 .zeroPoint = 0
8289 }, { // param21
8290 .channelQuant = {},
8291 .data = TestBuffer::createFromVector<float>({2.0f}),
8292 .dimensions = {},
8293 .isIgnored = false,
8294 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8295 .numberOfConsumers = 1,
8296 .scale = 0.0f,
8297 .type = TestOperandType::FLOAT32,
8298 .zeroPoint = 0
8299 }, { // param22
8300 .channelQuant = {},
8301 .data = TestBuffer::createFromVector<float>({2.0f}),
8302 .dimensions = {},
8303 .isIgnored = false,
8304 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8305 .numberOfConsumers = 1,
8306 .scale = 0.0f,
8307 .type = TestOperandType::FLOAT32,
8308 .zeroPoint = 0
8309 }, { // param23
8310 .channelQuant = {},
8311 .data = TestBuffer::createFromVector<int32_t>({4}),
8312 .dimensions = {},
8313 .isIgnored = false,
8314 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8315 .numberOfConsumers = 1,
8316 .scale = 0.0f,
8317 .type = TestOperandType::INT32,
8318 .zeroPoint = 0
8319 }, { // param24
8320 .channelQuant = {},
8321 .data = TestBuffer::createFromVector<int32_t>({4}),
8322 .dimensions = {},
8323 .isIgnored = false,
8324 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8325 .numberOfConsumers = 1,
8326 .scale = 0.0f,
8327 .type = TestOperandType::INT32,
8328 .zeroPoint = 0
8329 }, { // layout
8330 .channelQuant = {},
8331 .data = TestBuffer::createFromVector<bool8>({true}),
8332 .dimensions = {},
8333 .isIgnored = false,
8334 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8335 .numberOfConsumers = 2,
8336 .scale = 0.0f,
8337 .type = TestOperandType::BOOL,
8338 .zeroPoint = 0
8339 }, { // featureMap
8340 .channelQuant = {},
8341 .data = TestBuffer::createFromVector<float>({}),
8342 .dimensions = {0, 1, 2, 2},
8343 .isIgnored = false,
8344 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8345 .numberOfConsumers = 1,
8346 .scale = 0.0f,
8347 .type = TestOperandType::TENSOR_FLOAT32,
8348 .zeroPoint = 0
8349 }, { // param25
8350 .channelQuant = {},
8351 .data = TestBuffer::createFromVector<int32_t>({3}),
8352 .dimensions = {},
8353 .isIgnored = false,
8354 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8355 .numberOfConsumers = 1,
8356 .scale = 0.0f,
8357 .type = TestOperandType::INT32,
8358 .zeroPoint = 0
8359 }, { // param26
8360 .channelQuant = {},
8361 .data = TestBuffer::createFromVector<int32_t>({3}),
8362 .dimensions = {},
8363 .isIgnored = false,
8364 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8365 .numberOfConsumers = 1,
8366 .scale = 0.0f,
8367 .type = TestOperandType::INT32,
8368 .zeroPoint = 0
8369 }, { // out
8370 .channelQuant = {},
8371 .data = TestBuffer::createFromVector<float>({}),
8372 .dimensions = {0, 1, 3, 3},
8373 .isIgnored = false,
8374 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8375 .numberOfConsumers = 0,
8376 .scale = 0.0f,
8377 .type = TestOperandType::TENSOR_FLOAT32,
8378 .zeroPoint = 0
8379 }},
8380 .operations = {{
8381 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
8382 .outputs = {9, 10, 11, 12},
8383 .type = TestOperationType::BOX_WITH_NMS_LIMIT
8384 }, {
8385 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
8386 .outputs = {21},
8387 .type = TestOperationType::ROI_ALIGN
8388 }, {
8389 .inputs = {21, 22, 23, 20},
8390 .outputs = {24},
8391 .type = TestOperationType::RESIZE_BILINEAR
8392 }},
8393 .outputIndexes = {9, 11, 24}
8394 },
8395 .minSupportedVersion = TestHalVersion::UNKNOWN,
8396 .referenced = {}
8397 };
8398 return model;
8399 }
8400
8401 const auto dummy_test_model_zero_sized_nchw_relaxed = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nchw_relaxed", get_test_model_zero_sized_nchw_relaxed());
8402
8403 } // namespace generated_tests::resize_bilinear_v1_2
8404
8405 namespace generated_tests::resize_bilinear_v1_2 {
8406
get_test_model_zero_sized_nchw_quant8()8407 const TestModel& get_test_model_zero_sized_nchw_quant8() {
8408 static TestModel model = {
8409 .expectFailure = false,
8410 .expectedMultinomialDistributionTolerance = 0,
8411 .isRelaxed = false,
8412 .main = { // zero_sized
8413 .inputIndexes = {13},
8414 .operands = {{ // scores
8415 .channelQuant = {},
8416 .data = TestBuffer::createFromVector<uint8_t>({137, 129}),
8417 .dimensions = {1, 2},
8418 .isIgnored = false,
8419 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8420 .numberOfConsumers = 1,
8421 .scale = 0.1f,
8422 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
8423 .zeroPoint = 128
8424 }, { // roi
8425 .channelQuant = {},
8426 .data = TestBuffer::createFromVector<uint16_t>({8, 8, 80, 80, 0, 0, 80, 80}),
8427 .dimensions = {1, 8},
8428 .isIgnored = false,
8429 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8430 .numberOfConsumers = 1,
8431 .scale = 0.125f,
8432 .type = TestOperandType::TENSOR_QUANT16_ASYMM,
8433 .zeroPoint = 0
8434 }, { // param12
8435 .channelQuant = {},
8436 .data = TestBuffer::createFromVector<int32_t>({0}),
8437 .dimensions = {1},
8438 .isIgnored = false,
8439 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8440 .numberOfConsumers = 1,
8441 .scale = 0.0f,
8442 .type = TestOperandType::TENSOR_INT32,
8443 .zeroPoint = 0
8444 }, { // param13
8445 .channelQuant = {},
8446 .data = TestBuffer::createFromVector<float>({0.3f}),
8447 .dimensions = {},
8448 .isIgnored = false,
8449 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8450 .numberOfConsumers = 1,
8451 .scale = 0.0f,
8452 .type = TestOperandType::FLOAT32,
8453 .zeroPoint = 0
8454 }, { // param14
8455 .channelQuant = {},
8456 .data = TestBuffer::createFromVector<int32_t>({-1}),
8457 .dimensions = {},
8458 .isIgnored = false,
8459 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8460 .numberOfConsumers = 1,
8461 .scale = 0.0f,
8462 .type = TestOperandType::INT32,
8463 .zeroPoint = 0
8464 }, { // param15
8465 .channelQuant = {},
8466 .data = TestBuffer::createFromVector<int32_t>({0}),
8467 .dimensions = {},
8468 .isIgnored = false,
8469 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8470 .numberOfConsumers = 1,
8471 .scale = 0.0f,
8472 .type = TestOperandType::INT32,
8473 .zeroPoint = 0
8474 }, { // param16
8475 .channelQuant = {},
8476 .data = TestBuffer::createFromVector<float>({0.4f}),
8477 .dimensions = {},
8478 .isIgnored = false,
8479 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8480 .numberOfConsumers = 1,
8481 .scale = 0.0f,
8482 .type = TestOperandType::FLOAT32,
8483 .zeroPoint = 0
8484 }, { // param17
8485 .channelQuant = {},
8486 .data = TestBuffer::createFromVector<float>({1.0f}),
8487 .dimensions = {},
8488 .isIgnored = false,
8489 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8490 .numberOfConsumers = 1,
8491 .scale = 0.0f,
8492 .type = TestOperandType::FLOAT32,
8493 .zeroPoint = 0
8494 }, { // param18
8495 .channelQuant = {},
8496 .data = TestBuffer::createFromVector<float>({0.3f}),
8497 .dimensions = {},
8498 .isIgnored = false,
8499 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8500 .numberOfConsumers = 1,
8501 .scale = 0.0f,
8502 .type = TestOperandType::FLOAT32,
8503 .zeroPoint = 0
8504 }, { // scoresOut
8505 .channelQuant = {},
8506 .data = TestBuffer::createFromVector<uint8_t>({}),
8507 .dimensions = {0},
8508 .isIgnored = false,
8509 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8510 .numberOfConsumers = 0,
8511 .scale = 0.1f,
8512 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
8513 .zeroPoint = 128
8514 }, { // roiOut
8515 .channelQuant = {},
8516 .data = TestBuffer::createFromVector<uint16_t>({}),
8517 .dimensions = {0, 4},
8518 .isIgnored = false,
8519 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8520 .numberOfConsumers = 1,
8521 .scale = 0.125f,
8522 .type = TestOperandType::TENSOR_QUANT16_ASYMM,
8523 .zeroPoint = 0
8524 }, { // classesOut
8525 .channelQuant = {},
8526 .data = TestBuffer::createFromVector<int32_t>({}),
8527 .dimensions = {0},
8528 .isIgnored = false,
8529 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8530 .numberOfConsumers = 0,
8531 .scale = 0.0f,
8532 .type = TestOperandType::TENSOR_INT32,
8533 .zeroPoint = 0
8534 }, { // batchSplitOut
8535 .channelQuant = {},
8536 .data = TestBuffer::createFromVector<int32_t>({}),
8537 .dimensions = {0},
8538 .isIgnored = false,
8539 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8540 .numberOfConsumers = 1,
8541 .scale = 0.0f,
8542 .type = TestOperandType::TENSOR_INT32,
8543 .zeroPoint = 0
8544 }, { // in
8545 .channelQuant = {},
8546 .data = TestBuffer::createFromVector<uint8_t>({138}),
8547 .dimensions = {1, 1, 1, 1},
8548 .isIgnored = false,
8549 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8550 .numberOfConsumers = 1,
8551 .scale = 0.1f,
8552 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
8553 .zeroPoint = 128
8554 }, { // param19
8555 .channelQuant = {},
8556 .data = TestBuffer::createFromVector<int32_t>({2}),
8557 .dimensions = {},
8558 .isIgnored = false,
8559 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8560 .numberOfConsumers = 1,
8561 .scale = 0.0f,
8562 .type = TestOperandType::INT32,
8563 .zeroPoint = 0
8564 }, { // param20
8565 .channelQuant = {},
8566 .data = TestBuffer::createFromVector<int32_t>({2}),
8567 .dimensions = {},
8568 .isIgnored = false,
8569 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8570 .numberOfConsumers = 1,
8571 .scale = 0.0f,
8572 .type = TestOperandType::INT32,
8573 .zeroPoint = 0
8574 }, { // param21
8575 .channelQuant = {},
8576 .data = TestBuffer::createFromVector<float>({2.0f}),
8577 .dimensions = {},
8578 .isIgnored = false,
8579 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8580 .numberOfConsumers = 1,
8581 .scale = 0.0f,
8582 .type = TestOperandType::FLOAT32,
8583 .zeroPoint = 0
8584 }, { // param22
8585 .channelQuant = {},
8586 .data = TestBuffer::createFromVector<float>({2.0f}),
8587 .dimensions = {},
8588 .isIgnored = false,
8589 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8590 .numberOfConsumers = 1,
8591 .scale = 0.0f,
8592 .type = TestOperandType::FLOAT32,
8593 .zeroPoint = 0
8594 }, { // param23
8595 .channelQuant = {},
8596 .data = TestBuffer::createFromVector<int32_t>({4}),
8597 .dimensions = {},
8598 .isIgnored = false,
8599 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8600 .numberOfConsumers = 1,
8601 .scale = 0.0f,
8602 .type = TestOperandType::INT32,
8603 .zeroPoint = 0
8604 }, { // param24
8605 .channelQuant = {},
8606 .data = TestBuffer::createFromVector<int32_t>({4}),
8607 .dimensions = {},
8608 .isIgnored = false,
8609 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8610 .numberOfConsumers = 1,
8611 .scale = 0.0f,
8612 .type = TestOperandType::INT32,
8613 .zeroPoint = 0
8614 }, { // layout
8615 .channelQuant = {},
8616 .data = TestBuffer::createFromVector<bool8>({true}),
8617 .dimensions = {},
8618 .isIgnored = false,
8619 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8620 .numberOfConsumers = 2,
8621 .scale = 0.0f,
8622 .type = TestOperandType::BOOL,
8623 .zeroPoint = 0
8624 }, { // featureMap
8625 .channelQuant = {},
8626 .data = TestBuffer::createFromVector<uint8_t>({}),
8627 .dimensions = {0, 1, 2, 2},
8628 .isIgnored = false,
8629 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8630 .numberOfConsumers = 1,
8631 .scale = 0.1f,
8632 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
8633 .zeroPoint = 128
8634 }, { // param25
8635 .channelQuant = {},
8636 .data = TestBuffer::createFromVector<int32_t>({3}),
8637 .dimensions = {},
8638 .isIgnored = false,
8639 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8640 .numberOfConsumers = 1,
8641 .scale = 0.0f,
8642 .type = TestOperandType::INT32,
8643 .zeroPoint = 0
8644 }, { // param26
8645 .channelQuant = {},
8646 .data = TestBuffer::createFromVector<int32_t>({3}),
8647 .dimensions = {},
8648 .isIgnored = false,
8649 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8650 .numberOfConsumers = 1,
8651 .scale = 0.0f,
8652 .type = TestOperandType::INT32,
8653 .zeroPoint = 0
8654 }, { // out
8655 .channelQuant = {},
8656 .data = TestBuffer::createFromVector<uint8_t>({}),
8657 .dimensions = {0, 1, 3, 3},
8658 .isIgnored = false,
8659 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8660 .numberOfConsumers = 0,
8661 .scale = 0.1f,
8662 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
8663 .zeroPoint = 128
8664 }},
8665 .operations = {{
8666 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
8667 .outputs = {9, 10, 11, 12},
8668 .type = TestOperationType::BOX_WITH_NMS_LIMIT
8669 }, {
8670 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
8671 .outputs = {21},
8672 .type = TestOperationType::ROI_ALIGN
8673 }, {
8674 .inputs = {21, 22, 23, 20},
8675 .outputs = {24},
8676 .type = TestOperationType::RESIZE_BILINEAR
8677 }},
8678 .outputIndexes = {9, 11, 24}
8679 },
8680 .minSupportedVersion = TestHalVersion::V1_2,
8681 .referenced = {}
8682 };
8683 return model;
8684 }
8685
8686 const auto dummy_test_model_zero_sized_nchw_quant8 = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nchw_quant8", get_test_model_zero_sized_nchw_quant8());
8687
8688 } // namespace generated_tests::resize_bilinear_v1_2
8689
8690 namespace generated_tests::resize_bilinear_v1_2 {
8691
get_test_model_zero_sized_nchw_float16()8692 const TestModel& get_test_model_zero_sized_nchw_float16() {
8693 static TestModel model = {
8694 .expectFailure = false,
8695 .expectedMultinomialDistributionTolerance = 0,
8696 .isRelaxed = false,
8697 .main = { // zero_sized
8698 .inputIndexes = {13},
8699 .operands = {{ // scores
8700 .channelQuant = {},
8701 .data = TestBuffer::createFromVector<_Float16>({0.8999999761581421f, 0.10000000149011612f}),
8702 .dimensions = {1, 2},
8703 .isIgnored = false,
8704 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8705 .numberOfConsumers = 1,
8706 .scale = 0.0f,
8707 .type = TestOperandType::TENSOR_FLOAT16,
8708 .zeroPoint = 0
8709 }, { // roi
8710 .channelQuant = {},
8711 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
8712 .dimensions = {1, 8},
8713 .isIgnored = false,
8714 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8715 .numberOfConsumers = 1,
8716 .scale = 0.0f,
8717 .type = TestOperandType::TENSOR_FLOAT16,
8718 .zeroPoint = 0
8719 }, { // param12
8720 .channelQuant = {},
8721 .data = TestBuffer::createFromVector<int32_t>({0}),
8722 .dimensions = {1},
8723 .isIgnored = false,
8724 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8725 .numberOfConsumers = 1,
8726 .scale = 0.0f,
8727 .type = TestOperandType::TENSOR_INT32,
8728 .zeroPoint = 0
8729 }, { // param13
8730 .channelQuant = {},
8731 .data = TestBuffer::createFromVector<_Float16>({0.30000001192092896f}),
8732 .dimensions = {},
8733 .isIgnored = false,
8734 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8735 .numberOfConsumers = 1,
8736 .scale = 0.0f,
8737 .type = TestOperandType::FLOAT16,
8738 .zeroPoint = 0
8739 }, { // param14
8740 .channelQuant = {},
8741 .data = TestBuffer::createFromVector<int32_t>({-1}),
8742 .dimensions = {},
8743 .isIgnored = false,
8744 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8745 .numberOfConsumers = 1,
8746 .scale = 0.0f,
8747 .type = TestOperandType::INT32,
8748 .zeroPoint = 0
8749 }, { // param15
8750 .channelQuant = {},
8751 .data = TestBuffer::createFromVector<int32_t>({0}),
8752 .dimensions = {},
8753 .isIgnored = false,
8754 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8755 .numberOfConsumers = 1,
8756 .scale = 0.0f,
8757 .type = TestOperandType::INT32,
8758 .zeroPoint = 0
8759 }, { // param16
8760 .channelQuant = {},
8761 .data = TestBuffer::createFromVector<_Float16>({0.4000000059604645f}),
8762 .dimensions = {},
8763 .isIgnored = false,
8764 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8765 .numberOfConsumers = 1,
8766 .scale = 0.0f,
8767 .type = TestOperandType::FLOAT16,
8768 .zeroPoint = 0
8769 }, { // param17
8770 .channelQuant = {},
8771 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
8772 .dimensions = {},
8773 .isIgnored = false,
8774 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8775 .numberOfConsumers = 1,
8776 .scale = 0.0f,
8777 .type = TestOperandType::FLOAT16,
8778 .zeroPoint = 0
8779 }, { // param18
8780 .channelQuant = {},
8781 .data = TestBuffer::createFromVector<_Float16>({0.30000001192092896f}),
8782 .dimensions = {},
8783 .isIgnored = false,
8784 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8785 .numberOfConsumers = 1,
8786 .scale = 0.0f,
8787 .type = TestOperandType::FLOAT16,
8788 .zeroPoint = 0
8789 }, { // scoresOut
8790 .channelQuant = {},
8791 .data = TestBuffer::createFromVector<_Float16>({}),
8792 .dimensions = {0},
8793 .isIgnored = false,
8794 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8795 .numberOfConsumers = 0,
8796 .scale = 0.0f,
8797 .type = TestOperandType::TENSOR_FLOAT16,
8798 .zeroPoint = 0
8799 }, { // roiOut
8800 .channelQuant = {},
8801 .data = TestBuffer::createFromVector<_Float16>({}),
8802 .dimensions = {0, 4},
8803 .isIgnored = false,
8804 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8805 .numberOfConsumers = 1,
8806 .scale = 0.0f,
8807 .type = TestOperandType::TENSOR_FLOAT16,
8808 .zeroPoint = 0
8809 }, { // classesOut
8810 .channelQuant = {},
8811 .data = TestBuffer::createFromVector<int32_t>({}),
8812 .dimensions = {0},
8813 .isIgnored = false,
8814 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8815 .numberOfConsumers = 0,
8816 .scale = 0.0f,
8817 .type = TestOperandType::TENSOR_INT32,
8818 .zeroPoint = 0
8819 }, { // batchSplitOut
8820 .channelQuant = {},
8821 .data = TestBuffer::createFromVector<int32_t>({}),
8822 .dimensions = {0},
8823 .isIgnored = false,
8824 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8825 .numberOfConsumers = 1,
8826 .scale = 0.0f,
8827 .type = TestOperandType::TENSOR_INT32,
8828 .zeroPoint = 0
8829 }, { // in
8830 .channelQuant = {},
8831 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
8832 .dimensions = {1, 1, 1, 1},
8833 .isIgnored = false,
8834 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
8835 .numberOfConsumers = 1,
8836 .scale = 0.0f,
8837 .type = TestOperandType::TENSOR_FLOAT16,
8838 .zeroPoint = 0
8839 }, { // param19
8840 .channelQuant = {},
8841 .data = TestBuffer::createFromVector<int32_t>({2}),
8842 .dimensions = {},
8843 .isIgnored = false,
8844 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8845 .numberOfConsumers = 1,
8846 .scale = 0.0f,
8847 .type = TestOperandType::INT32,
8848 .zeroPoint = 0
8849 }, { // param20
8850 .channelQuant = {},
8851 .data = TestBuffer::createFromVector<int32_t>({2}),
8852 .dimensions = {},
8853 .isIgnored = false,
8854 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8855 .numberOfConsumers = 1,
8856 .scale = 0.0f,
8857 .type = TestOperandType::INT32,
8858 .zeroPoint = 0
8859 }, { // param21
8860 .channelQuant = {},
8861 .data = TestBuffer::createFromVector<_Float16>({2.0f}),
8862 .dimensions = {},
8863 .isIgnored = false,
8864 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8865 .numberOfConsumers = 1,
8866 .scale = 0.0f,
8867 .type = TestOperandType::FLOAT16,
8868 .zeroPoint = 0
8869 }, { // param22
8870 .channelQuant = {},
8871 .data = TestBuffer::createFromVector<_Float16>({2.0f}),
8872 .dimensions = {},
8873 .isIgnored = false,
8874 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8875 .numberOfConsumers = 1,
8876 .scale = 0.0f,
8877 .type = TestOperandType::FLOAT16,
8878 .zeroPoint = 0
8879 }, { // param23
8880 .channelQuant = {},
8881 .data = TestBuffer::createFromVector<int32_t>({4}),
8882 .dimensions = {},
8883 .isIgnored = false,
8884 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8885 .numberOfConsumers = 1,
8886 .scale = 0.0f,
8887 .type = TestOperandType::INT32,
8888 .zeroPoint = 0
8889 }, { // param24
8890 .channelQuant = {},
8891 .data = TestBuffer::createFromVector<int32_t>({4}),
8892 .dimensions = {},
8893 .isIgnored = false,
8894 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8895 .numberOfConsumers = 1,
8896 .scale = 0.0f,
8897 .type = TestOperandType::INT32,
8898 .zeroPoint = 0
8899 }, { // layout
8900 .channelQuant = {},
8901 .data = TestBuffer::createFromVector<bool8>({true}),
8902 .dimensions = {},
8903 .isIgnored = false,
8904 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8905 .numberOfConsumers = 2,
8906 .scale = 0.0f,
8907 .type = TestOperandType::BOOL,
8908 .zeroPoint = 0
8909 }, { // featureMap
8910 .channelQuant = {},
8911 .data = TestBuffer::createFromVector<_Float16>({}),
8912 .dimensions = {0, 1, 2, 2},
8913 .isIgnored = false,
8914 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
8915 .numberOfConsumers = 1,
8916 .scale = 0.0f,
8917 .type = TestOperandType::TENSOR_FLOAT16,
8918 .zeroPoint = 0
8919 }, { // param25
8920 .channelQuant = {},
8921 .data = TestBuffer::createFromVector<int32_t>({3}),
8922 .dimensions = {},
8923 .isIgnored = false,
8924 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8925 .numberOfConsumers = 1,
8926 .scale = 0.0f,
8927 .type = TestOperandType::INT32,
8928 .zeroPoint = 0
8929 }, { // param26
8930 .channelQuant = {},
8931 .data = TestBuffer::createFromVector<int32_t>({3}),
8932 .dimensions = {},
8933 .isIgnored = false,
8934 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8935 .numberOfConsumers = 1,
8936 .scale = 0.0f,
8937 .type = TestOperandType::INT32,
8938 .zeroPoint = 0
8939 }, { // out
8940 .channelQuant = {},
8941 .data = TestBuffer::createFromVector<_Float16>({}),
8942 .dimensions = {0, 1, 3, 3},
8943 .isIgnored = false,
8944 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
8945 .numberOfConsumers = 0,
8946 .scale = 0.0f,
8947 .type = TestOperandType::TENSOR_FLOAT16,
8948 .zeroPoint = 0
8949 }},
8950 .operations = {{
8951 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
8952 .outputs = {9, 10, 11, 12},
8953 .type = TestOperationType::BOX_WITH_NMS_LIMIT
8954 }, {
8955 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
8956 .outputs = {21},
8957 .type = TestOperationType::ROI_ALIGN
8958 }, {
8959 .inputs = {21, 22, 23, 20},
8960 .outputs = {24},
8961 .type = TestOperationType::RESIZE_BILINEAR
8962 }},
8963 .outputIndexes = {9, 11, 24}
8964 },
8965 .minSupportedVersion = TestHalVersion::V1_2,
8966 .referenced = {}
8967 };
8968 return model;
8969 }
8970
8971 const auto dummy_test_model_zero_sized_nchw_float16 = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nchw_float16", get_test_model_zero_sized_nchw_float16());
8972
8973 } // namespace generated_tests::resize_bilinear_v1_2
8974
8975 namespace generated_tests::resize_bilinear_v1_2 {
8976
get_test_model_zero_sized_nhwc_2()8977 const TestModel& get_test_model_zero_sized_nhwc_2() {
8978 static TestModel model = {
8979 .expectFailure = false,
8980 .expectedMultinomialDistributionTolerance = 0,
8981 .isRelaxed = false,
8982 .main = { // zero_sized
8983 .inputIndexes = {13},
8984 .operands = {{ // scores1
8985 .channelQuant = {},
8986 .data = TestBuffer::createFromVector<float>({0.9f, 0.1f}),
8987 .dimensions = {1, 2},
8988 .isIgnored = false,
8989 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
8990 .numberOfConsumers = 1,
8991 .scale = 0.0f,
8992 .type = TestOperandType::TENSOR_FLOAT32,
8993 .zeroPoint = 0
8994 }, { // roi1
8995 .channelQuant = {},
8996 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
8997 .dimensions = {1, 8},
8998 .isIgnored = false,
8999 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9000 .numberOfConsumers = 1,
9001 .scale = 0.0f,
9002 .type = TestOperandType::TENSOR_FLOAT32,
9003 .zeroPoint = 0
9004 }, { // param27
9005 .channelQuant = {},
9006 .data = TestBuffer::createFromVector<int32_t>({0}),
9007 .dimensions = {1},
9008 .isIgnored = false,
9009 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9010 .numberOfConsumers = 1,
9011 .scale = 0.0f,
9012 .type = TestOperandType::TENSOR_INT32,
9013 .zeroPoint = 0
9014 }, { // param28
9015 .channelQuant = {},
9016 .data = TestBuffer::createFromVector<float>({0.3f}),
9017 .dimensions = {},
9018 .isIgnored = false,
9019 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9020 .numberOfConsumers = 1,
9021 .scale = 0.0f,
9022 .type = TestOperandType::FLOAT32,
9023 .zeroPoint = 0
9024 }, { // param29
9025 .channelQuant = {},
9026 .data = TestBuffer::createFromVector<int32_t>({-1}),
9027 .dimensions = {},
9028 .isIgnored = false,
9029 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9030 .numberOfConsumers = 1,
9031 .scale = 0.0f,
9032 .type = TestOperandType::INT32,
9033 .zeroPoint = 0
9034 }, { // param30
9035 .channelQuant = {},
9036 .data = TestBuffer::createFromVector<int32_t>({0}),
9037 .dimensions = {},
9038 .isIgnored = false,
9039 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9040 .numberOfConsumers = 1,
9041 .scale = 0.0f,
9042 .type = TestOperandType::INT32,
9043 .zeroPoint = 0
9044 }, { // param31
9045 .channelQuant = {},
9046 .data = TestBuffer::createFromVector<float>({0.4f}),
9047 .dimensions = {},
9048 .isIgnored = false,
9049 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9050 .numberOfConsumers = 1,
9051 .scale = 0.0f,
9052 .type = TestOperandType::FLOAT32,
9053 .zeroPoint = 0
9054 }, { // param32
9055 .channelQuant = {},
9056 .data = TestBuffer::createFromVector<float>({1.0f}),
9057 .dimensions = {},
9058 .isIgnored = false,
9059 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9060 .numberOfConsumers = 1,
9061 .scale = 0.0f,
9062 .type = TestOperandType::FLOAT32,
9063 .zeroPoint = 0
9064 }, { // param33
9065 .channelQuant = {},
9066 .data = TestBuffer::createFromVector<float>({0.3f}),
9067 .dimensions = {},
9068 .isIgnored = false,
9069 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9070 .numberOfConsumers = 1,
9071 .scale = 0.0f,
9072 .type = TestOperandType::FLOAT32,
9073 .zeroPoint = 0
9074 }, { // scoresOut1
9075 .channelQuant = {},
9076 .data = TestBuffer::createFromVector<float>({}),
9077 .dimensions = {0},
9078 .isIgnored = false,
9079 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9080 .numberOfConsumers = 0,
9081 .scale = 0.0f,
9082 .type = TestOperandType::TENSOR_FLOAT32,
9083 .zeroPoint = 0
9084 }, { // roiOut1
9085 .channelQuant = {},
9086 .data = TestBuffer::createFromVector<float>({}),
9087 .dimensions = {0, 4},
9088 .isIgnored = false,
9089 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9090 .numberOfConsumers = 1,
9091 .scale = 0.0f,
9092 .type = TestOperandType::TENSOR_FLOAT32,
9093 .zeroPoint = 0
9094 }, { // classesOut1
9095 .channelQuant = {},
9096 .data = TestBuffer::createFromVector<int32_t>({}),
9097 .dimensions = {0},
9098 .isIgnored = false,
9099 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9100 .numberOfConsumers = 0,
9101 .scale = 0.0f,
9102 .type = TestOperandType::TENSOR_INT32,
9103 .zeroPoint = 0
9104 }, { // batchSplitOut1
9105 .channelQuant = {},
9106 .data = TestBuffer::createFromVector<int32_t>({}),
9107 .dimensions = {0},
9108 .isIgnored = false,
9109 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9110 .numberOfConsumers = 1,
9111 .scale = 0.0f,
9112 .type = TestOperandType::TENSOR_INT32,
9113 .zeroPoint = 0
9114 }, { // in1
9115 .channelQuant = {},
9116 .data = TestBuffer::createFromVector<float>({1.0f}),
9117 .dimensions = {1, 1, 1, 1},
9118 .isIgnored = false,
9119 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9120 .numberOfConsumers = 1,
9121 .scale = 0.0f,
9122 .type = TestOperandType::TENSOR_FLOAT32,
9123 .zeroPoint = 0
9124 }, { // param34
9125 .channelQuant = {},
9126 .data = TestBuffer::createFromVector<int32_t>({2}),
9127 .dimensions = {},
9128 .isIgnored = false,
9129 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9130 .numberOfConsumers = 1,
9131 .scale = 0.0f,
9132 .type = TestOperandType::INT32,
9133 .zeroPoint = 0
9134 }, { // param35
9135 .channelQuant = {},
9136 .data = TestBuffer::createFromVector<int32_t>({2}),
9137 .dimensions = {},
9138 .isIgnored = false,
9139 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9140 .numberOfConsumers = 1,
9141 .scale = 0.0f,
9142 .type = TestOperandType::INT32,
9143 .zeroPoint = 0
9144 }, { // param36
9145 .channelQuant = {},
9146 .data = TestBuffer::createFromVector<float>({2.0f}),
9147 .dimensions = {},
9148 .isIgnored = false,
9149 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9150 .numberOfConsumers = 1,
9151 .scale = 0.0f,
9152 .type = TestOperandType::FLOAT32,
9153 .zeroPoint = 0
9154 }, { // param37
9155 .channelQuant = {},
9156 .data = TestBuffer::createFromVector<float>({2.0f}),
9157 .dimensions = {},
9158 .isIgnored = false,
9159 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9160 .numberOfConsumers = 1,
9161 .scale = 0.0f,
9162 .type = TestOperandType::FLOAT32,
9163 .zeroPoint = 0
9164 }, { // param38
9165 .channelQuant = {},
9166 .data = TestBuffer::createFromVector<int32_t>({4}),
9167 .dimensions = {},
9168 .isIgnored = false,
9169 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9170 .numberOfConsumers = 1,
9171 .scale = 0.0f,
9172 .type = TestOperandType::INT32,
9173 .zeroPoint = 0
9174 }, { // param39
9175 .channelQuant = {},
9176 .data = TestBuffer::createFromVector<int32_t>({4}),
9177 .dimensions = {},
9178 .isIgnored = false,
9179 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9180 .numberOfConsumers = 1,
9181 .scale = 0.0f,
9182 .type = TestOperandType::INT32,
9183 .zeroPoint = 0
9184 }, { // layout
9185 .channelQuant = {},
9186 .data = TestBuffer::createFromVector<bool8>({false}),
9187 .dimensions = {},
9188 .isIgnored = false,
9189 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9190 .numberOfConsumers = 2,
9191 .scale = 0.0f,
9192 .type = TestOperandType::BOOL,
9193 .zeroPoint = 0
9194 }, { // featureMap1
9195 .channelQuant = {},
9196 .data = TestBuffer::createFromVector<float>({}),
9197 .dimensions = {0, 2, 2, 1},
9198 .isIgnored = false,
9199 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9200 .numberOfConsumers = 1,
9201 .scale = 0.0f,
9202 .type = TestOperandType::TENSOR_FLOAT32,
9203 .zeroPoint = 0
9204 }, { // param40
9205 .channelQuant = {},
9206 .data = TestBuffer::createFromVector<float>({1.6f}),
9207 .dimensions = {},
9208 .isIgnored = false,
9209 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9210 .numberOfConsumers = 1,
9211 .scale = 0.0f,
9212 .type = TestOperandType::FLOAT32,
9213 .zeroPoint = 0
9214 }, { // param41
9215 .channelQuant = {},
9216 .data = TestBuffer::createFromVector<float>({1.6f}),
9217 .dimensions = {},
9218 .isIgnored = false,
9219 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9220 .numberOfConsumers = 1,
9221 .scale = 0.0f,
9222 .type = TestOperandType::FLOAT32,
9223 .zeroPoint = 0
9224 }, { // out1
9225 .channelQuant = {},
9226 .data = TestBuffer::createFromVector<float>({}),
9227 .dimensions = {0, 3, 3, 1},
9228 .isIgnored = false,
9229 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9230 .numberOfConsumers = 0,
9231 .scale = 0.0f,
9232 .type = TestOperandType::TENSOR_FLOAT32,
9233 .zeroPoint = 0
9234 }},
9235 .operations = {{
9236 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
9237 .outputs = {9, 10, 11, 12},
9238 .type = TestOperationType::BOX_WITH_NMS_LIMIT
9239 }, {
9240 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
9241 .outputs = {21},
9242 .type = TestOperationType::ROI_ALIGN
9243 }, {
9244 .inputs = {21, 22, 23, 20},
9245 .outputs = {24},
9246 .type = TestOperationType::RESIZE_BILINEAR
9247 }},
9248 .outputIndexes = {9, 11, 24}
9249 },
9250 .minSupportedVersion = TestHalVersion::V1_2,
9251 .referenced = {}
9252 };
9253 return model;
9254 }
9255
9256 const auto dummy_test_model_zero_sized_nhwc_2 = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nhwc_2", get_test_model_zero_sized_nhwc_2());
9257
9258 } // namespace generated_tests::resize_bilinear_v1_2
9259
9260 namespace generated_tests::resize_bilinear_v1_2 {
9261
get_test_model_zero_sized_nhwc_relaxed_2()9262 const TestModel& get_test_model_zero_sized_nhwc_relaxed_2() {
9263 static TestModel model = {
9264 .expectFailure = false,
9265 .expectedMultinomialDistributionTolerance = 0,
9266 .isRelaxed = true,
9267 .main = { // zero_sized
9268 .inputIndexes = {13},
9269 .operands = {{ // scores1
9270 .channelQuant = {},
9271 .data = TestBuffer::createFromVector<float>({0.9f, 0.1f}),
9272 .dimensions = {1, 2},
9273 .isIgnored = false,
9274 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9275 .numberOfConsumers = 1,
9276 .scale = 0.0f,
9277 .type = TestOperandType::TENSOR_FLOAT32,
9278 .zeroPoint = 0
9279 }, { // roi1
9280 .channelQuant = {},
9281 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
9282 .dimensions = {1, 8},
9283 .isIgnored = false,
9284 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9285 .numberOfConsumers = 1,
9286 .scale = 0.0f,
9287 .type = TestOperandType::TENSOR_FLOAT32,
9288 .zeroPoint = 0
9289 }, { // param27
9290 .channelQuant = {},
9291 .data = TestBuffer::createFromVector<int32_t>({0}),
9292 .dimensions = {1},
9293 .isIgnored = false,
9294 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9295 .numberOfConsumers = 1,
9296 .scale = 0.0f,
9297 .type = TestOperandType::TENSOR_INT32,
9298 .zeroPoint = 0
9299 }, { // param28
9300 .channelQuant = {},
9301 .data = TestBuffer::createFromVector<float>({0.3f}),
9302 .dimensions = {},
9303 .isIgnored = false,
9304 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9305 .numberOfConsumers = 1,
9306 .scale = 0.0f,
9307 .type = TestOperandType::FLOAT32,
9308 .zeroPoint = 0
9309 }, { // param29
9310 .channelQuant = {},
9311 .data = TestBuffer::createFromVector<int32_t>({-1}),
9312 .dimensions = {},
9313 .isIgnored = false,
9314 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9315 .numberOfConsumers = 1,
9316 .scale = 0.0f,
9317 .type = TestOperandType::INT32,
9318 .zeroPoint = 0
9319 }, { // param30
9320 .channelQuant = {},
9321 .data = TestBuffer::createFromVector<int32_t>({0}),
9322 .dimensions = {},
9323 .isIgnored = false,
9324 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9325 .numberOfConsumers = 1,
9326 .scale = 0.0f,
9327 .type = TestOperandType::INT32,
9328 .zeroPoint = 0
9329 }, { // param31
9330 .channelQuant = {},
9331 .data = TestBuffer::createFromVector<float>({0.4f}),
9332 .dimensions = {},
9333 .isIgnored = false,
9334 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9335 .numberOfConsumers = 1,
9336 .scale = 0.0f,
9337 .type = TestOperandType::FLOAT32,
9338 .zeroPoint = 0
9339 }, { // param32
9340 .channelQuant = {},
9341 .data = TestBuffer::createFromVector<float>({1.0f}),
9342 .dimensions = {},
9343 .isIgnored = false,
9344 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9345 .numberOfConsumers = 1,
9346 .scale = 0.0f,
9347 .type = TestOperandType::FLOAT32,
9348 .zeroPoint = 0
9349 }, { // param33
9350 .channelQuant = {},
9351 .data = TestBuffer::createFromVector<float>({0.3f}),
9352 .dimensions = {},
9353 .isIgnored = false,
9354 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9355 .numberOfConsumers = 1,
9356 .scale = 0.0f,
9357 .type = TestOperandType::FLOAT32,
9358 .zeroPoint = 0
9359 }, { // scoresOut1
9360 .channelQuant = {},
9361 .data = TestBuffer::createFromVector<float>({}),
9362 .dimensions = {0},
9363 .isIgnored = false,
9364 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9365 .numberOfConsumers = 0,
9366 .scale = 0.0f,
9367 .type = TestOperandType::TENSOR_FLOAT32,
9368 .zeroPoint = 0
9369 }, { // roiOut1
9370 .channelQuant = {},
9371 .data = TestBuffer::createFromVector<float>({}),
9372 .dimensions = {0, 4},
9373 .isIgnored = false,
9374 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9375 .numberOfConsumers = 1,
9376 .scale = 0.0f,
9377 .type = TestOperandType::TENSOR_FLOAT32,
9378 .zeroPoint = 0
9379 }, { // classesOut1
9380 .channelQuant = {},
9381 .data = TestBuffer::createFromVector<int32_t>({}),
9382 .dimensions = {0},
9383 .isIgnored = false,
9384 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9385 .numberOfConsumers = 0,
9386 .scale = 0.0f,
9387 .type = TestOperandType::TENSOR_INT32,
9388 .zeroPoint = 0
9389 }, { // batchSplitOut1
9390 .channelQuant = {},
9391 .data = TestBuffer::createFromVector<int32_t>({}),
9392 .dimensions = {0},
9393 .isIgnored = false,
9394 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9395 .numberOfConsumers = 1,
9396 .scale = 0.0f,
9397 .type = TestOperandType::TENSOR_INT32,
9398 .zeroPoint = 0
9399 }, { // in1
9400 .channelQuant = {},
9401 .data = TestBuffer::createFromVector<float>({1.0f}),
9402 .dimensions = {1, 1, 1, 1},
9403 .isIgnored = false,
9404 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9405 .numberOfConsumers = 1,
9406 .scale = 0.0f,
9407 .type = TestOperandType::TENSOR_FLOAT32,
9408 .zeroPoint = 0
9409 }, { // param34
9410 .channelQuant = {},
9411 .data = TestBuffer::createFromVector<int32_t>({2}),
9412 .dimensions = {},
9413 .isIgnored = false,
9414 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9415 .numberOfConsumers = 1,
9416 .scale = 0.0f,
9417 .type = TestOperandType::INT32,
9418 .zeroPoint = 0
9419 }, { // param35
9420 .channelQuant = {},
9421 .data = TestBuffer::createFromVector<int32_t>({2}),
9422 .dimensions = {},
9423 .isIgnored = false,
9424 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9425 .numberOfConsumers = 1,
9426 .scale = 0.0f,
9427 .type = TestOperandType::INT32,
9428 .zeroPoint = 0
9429 }, { // param36
9430 .channelQuant = {},
9431 .data = TestBuffer::createFromVector<float>({2.0f}),
9432 .dimensions = {},
9433 .isIgnored = false,
9434 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9435 .numberOfConsumers = 1,
9436 .scale = 0.0f,
9437 .type = TestOperandType::FLOAT32,
9438 .zeroPoint = 0
9439 }, { // param37
9440 .channelQuant = {},
9441 .data = TestBuffer::createFromVector<float>({2.0f}),
9442 .dimensions = {},
9443 .isIgnored = false,
9444 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9445 .numberOfConsumers = 1,
9446 .scale = 0.0f,
9447 .type = TestOperandType::FLOAT32,
9448 .zeroPoint = 0
9449 }, { // param38
9450 .channelQuant = {},
9451 .data = TestBuffer::createFromVector<int32_t>({4}),
9452 .dimensions = {},
9453 .isIgnored = false,
9454 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9455 .numberOfConsumers = 1,
9456 .scale = 0.0f,
9457 .type = TestOperandType::INT32,
9458 .zeroPoint = 0
9459 }, { // param39
9460 .channelQuant = {},
9461 .data = TestBuffer::createFromVector<int32_t>({4}),
9462 .dimensions = {},
9463 .isIgnored = false,
9464 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9465 .numberOfConsumers = 1,
9466 .scale = 0.0f,
9467 .type = TestOperandType::INT32,
9468 .zeroPoint = 0
9469 }, { // layout
9470 .channelQuant = {},
9471 .data = TestBuffer::createFromVector<bool8>({false}),
9472 .dimensions = {},
9473 .isIgnored = false,
9474 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9475 .numberOfConsumers = 2,
9476 .scale = 0.0f,
9477 .type = TestOperandType::BOOL,
9478 .zeroPoint = 0
9479 }, { // featureMap1
9480 .channelQuant = {},
9481 .data = TestBuffer::createFromVector<float>({}),
9482 .dimensions = {0, 2, 2, 1},
9483 .isIgnored = false,
9484 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9485 .numberOfConsumers = 1,
9486 .scale = 0.0f,
9487 .type = TestOperandType::TENSOR_FLOAT32,
9488 .zeroPoint = 0
9489 }, { // param40
9490 .channelQuant = {},
9491 .data = TestBuffer::createFromVector<float>({1.6f}),
9492 .dimensions = {},
9493 .isIgnored = false,
9494 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9495 .numberOfConsumers = 1,
9496 .scale = 0.0f,
9497 .type = TestOperandType::FLOAT32,
9498 .zeroPoint = 0
9499 }, { // param41
9500 .channelQuant = {},
9501 .data = TestBuffer::createFromVector<float>({1.6f}),
9502 .dimensions = {},
9503 .isIgnored = false,
9504 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9505 .numberOfConsumers = 1,
9506 .scale = 0.0f,
9507 .type = TestOperandType::FLOAT32,
9508 .zeroPoint = 0
9509 }, { // out1
9510 .channelQuant = {},
9511 .data = TestBuffer::createFromVector<float>({}),
9512 .dimensions = {0, 3, 3, 1},
9513 .isIgnored = false,
9514 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9515 .numberOfConsumers = 0,
9516 .scale = 0.0f,
9517 .type = TestOperandType::TENSOR_FLOAT32,
9518 .zeroPoint = 0
9519 }},
9520 .operations = {{
9521 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
9522 .outputs = {9, 10, 11, 12},
9523 .type = TestOperationType::BOX_WITH_NMS_LIMIT
9524 }, {
9525 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
9526 .outputs = {21},
9527 .type = TestOperationType::ROI_ALIGN
9528 }, {
9529 .inputs = {21, 22, 23, 20},
9530 .outputs = {24},
9531 .type = TestOperationType::RESIZE_BILINEAR
9532 }},
9533 .outputIndexes = {9, 11, 24}
9534 },
9535 .minSupportedVersion = TestHalVersion::UNKNOWN,
9536 .referenced = {}
9537 };
9538 return model;
9539 }
9540
9541 const auto dummy_test_model_zero_sized_nhwc_relaxed_2 = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nhwc_relaxed_2", get_test_model_zero_sized_nhwc_relaxed_2());
9542
9543 } // namespace generated_tests::resize_bilinear_v1_2
9544
9545 namespace generated_tests::resize_bilinear_v1_2 {
9546
get_test_model_zero_sized_nhwc_quant8_2()9547 const TestModel& get_test_model_zero_sized_nhwc_quant8_2() {
9548 static TestModel model = {
9549 .expectFailure = false,
9550 .expectedMultinomialDistributionTolerance = 0,
9551 .isRelaxed = false,
9552 .main = { // zero_sized
9553 .inputIndexes = {13},
9554 .operands = {{ // scores1
9555 .channelQuant = {},
9556 .data = TestBuffer::createFromVector<uint8_t>({137, 129}),
9557 .dimensions = {1, 2},
9558 .isIgnored = false,
9559 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9560 .numberOfConsumers = 1,
9561 .scale = 0.1f,
9562 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
9563 .zeroPoint = 128
9564 }, { // roi1
9565 .channelQuant = {},
9566 .data = TestBuffer::createFromVector<uint16_t>({8, 8, 80, 80, 0, 0, 80, 80}),
9567 .dimensions = {1, 8},
9568 .isIgnored = false,
9569 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9570 .numberOfConsumers = 1,
9571 .scale = 0.125f,
9572 .type = TestOperandType::TENSOR_QUANT16_ASYMM,
9573 .zeroPoint = 0
9574 }, { // param27
9575 .channelQuant = {},
9576 .data = TestBuffer::createFromVector<int32_t>({0}),
9577 .dimensions = {1},
9578 .isIgnored = false,
9579 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9580 .numberOfConsumers = 1,
9581 .scale = 0.0f,
9582 .type = TestOperandType::TENSOR_INT32,
9583 .zeroPoint = 0
9584 }, { // param28
9585 .channelQuant = {},
9586 .data = TestBuffer::createFromVector<float>({0.3f}),
9587 .dimensions = {},
9588 .isIgnored = false,
9589 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9590 .numberOfConsumers = 1,
9591 .scale = 0.0f,
9592 .type = TestOperandType::FLOAT32,
9593 .zeroPoint = 0
9594 }, { // param29
9595 .channelQuant = {},
9596 .data = TestBuffer::createFromVector<int32_t>({-1}),
9597 .dimensions = {},
9598 .isIgnored = false,
9599 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9600 .numberOfConsumers = 1,
9601 .scale = 0.0f,
9602 .type = TestOperandType::INT32,
9603 .zeroPoint = 0
9604 }, { // param30
9605 .channelQuant = {},
9606 .data = TestBuffer::createFromVector<int32_t>({0}),
9607 .dimensions = {},
9608 .isIgnored = false,
9609 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9610 .numberOfConsumers = 1,
9611 .scale = 0.0f,
9612 .type = TestOperandType::INT32,
9613 .zeroPoint = 0
9614 }, { // param31
9615 .channelQuant = {},
9616 .data = TestBuffer::createFromVector<float>({0.4f}),
9617 .dimensions = {},
9618 .isIgnored = false,
9619 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9620 .numberOfConsumers = 1,
9621 .scale = 0.0f,
9622 .type = TestOperandType::FLOAT32,
9623 .zeroPoint = 0
9624 }, { // param32
9625 .channelQuant = {},
9626 .data = TestBuffer::createFromVector<float>({1.0f}),
9627 .dimensions = {},
9628 .isIgnored = false,
9629 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9630 .numberOfConsumers = 1,
9631 .scale = 0.0f,
9632 .type = TestOperandType::FLOAT32,
9633 .zeroPoint = 0
9634 }, { // param33
9635 .channelQuant = {},
9636 .data = TestBuffer::createFromVector<float>({0.3f}),
9637 .dimensions = {},
9638 .isIgnored = false,
9639 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9640 .numberOfConsumers = 1,
9641 .scale = 0.0f,
9642 .type = TestOperandType::FLOAT32,
9643 .zeroPoint = 0
9644 }, { // scoresOut1
9645 .channelQuant = {},
9646 .data = TestBuffer::createFromVector<uint8_t>({}),
9647 .dimensions = {0},
9648 .isIgnored = false,
9649 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9650 .numberOfConsumers = 0,
9651 .scale = 0.1f,
9652 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
9653 .zeroPoint = 128
9654 }, { // roiOut1
9655 .channelQuant = {},
9656 .data = TestBuffer::createFromVector<uint16_t>({}),
9657 .dimensions = {0, 4},
9658 .isIgnored = false,
9659 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9660 .numberOfConsumers = 1,
9661 .scale = 0.125f,
9662 .type = TestOperandType::TENSOR_QUANT16_ASYMM,
9663 .zeroPoint = 0
9664 }, { // classesOut1
9665 .channelQuant = {},
9666 .data = TestBuffer::createFromVector<int32_t>({}),
9667 .dimensions = {0},
9668 .isIgnored = false,
9669 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9670 .numberOfConsumers = 0,
9671 .scale = 0.0f,
9672 .type = TestOperandType::TENSOR_INT32,
9673 .zeroPoint = 0
9674 }, { // batchSplitOut1
9675 .channelQuant = {},
9676 .data = TestBuffer::createFromVector<int32_t>({}),
9677 .dimensions = {0},
9678 .isIgnored = false,
9679 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9680 .numberOfConsumers = 1,
9681 .scale = 0.0f,
9682 .type = TestOperandType::TENSOR_INT32,
9683 .zeroPoint = 0
9684 }, { // in1
9685 .channelQuant = {},
9686 .data = TestBuffer::createFromVector<uint8_t>({138}),
9687 .dimensions = {1, 1, 1, 1},
9688 .isIgnored = false,
9689 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9690 .numberOfConsumers = 1,
9691 .scale = 0.1f,
9692 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
9693 .zeroPoint = 128
9694 }, { // param34
9695 .channelQuant = {},
9696 .data = TestBuffer::createFromVector<int32_t>({2}),
9697 .dimensions = {},
9698 .isIgnored = false,
9699 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9700 .numberOfConsumers = 1,
9701 .scale = 0.0f,
9702 .type = TestOperandType::INT32,
9703 .zeroPoint = 0
9704 }, { // param35
9705 .channelQuant = {},
9706 .data = TestBuffer::createFromVector<int32_t>({2}),
9707 .dimensions = {},
9708 .isIgnored = false,
9709 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9710 .numberOfConsumers = 1,
9711 .scale = 0.0f,
9712 .type = TestOperandType::INT32,
9713 .zeroPoint = 0
9714 }, { // param36
9715 .channelQuant = {},
9716 .data = TestBuffer::createFromVector<float>({2.0f}),
9717 .dimensions = {},
9718 .isIgnored = false,
9719 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9720 .numberOfConsumers = 1,
9721 .scale = 0.0f,
9722 .type = TestOperandType::FLOAT32,
9723 .zeroPoint = 0
9724 }, { // param37
9725 .channelQuant = {},
9726 .data = TestBuffer::createFromVector<float>({2.0f}),
9727 .dimensions = {},
9728 .isIgnored = false,
9729 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9730 .numberOfConsumers = 1,
9731 .scale = 0.0f,
9732 .type = TestOperandType::FLOAT32,
9733 .zeroPoint = 0
9734 }, { // param38
9735 .channelQuant = {},
9736 .data = TestBuffer::createFromVector<int32_t>({4}),
9737 .dimensions = {},
9738 .isIgnored = false,
9739 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9740 .numberOfConsumers = 1,
9741 .scale = 0.0f,
9742 .type = TestOperandType::INT32,
9743 .zeroPoint = 0
9744 }, { // param39
9745 .channelQuant = {},
9746 .data = TestBuffer::createFromVector<int32_t>({4}),
9747 .dimensions = {},
9748 .isIgnored = false,
9749 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9750 .numberOfConsumers = 1,
9751 .scale = 0.0f,
9752 .type = TestOperandType::INT32,
9753 .zeroPoint = 0
9754 }, { // layout
9755 .channelQuant = {},
9756 .data = TestBuffer::createFromVector<bool8>({false}),
9757 .dimensions = {},
9758 .isIgnored = false,
9759 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9760 .numberOfConsumers = 2,
9761 .scale = 0.0f,
9762 .type = TestOperandType::BOOL,
9763 .zeroPoint = 0
9764 }, { // featureMap1
9765 .channelQuant = {},
9766 .data = TestBuffer::createFromVector<uint8_t>({}),
9767 .dimensions = {0, 2, 2, 1},
9768 .isIgnored = false,
9769 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9770 .numberOfConsumers = 1,
9771 .scale = 0.1f,
9772 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
9773 .zeroPoint = 128
9774 }, { // param40
9775 .channelQuant = {},
9776 .data = TestBuffer::createFromVector<float>({1.6f}),
9777 .dimensions = {},
9778 .isIgnored = false,
9779 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9780 .numberOfConsumers = 1,
9781 .scale = 0.0f,
9782 .type = TestOperandType::FLOAT32,
9783 .zeroPoint = 0
9784 }, { // param41
9785 .channelQuant = {},
9786 .data = TestBuffer::createFromVector<float>({1.6f}),
9787 .dimensions = {},
9788 .isIgnored = false,
9789 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9790 .numberOfConsumers = 1,
9791 .scale = 0.0f,
9792 .type = TestOperandType::FLOAT32,
9793 .zeroPoint = 0
9794 }, { // out1
9795 .channelQuant = {},
9796 .data = TestBuffer::createFromVector<uint8_t>({}),
9797 .dimensions = {0, 3, 3, 1},
9798 .isIgnored = false,
9799 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9800 .numberOfConsumers = 0,
9801 .scale = 0.1f,
9802 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
9803 .zeroPoint = 128
9804 }},
9805 .operations = {{
9806 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
9807 .outputs = {9, 10, 11, 12},
9808 .type = TestOperationType::BOX_WITH_NMS_LIMIT
9809 }, {
9810 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
9811 .outputs = {21},
9812 .type = TestOperationType::ROI_ALIGN
9813 }, {
9814 .inputs = {21, 22, 23, 20},
9815 .outputs = {24},
9816 .type = TestOperationType::RESIZE_BILINEAR
9817 }},
9818 .outputIndexes = {9, 11, 24}
9819 },
9820 .minSupportedVersion = TestHalVersion::V1_2,
9821 .referenced = {}
9822 };
9823 return model;
9824 }
9825
9826 const auto dummy_test_model_zero_sized_nhwc_quant8_2 = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nhwc_quant8_2", get_test_model_zero_sized_nhwc_quant8_2());
9827
9828 } // namespace generated_tests::resize_bilinear_v1_2
9829
9830 namespace generated_tests::resize_bilinear_v1_2 {
9831
get_test_model_zero_sized_nhwc_float16_2()9832 const TestModel& get_test_model_zero_sized_nhwc_float16_2() {
9833 static TestModel model = {
9834 .expectFailure = false,
9835 .expectedMultinomialDistributionTolerance = 0,
9836 .isRelaxed = false,
9837 .main = { // zero_sized
9838 .inputIndexes = {13},
9839 .operands = {{ // scores1
9840 .channelQuant = {},
9841 .data = TestBuffer::createFromVector<_Float16>({0.8999999761581421f, 0.10000000149011612f}),
9842 .dimensions = {1, 2},
9843 .isIgnored = false,
9844 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9845 .numberOfConsumers = 1,
9846 .scale = 0.0f,
9847 .type = TestOperandType::TENSOR_FLOAT16,
9848 .zeroPoint = 0
9849 }, { // roi1
9850 .channelQuant = {},
9851 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
9852 .dimensions = {1, 8},
9853 .isIgnored = false,
9854 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9855 .numberOfConsumers = 1,
9856 .scale = 0.0f,
9857 .type = TestOperandType::TENSOR_FLOAT16,
9858 .zeroPoint = 0
9859 }, { // param27
9860 .channelQuant = {},
9861 .data = TestBuffer::createFromVector<int32_t>({0}),
9862 .dimensions = {1},
9863 .isIgnored = false,
9864 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9865 .numberOfConsumers = 1,
9866 .scale = 0.0f,
9867 .type = TestOperandType::TENSOR_INT32,
9868 .zeroPoint = 0
9869 }, { // param28
9870 .channelQuant = {},
9871 .data = TestBuffer::createFromVector<_Float16>({0.30000001192092896f}),
9872 .dimensions = {},
9873 .isIgnored = false,
9874 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9875 .numberOfConsumers = 1,
9876 .scale = 0.0f,
9877 .type = TestOperandType::FLOAT16,
9878 .zeroPoint = 0
9879 }, { // param29
9880 .channelQuant = {},
9881 .data = TestBuffer::createFromVector<int32_t>({-1}),
9882 .dimensions = {},
9883 .isIgnored = false,
9884 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9885 .numberOfConsumers = 1,
9886 .scale = 0.0f,
9887 .type = TestOperandType::INT32,
9888 .zeroPoint = 0
9889 }, { // param30
9890 .channelQuant = {},
9891 .data = TestBuffer::createFromVector<int32_t>({0}),
9892 .dimensions = {},
9893 .isIgnored = false,
9894 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9895 .numberOfConsumers = 1,
9896 .scale = 0.0f,
9897 .type = TestOperandType::INT32,
9898 .zeroPoint = 0
9899 }, { // param31
9900 .channelQuant = {},
9901 .data = TestBuffer::createFromVector<_Float16>({0.4000000059604645f}),
9902 .dimensions = {},
9903 .isIgnored = false,
9904 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9905 .numberOfConsumers = 1,
9906 .scale = 0.0f,
9907 .type = TestOperandType::FLOAT16,
9908 .zeroPoint = 0
9909 }, { // param32
9910 .channelQuant = {},
9911 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
9912 .dimensions = {},
9913 .isIgnored = false,
9914 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9915 .numberOfConsumers = 1,
9916 .scale = 0.0f,
9917 .type = TestOperandType::FLOAT16,
9918 .zeroPoint = 0
9919 }, { // param33
9920 .channelQuant = {},
9921 .data = TestBuffer::createFromVector<_Float16>({0.30000001192092896f}),
9922 .dimensions = {},
9923 .isIgnored = false,
9924 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9925 .numberOfConsumers = 1,
9926 .scale = 0.0f,
9927 .type = TestOperandType::FLOAT16,
9928 .zeroPoint = 0
9929 }, { // scoresOut1
9930 .channelQuant = {},
9931 .data = TestBuffer::createFromVector<_Float16>({}),
9932 .dimensions = {0},
9933 .isIgnored = false,
9934 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9935 .numberOfConsumers = 0,
9936 .scale = 0.0f,
9937 .type = TestOperandType::TENSOR_FLOAT16,
9938 .zeroPoint = 0
9939 }, { // roiOut1
9940 .channelQuant = {},
9941 .data = TestBuffer::createFromVector<_Float16>({}),
9942 .dimensions = {0, 4},
9943 .isIgnored = false,
9944 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9945 .numberOfConsumers = 1,
9946 .scale = 0.0f,
9947 .type = TestOperandType::TENSOR_FLOAT16,
9948 .zeroPoint = 0
9949 }, { // classesOut1
9950 .channelQuant = {},
9951 .data = TestBuffer::createFromVector<int32_t>({}),
9952 .dimensions = {0},
9953 .isIgnored = false,
9954 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
9955 .numberOfConsumers = 0,
9956 .scale = 0.0f,
9957 .type = TestOperandType::TENSOR_INT32,
9958 .zeroPoint = 0
9959 }, { // batchSplitOut1
9960 .channelQuant = {},
9961 .data = TestBuffer::createFromVector<int32_t>({}),
9962 .dimensions = {0},
9963 .isIgnored = false,
9964 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
9965 .numberOfConsumers = 1,
9966 .scale = 0.0f,
9967 .type = TestOperandType::TENSOR_INT32,
9968 .zeroPoint = 0
9969 }, { // in1
9970 .channelQuant = {},
9971 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
9972 .dimensions = {1, 1, 1, 1},
9973 .isIgnored = false,
9974 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
9975 .numberOfConsumers = 1,
9976 .scale = 0.0f,
9977 .type = TestOperandType::TENSOR_FLOAT16,
9978 .zeroPoint = 0
9979 }, { // param34
9980 .channelQuant = {},
9981 .data = TestBuffer::createFromVector<int32_t>({2}),
9982 .dimensions = {},
9983 .isIgnored = false,
9984 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9985 .numberOfConsumers = 1,
9986 .scale = 0.0f,
9987 .type = TestOperandType::INT32,
9988 .zeroPoint = 0
9989 }, { // param35
9990 .channelQuant = {},
9991 .data = TestBuffer::createFromVector<int32_t>({2}),
9992 .dimensions = {},
9993 .isIgnored = false,
9994 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
9995 .numberOfConsumers = 1,
9996 .scale = 0.0f,
9997 .type = TestOperandType::INT32,
9998 .zeroPoint = 0
9999 }, { // param36
10000 .channelQuant = {},
10001 .data = TestBuffer::createFromVector<_Float16>({2.0f}),
10002 .dimensions = {},
10003 .isIgnored = false,
10004 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10005 .numberOfConsumers = 1,
10006 .scale = 0.0f,
10007 .type = TestOperandType::FLOAT16,
10008 .zeroPoint = 0
10009 }, { // param37
10010 .channelQuant = {},
10011 .data = TestBuffer::createFromVector<_Float16>({2.0f}),
10012 .dimensions = {},
10013 .isIgnored = false,
10014 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10015 .numberOfConsumers = 1,
10016 .scale = 0.0f,
10017 .type = TestOperandType::FLOAT16,
10018 .zeroPoint = 0
10019 }, { // param38
10020 .channelQuant = {},
10021 .data = TestBuffer::createFromVector<int32_t>({4}),
10022 .dimensions = {},
10023 .isIgnored = false,
10024 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10025 .numberOfConsumers = 1,
10026 .scale = 0.0f,
10027 .type = TestOperandType::INT32,
10028 .zeroPoint = 0
10029 }, { // param39
10030 .channelQuant = {},
10031 .data = TestBuffer::createFromVector<int32_t>({4}),
10032 .dimensions = {},
10033 .isIgnored = false,
10034 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10035 .numberOfConsumers = 1,
10036 .scale = 0.0f,
10037 .type = TestOperandType::INT32,
10038 .zeroPoint = 0
10039 }, { // layout
10040 .channelQuant = {},
10041 .data = TestBuffer::createFromVector<bool8>({false}),
10042 .dimensions = {},
10043 .isIgnored = false,
10044 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10045 .numberOfConsumers = 2,
10046 .scale = 0.0f,
10047 .type = TestOperandType::BOOL,
10048 .zeroPoint = 0
10049 }, { // featureMap1
10050 .channelQuant = {},
10051 .data = TestBuffer::createFromVector<_Float16>({}),
10052 .dimensions = {0, 2, 2, 1},
10053 .isIgnored = false,
10054 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10055 .numberOfConsumers = 1,
10056 .scale = 0.0f,
10057 .type = TestOperandType::TENSOR_FLOAT16,
10058 .zeroPoint = 0
10059 }, { // param40
10060 .channelQuant = {},
10061 .data = TestBuffer::createFromVector<_Float16>({1.600000023841858f}),
10062 .dimensions = {},
10063 .isIgnored = false,
10064 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10065 .numberOfConsumers = 1,
10066 .scale = 0.0f,
10067 .type = TestOperandType::FLOAT16,
10068 .zeroPoint = 0
10069 }, { // param41
10070 .channelQuant = {},
10071 .data = TestBuffer::createFromVector<_Float16>({1.600000023841858f}),
10072 .dimensions = {},
10073 .isIgnored = false,
10074 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10075 .numberOfConsumers = 1,
10076 .scale = 0.0f,
10077 .type = TestOperandType::FLOAT16,
10078 .zeroPoint = 0
10079 }, { // out1
10080 .channelQuant = {},
10081 .data = TestBuffer::createFromVector<_Float16>({}),
10082 .dimensions = {0, 3, 3, 1},
10083 .isIgnored = false,
10084 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10085 .numberOfConsumers = 0,
10086 .scale = 0.0f,
10087 .type = TestOperandType::TENSOR_FLOAT16,
10088 .zeroPoint = 0
10089 }},
10090 .operations = {{
10091 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
10092 .outputs = {9, 10, 11, 12},
10093 .type = TestOperationType::BOX_WITH_NMS_LIMIT
10094 }, {
10095 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
10096 .outputs = {21},
10097 .type = TestOperationType::ROI_ALIGN
10098 }, {
10099 .inputs = {21, 22, 23, 20},
10100 .outputs = {24},
10101 .type = TestOperationType::RESIZE_BILINEAR
10102 }},
10103 .outputIndexes = {9, 11, 24}
10104 },
10105 .minSupportedVersion = TestHalVersion::V1_2,
10106 .referenced = {}
10107 };
10108 return model;
10109 }
10110
10111 const auto dummy_test_model_zero_sized_nhwc_float16_2 = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nhwc_float16_2", get_test_model_zero_sized_nhwc_float16_2());
10112
10113 } // namespace generated_tests::resize_bilinear_v1_2
10114
10115 namespace generated_tests::resize_bilinear_v1_2 {
10116
get_test_model_zero_sized_nchw_2()10117 const TestModel& get_test_model_zero_sized_nchw_2() {
10118 static TestModel model = {
10119 .expectFailure = false,
10120 .expectedMultinomialDistributionTolerance = 0,
10121 .isRelaxed = false,
10122 .main = { // zero_sized
10123 .inputIndexes = {13},
10124 .operands = {{ // scores1
10125 .channelQuant = {},
10126 .data = TestBuffer::createFromVector<float>({0.9f, 0.1f}),
10127 .dimensions = {1, 2},
10128 .isIgnored = false,
10129 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10130 .numberOfConsumers = 1,
10131 .scale = 0.0f,
10132 .type = TestOperandType::TENSOR_FLOAT32,
10133 .zeroPoint = 0
10134 }, { // roi1
10135 .channelQuant = {},
10136 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
10137 .dimensions = {1, 8},
10138 .isIgnored = false,
10139 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10140 .numberOfConsumers = 1,
10141 .scale = 0.0f,
10142 .type = TestOperandType::TENSOR_FLOAT32,
10143 .zeroPoint = 0
10144 }, { // param27
10145 .channelQuant = {},
10146 .data = TestBuffer::createFromVector<int32_t>({0}),
10147 .dimensions = {1},
10148 .isIgnored = false,
10149 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10150 .numberOfConsumers = 1,
10151 .scale = 0.0f,
10152 .type = TestOperandType::TENSOR_INT32,
10153 .zeroPoint = 0
10154 }, { // param28
10155 .channelQuant = {},
10156 .data = TestBuffer::createFromVector<float>({0.3f}),
10157 .dimensions = {},
10158 .isIgnored = false,
10159 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10160 .numberOfConsumers = 1,
10161 .scale = 0.0f,
10162 .type = TestOperandType::FLOAT32,
10163 .zeroPoint = 0
10164 }, { // param29
10165 .channelQuant = {},
10166 .data = TestBuffer::createFromVector<int32_t>({-1}),
10167 .dimensions = {},
10168 .isIgnored = false,
10169 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10170 .numberOfConsumers = 1,
10171 .scale = 0.0f,
10172 .type = TestOperandType::INT32,
10173 .zeroPoint = 0
10174 }, { // param30
10175 .channelQuant = {},
10176 .data = TestBuffer::createFromVector<int32_t>({0}),
10177 .dimensions = {},
10178 .isIgnored = false,
10179 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10180 .numberOfConsumers = 1,
10181 .scale = 0.0f,
10182 .type = TestOperandType::INT32,
10183 .zeroPoint = 0
10184 }, { // param31
10185 .channelQuant = {},
10186 .data = TestBuffer::createFromVector<float>({0.4f}),
10187 .dimensions = {},
10188 .isIgnored = false,
10189 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10190 .numberOfConsumers = 1,
10191 .scale = 0.0f,
10192 .type = TestOperandType::FLOAT32,
10193 .zeroPoint = 0
10194 }, { // param32
10195 .channelQuant = {},
10196 .data = TestBuffer::createFromVector<float>({1.0f}),
10197 .dimensions = {},
10198 .isIgnored = false,
10199 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10200 .numberOfConsumers = 1,
10201 .scale = 0.0f,
10202 .type = TestOperandType::FLOAT32,
10203 .zeroPoint = 0
10204 }, { // param33
10205 .channelQuant = {},
10206 .data = TestBuffer::createFromVector<float>({0.3f}),
10207 .dimensions = {},
10208 .isIgnored = false,
10209 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10210 .numberOfConsumers = 1,
10211 .scale = 0.0f,
10212 .type = TestOperandType::FLOAT32,
10213 .zeroPoint = 0
10214 }, { // scoresOut1
10215 .channelQuant = {},
10216 .data = TestBuffer::createFromVector<float>({}),
10217 .dimensions = {0},
10218 .isIgnored = false,
10219 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10220 .numberOfConsumers = 0,
10221 .scale = 0.0f,
10222 .type = TestOperandType::TENSOR_FLOAT32,
10223 .zeroPoint = 0
10224 }, { // roiOut1
10225 .channelQuant = {},
10226 .data = TestBuffer::createFromVector<float>({}),
10227 .dimensions = {0, 4},
10228 .isIgnored = false,
10229 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10230 .numberOfConsumers = 1,
10231 .scale = 0.0f,
10232 .type = TestOperandType::TENSOR_FLOAT32,
10233 .zeroPoint = 0
10234 }, { // classesOut1
10235 .channelQuant = {},
10236 .data = TestBuffer::createFromVector<int32_t>({}),
10237 .dimensions = {0},
10238 .isIgnored = false,
10239 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10240 .numberOfConsumers = 0,
10241 .scale = 0.0f,
10242 .type = TestOperandType::TENSOR_INT32,
10243 .zeroPoint = 0
10244 }, { // batchSplitOut1
10245 .channelQuant = {},
10246 .data = TestBuffer::createFromVector<int32_t>({}),
10247 .dimensions = {0},
10248 .isIgnored = false,
10249 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10250 .numberOfConsumers = 1,
10251 .scale = 0.0f,
10252 .type = TestOperandType::TENSOR_INT32,
10253 .zeroPoint = 0
10254 }, { // in1
10255 .channelQuant = {},
10256 .data = TestBuffer::createFromVector<float>({1.0f}),
10257 .dimensions = {1, 1, 1, 1},
10258 .isIgnored = false,
10259 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10260 .numberOfConsumers = 1,
10261 .scale = 0.0f,
10262 .type = TestOperandType::TENSOR_FLOAT32,
10263 .zeroPoint = 0
10264 }, { // param34
10265 .channelQuant = {},
10266 .data = TestBuffer::createFromVector<int32_t>({2}),
10267 .dimensions = {},
10268 .isIgnored = false,
10269 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10270 .numberOfConsumers = 1,
10271 .scale = 0.0f,
10272 .type = TestOperandType::INT32,
10273 .zeroPoint = 0
10274 }, { // param35
10275 .channelQuant = {},
10276 .data = TestBuffer::createFromVector<int32_t>({2}),
10277 .dimensions = {},
10278 .isIgnored = false,
10279 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10280 .numberOfConsumers = 1,
10281 .scale = 0.0f,
10282 .type = TestOperandType::INT32,
10283 .zeroPoint = 0
10284 }, { // param36
10285 .channelQuant = {},
10286 .data = TestBuffer::createFromVector<float>({2.0f}),
10287 .dimensions = {},
10288 .isIgnored = false,
10289 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10290 .numberOfConsumers = 1,
10291 .scale = 0.0f,
10292 .type = TestOperandType::FLOAT32,
10293 .zeroPoint = 0
10294 }, { // param37
10295 .channelQuant = {},
10296 .data = TestBuffer::createFromVector<float>({2.0f}),
10297 .dimensions = {},
10298 .isIgnored = false,
10299 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10300 .numberOfConsumers = 1,
10301 .scale = 0.0f,
10302 .type = TestOperandType::FLOAT32,
10303 .zeroPoint = 0
10304 }, { // param38
10305 .channelQuant = {},
10306 .data = TestBuffer::createFromVector<int32_t>({4}),
10307 .dimensions = {},
10308 .isIgnored = false,
10309 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10310 .numberOfConsumers = 1,
10311 .scale = 0.0f,
10312 .type = TestOperandType::INT32,
10313 .zeroPoint = 0
10314 }, { // param39
10315 .channelQuant = {},
10316 .data = TestBuffer::createFromVector<int32_t>({4}),
10317 .dimensions = {},
10318 .isIgnored = false,
10319 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10320 .numberOfConsumers = 1,
10321 .scale = 0.0f,
10322 .type = TestOperandType::INT32,
10323 .zeroPoint = 0
10324 }, { // layout
10325 .channelQuant = {},
10326 .data = TestBuffer::createFromVector<bool8>({true}),
10327 .dimensions = {},
10328 .isIgnored = false,
10329 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10330 .numberOfConsumers = 2,
10331 .scale = 0.0f,
10332 .type = TestOperandType::BOOL,
10333 .zeroPoint = 0
10334 }, { // featureMap1
10335 .channelQuant = {},
10336 .data = TestBuffer::createFromVector<float>({}),
10337 .dimensions = {0, 1, 2, 2},
10338 .isIgnored = false,
10339 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10340 .numberOfConsumers = 1,
10341 .scale = 0.0f,
10342 .type = TestOperandType::TENSOR_FLOAT32,
10343 .zeroPoint = 0
10344 }, { // param40
10345 .channelQuant = {},
10346 .data = TestBuffer::createFromVector<float>({1.6f}),
10347 .dimensions = {},
10348 .isIgnored = false,
10349 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10350 .numberOfConsumers = 1,
10351 .scale = 0.0f,
10352 .type = TestOperandType::FLOAT32,
10353 .zeroPoint = 0
10354 }, { // param41
10355 .channelQuant = {},
10356 .data = TestBuffer::createFromVector<float>({1.6f}),
10357 .dimensions = {},
10358 .isIgnored = false,
10359 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10360 .numberOfConsumers = 1,
10361 .scale = 0.0f,
10362 .type = TestOperandType::FLOAT32,
10363 .zeroPoint = 0
10364 }, { // out1
10365 .channelQuant = {},
10366 .data = TestBuffer::createFromVector<float>({}),
10367 .dimensions = {0, 1, 3, 3},
10368 .isIgnored = false,
10369 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10370 .numberOfConsumers = 0,
10371 .scale = 0.0f,
10372 .type = TestOperandType::TENSOR_FLOAT32,
10373 .zeroPoint = 0
10374 }},
10375 .operations = {{
10376 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
10377 .outputs = {9, 10, 11, 12},
10378 .type = TestOperationType::BOX_WITH_NMS_LIMIT
10379 }, {
10380 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
10381 .outputs = {21},
10382 .type = TestOperationType::ROI_ALIGN
10383 }, {
10384 .inputs = {21, 22, 23, 20},
10385 .outputs = {24},
10386 .type = TestOperationType::RESIZE_BILINEAR
10387 }},
10388 .outputIndexes = {9, 11, 24}
10389 },
10390 .minSupportedVersion = TestHalVersion::V1_2,
10391 .referenced = {}
10392 };
10393 return model;
10394 }
10395
10396 const auto dummy_test_model_zero_sized_nchw_2 = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nchw_2", get_test_model_zero_sized_nchw_2());
10397
10398 } // namespace generated_tests::resize_bilinear_v1_2
10399
10400 namespace generated_tests::resize_bilinear_v1_2 {
10401
get_test_model_zero_sized_nchw_relaxed_2()10402 const TestModel& get_test_model_zero_sized_nchw_relaxed_2() {
10403 static TestModel model = {
10404 .expectFailure = false,
10405 .expectedMultinomialDistributionTolerance = 0,
10406 .isRelaxed = true,
10407 .main = { // zero_sized
10408 .inputIndexes = {13},
10409 .operands = {{ // scores1
10410 .channelQuant = {},
10411 .data = TestBuffer::createFromVector<float>({0.9f, 0.1f}),
10412 .dimensions = {1, 2},
10413 .isIgnored = false,
10414 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10415 .numberOfConsumers = 1,
10416 .scale = 0.0f,
10417 .type = TestOperandType::TENSOR_FLOAT32,
10418 .zeroPoint = 0
10419 }, { // roi1
10420 .channelQuant = {},
10421 .data = TestBuffer::createFromVector<float>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
10422 .dimensions = {1, 8},
10423 .isIgnored = false,
10424 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10425 .numberOfConsumers = 1,
10426 .scale = 0.0f,
10427 .type = TestOperandType::TENSOR_FLOAT32,
10428 .zeroPoint = 0
10429 }, { // param27
10430 .channelQuant = {},
10431 .data = TestBuffer::createFromVector<int32_t>({0}),
10432 .dimensions = {1},
10433 .isIgnored = false,
10434 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10435 .numberOfConsumers = 1,
10436 .scale = 0.0f,
10437 .type = TestOperandType::TENSOR_INT32,
10438 .zeroPoint = 0
10439 }, { // param28
10440 .channelQuant = {},
10441 .data = TestBuffer::createFromVector<float>({0.3f}),
10442 .dimensions = {},
10443 .isIgnored = false,
10444 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10445 .numberOfConsumers = 1,
10446 .scale = 0.0f,
10447 .type = TestOperandType::FLOAT32,
10448 .zeroPoint = 0
10449 }, { // param29
10450 .channelQuant = {},
10451 .data = TestBuffer::createFromVector<int32_t>({-1}),
10452 .dimensions = {},
10453 .isIgnored = false,
10454 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10455 .numberOfConsumers = 1,
10456 .scale = 0.0f,
10457 .type = TestOperandType::INT32,
10458 .zeroPoint = 0
10459 }, { // param30
10460 .channelQuant = {},
10461 .data = TestBuffer::createFromVector<int32_t>({0}),
10462 .dimensions = {},
10463 .isIgnored = false,
10464 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10465 .numberOfConsumers = 1,
10466 .scale = 0.0f,
10467 .type = TestOperandType::INT32,
10468 .zeroPoint = 0
10469 }, { // param31
10470 .channelQuant = {},
10471 .data = TestBuffer::createFromVector<float>({0.4f}),
10472 .dimensions = {},
10473 .isIgnored = false,
10474 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10475 .numberOfConsumers = 1,
10476 .scale = 0.0f,
10477 .type = TestOperandType::FLOAT32,
10478 .zeroPoint = 0
10479 }, { // param32
10480 .channelQuant = {},
10481 .data = TestBuffer::createFromVector<float>({1.0f}),
10482 .dimensions = {},
10483 .isIgnored = false,
10484 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10485 .numberOfConsumers = 1,
10486 .scale = 0.0f,
10487 .type = TestOperandType::FLOAT32,
10488 .zeroPoint = 0
10489 }, { // param33
10490 .channelQuant = {},
10491 .data = TestBuffer::createFromVector<float>({0.3f}),
10492 .dimensions = {},
10493 .isIgnored = false,
10494 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10495 .numberOfConsumers = 1,
10496 .scale = 0.0f,
10497 .type = TestOperandType::FLOAT32,
10498 .zeroPoint = 0
10499 }, { // scoresOut1
10500 .channelQuant = {},
10501 .data = TestBuffer::createFromVector<float>({}),
10502 .dimensions = {0},
10503 .isIgnored = false,
10504 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10505 .numberOfConsumers = 0,
10506 .scale = 0.0f,
10507 .type = TestOperandType::TENSOR_FLOAT32,
10508 .zeroPoint = 0
10509 }, { // roiOut1
10510 .channelQuant = {},
10511 .data = TestBuffer::createFromVector<float>({}),
10512 .dimensions = {0, 4},
10513 .isIgnored = false,
10514 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10515 .numberOfConsumers = 1,
10516 .scale = 0.0f,
10517 .type = TestOperandType::TENSOR_FLOAT32,
10518 .zeroPoint = 0
10519 }, { // classesOut1
10520 .channelQuant = {},
10521 .data = TestBuffer::createFromVector<int32_t>({}),
10522 .dimensions = {0},
10523 .isIgnored = false,
10524 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10525 .numberOfConsumers = 0,
10526 .scale = 0.0f,
10527 .type = TestOperandType::TENSOR_INT32,
10528 .zeroPoint = 0
10529 }, { // batchSplitOut1
10530 .channelQuant = {},
10531 .data = TestBuffer::createFromVector<int32_t>({}),
10532 .dimensions = {0},
10533 .isIgnored = false,
10534 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10535 .numberOfConsumers = 1,
10536 .scale = 0.0f,
10537 .type = TestOperandType::TENSOR_INT32,
10538 .zeroPoint = 0
10539 }, { // in1
10540 .channelQuant = {},
10541 .data = TestBuffer::createFromVector<float>({1.0f}),
10542 .dimensions = {1, 1, 1, 1},
10543 .isIgnored = false,
10544 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10545 .numberOfConsumers = 1,
10546 .scale = 0.0f,
10547 .type = TestOperandType::TENSOR_FLOAT32,
10548 .zeroPoint = 0
10549 }, { // param34
10550 .channelQuant = {},
10551 .data = TestBuffer::createFromVector<int32_t>({2}),
10552 .dimensions = {},
10553 .isIgnored = false,
10554 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10555 .numberOfConsumers = 1,
10556 .scale = 0.0f,
10557 .type = TestOperandType::INT32,
10558 .zeroPoint = 0
10559 }, { // param35
10560 .channelQuant = {},
10561 .data = TestBuffer::createFromVector<int32_t>({2}),
10562 .dimensions = {},
10563 .isIgnored = false,
10564 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10565 .numberOfConsumers = 1,
10566 .scale = 0.0f,
10567 .type = TestOperandType::INT32,
10568 .zeroPoint = 0
10569 }, { // param36
10570 .channelQuant = {},
10571 .data = TestBuffer::createFromVector<float>({2.0f}),
10572 .dimensions = {},
10573 .isIgnored = false,
10574 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10575 .numberOfConsumers = 1,
10576 .scale = 0.0f,
10577 .type = TestOperandType::FLOAT32,
10578 .zeroPoint = 0
10579 }, { // param37
10580 .channelQuant = {},
10581 .data = TestBuffer::createFromVector<float>({2.0f}),
10582 .dimensions = {},
10583 .isIgnored = false,
10584 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10585 .numberOfConsumers = 1,
10586 .scale = 0.0f,
10587 .type = TestOperandType::FLOAT32,
10588 .zeroPoint = 0
10589 }, { // param38
10590 .channelQuant = {},
10591 .data = TestBuffer::createFromVector<int32_t>({4}),
10592 .dimensions = {},
10593 .isIgnored = false,
10594 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10595 .numberOfConsumers = 1,
10596 .scale = 0.0f,
10597 .type = TestOperandType::INT32,
10598 .zeroPoint = 0
10599 }, { // param39
10600 .channelQuant = {},
10601 .data = TestBuffer::createFromVector<int32_t>({4}),
10602 .dimensions = {},
10603 .isIgnored = false,
10604 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10605 .numberOfConsumers = 1,
10606 .scale = 0.0f,
10607 .type = TestOperandType::INT32,
10608 .zeroPoint = 0
10609 }, { // layout
10610 .channelQuant = {},
10611 .data = TestBuffer::createFromVector<bool8>({true}),
10612 .dimensions = {},
10613 .isIgnored = false,
10614 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10615 .numberOfConsumers = 2,
10616 .scale = 0.0f,
10617 .type = TestOperandType::BOOL,
10618 .zeroPoint = 0
10619 }, { // featureMap1
10620 .channelQuant = {},
10621 .data = TestBuffer::createFromVector<float>({}),
10622 .dimensions = {0, 1, 2, 2},
10623 .isIgnored = false,
10624 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10625 .numberOfConsumers = 1,
10626 .scale = 0.0f,
10627 .type = TestOperandType::TENSOR_FLOAT32,
10628 .zeroPoint = 0
10629 }, { // param40
10630 .channelQuant = {},
10631 .data = TestBuffer::createFromVector<float>({1.6f}),
10632 .dimensions = {},
10633 .isIgnored = false,
10634 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10635 .numberOfConsumers = 1,
10636 .scale = 0.0f,
10637 .type = TestOperandType::FLOAT32,
10638 .zeroPoint = 0
10639 }, { // param41
10640 .channelQuant = {},
10641 .data = TestBuffer::createFromVector<float>({1.6f}),
10642 .dimensions = {},
10643 .isIgnored = false,
10644 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10645 .numberOfConsumers = 1,
10646 .scale = 0.0f,
10647 .type = TestOperandType::FLOAT32,
10648 .zeroPoint = 0
10649 }, { // out1
10650 .channelQuant = {},
10651 .data = TestBuffer::createFromVector<float>({}),
10652 .dimensions = {0, 1, 3, 3},
10653 .isIgnored = false,
10654 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10655 .numberOfConsumers = 0,
10656 .scale = 0.0f,
10657 .type = TestOperandType::TENSOR_FLOAT32,
10658 .zeroPoint = 0
10659 }},
10660 .operations = {{
10661 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
10662 .outputs = {9, 10, 11, 12},
10663 .type = TestOperationType::BOX_WITH_NMS_LIMIT
10664 }, {
10665 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
10666 .outputs = {21},
10667 .type = TestOperationType::ROI_ALIGN
10668 }, {
10669 .inputs = {21, 22, 23, 20},
10670 .outputs = {24},
10671 .type = TestOperationType::RESIZE_BILINEAR
10672 }},
10673 .outputIndexes = {9, 11, 24}
10674 },
10675 .minSupportedVersion = TestHalVersion::UNKNOWN,
10676 .referenced = {}
10677 };
10678 return model;
10679 }
10680
10681 const auto dummy_test_model_zero_sized_nchw_relaxed_2 = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nchw_relaxed_2", get_test_model_zero_sized_nchw_relaxed_2());
10682
10683 } // namespace generated_tests::resize_bilinear_v1_2
10684
10685 namespace generated_tests::resize_bilinear_v1_2 {
10686
get_test_model_zero_sized_nchw_quant8_2()10687 const TestModel& get_test_model_zero_sized_nchw_quant8_2() {
10688 static TestModel model = {
10689 .expectFailure = false,
10690 .expectedMultinomialDistributionTolerance = 0,
10691 .isRelaxed = false,
10692 .main = { // zero_sized
10693 .inputIndexes = {13},
10694 .operands = {{ // scores1
10695 .channelQuant = {},
10696 .data = TestBuffer::createFromVector<uint8_t>({137, 129}),
10697 .dimensions = {1, 2},
10698 .isIgnored = false,
10699 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10700 .numberOfConsumers = 1,
10701 .scale = 0.1f,
10702 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
10703 .zeroPoint = 128
10704 }, { // roi1
10705 .channelQuant = {},
10706 .data = TestBuffer::createFromVector<uint16_t>({8, 8, 80, 80, 0, 0, 80, 80}),
10707 .dimensions = {1, 8},
10708 .isIgnored = false,
10709 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10710 .numberOfConsumers = 1,
10711 .scale = 0.125f,
10712 .type = TestOperandType::TENSOR_QUANT16_ASYMM,
10713 .zeroPoint = 0
10714 }, { // param27
10715 .channelQuant = {},
10716 .data = TestBuffer::createFromVector<int32_t>({0}),
10717 .dimensions = {1},
10718 .isIgnored = false,
10719 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10720 .numberOfConsumers = 1,
10721 .scale = 0.0f,
10722 .type = TestOperandType::TENSOR_INT32,
10723 .zeroPoint = 0
10724 }, { // param28
10725 .channelQuant = {},
10726 .data = TestBuffer::createFromVector<float>({0.3f}),
10727 .dimensions = {},
10728 .isIgnored = false,
10729 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10730 .numberOfConsumers = 1,
10731 .scale = 0.0f,
10732 .type = TestOperandType::FLOAT32,
10733 .zeroPoint = 0
10734 }, { // param29
10735 .channelQuant = {},
10736 .data = TestBuffer::createFromVector<int32_t>({-1}),
10737 .dimensions = {},
10738 .isIgnored = false,
10739 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10740 .numberOfConsumers = 1,
10741 .scale = 0.0f,
10742 .type = TestOperandType::INT32,
10743 .zeroPoint = 0
10744 }, { // param30
10745 .channelQuant = {},
10746 .data = TestBuffer::createFromVector<int32_t>({0}),
10747 .dimensions = {},
10748 .isIgnored = false,
10749 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10750 .numberOfConsumers = 1,
10751 .scale = 0.0f,
10752 .type = TestOperandType::INT32,
10753 .zeroPoint = 0
10754 }, { // param31
10755 .channelQuant = {},
10756 .data = TestBuffer::createFromVector<float>({0.4f}),
10757 .dimensions = {},
10758 .isIgnored = false,
10759 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10760 .numberOfConsumers = 1,
10761 .scale = 0.0f,
10762 .type = TestOperandType::FLOAT32,
10763 .zeroPoint = 0
10764 }, { // param32
10765 .channelQuant = {},
10766 .data = TestBuffer::createFromVector<float>({1.0f}),
10767 .dimensions = {},
10768 .isIgnored = false,
10769 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10770 .numberOfConsumers = 1,
10771 .scale = 0.0f,
10772 .type = TestOperandType::FLOAT32,
10773 .zeroPoint = 0
10774 }, { // param33
10775 .channelQuant = {},
10776 .data = TestBuffer::createFromVector<float>({0.3f}),
10777 .dimensions = {},
10778 .isIgnored = false,
10779 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10780 .numberOfConsumers = 1,
10781 .scale = 0.0f,
10782 .type = TestOperandType::FLOAT32,
10783 .zeroPoint = 0
10784 }, { // scoresOut1
10785 .channelQuant = {},
10786 .data = TestBuffer::createFromVector<uint8_t>({}),
10787 .dimensions = {0},
10788 .isIgnored = false,
10789 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10790 .numberOfConsumers = 0,
10791 .scale = 0.1f,
10792 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
10793 .zeroPoint = 128
10794 }, { // roiOut1
10795 .channelQuant = {},
10796 .data = TestBuffer::createFromVector<uint16_t>({}),
10797 .dimensions = {0, 4},
10798 .isIgnored = false,
10799 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10800 .numberOfConsumers = 1,
10801 .scale = 0.125f,
10802 .type = TestOperandType::TENSOR_QUANT16_ASYMM,
10803 .zeroPoint = 0
10804 }, { // classesOut1
10805 .channelQuant = {},
10806 .data = TestBuffer::createFromVector<int32_t>({}),
10807 .dimensions = {0},
10808 .isIgnored = false,
10809 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10810 .numberOfConsumers = 0,
10811 .scale = 0.0f,
10812 .type = TestOperandType::TENSOR_INT32,
10813 .zeroPoint = 0
10814 }, { // batchSplitOut1
10815 .channelQuant = {},
10816 .data = TestBuffer::createFromVector<int32_t>({}),
10817 .dimensions = {0},
10818 .isIgnored = false,
10819 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10820 .numberOfConsumers = 1,
10821 .scale = 0.0f,
10822 .type = TestOperandType::TENSOR_INT32,
10823 .zeroPoint = 0
10824 }, { // in1
10825 .channelQuant = {},
10826 .data = TestBuffer::createFromVector<uint8_t>({138}),
10827 .dimensions = {1, 1, 1, 1},
10828 .isIgnored = false,
10829 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
10830 .numberOfConsumers = 1,
10831 .scale = 0.1f,
10832 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
10833 .zeroPoint = 128
10834 }, { // param34
10835 .channelQuant = {},
10836 .data = TestBuffer::createFromVector<int32_t>({2}),
10837 .dimensions = {},
10838 .isIgnored = false,
10839 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10840 .numberOfConsumers = 1,
10841 .scale = 0.0f,
10842 .type = TestOperandType::INT32,
10843 .zeroPoint = 0
10844 }, { // param35
10845 .channelQuant = {},
10846 .data = TestBuffer::createFromVector<int32_t>({2}),
10847 .dimensions = {},
10848 .isIgnored = false,
10849 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10850 .numberOfConsumers = 1,
10851 .scale = 0.0f,
10852 .type = TestOperandType::INT32,
10853 .zeroPoint = 0
10854 }, { // param36
10855 .channelQuant = {},
10856 .data = TestBuffer::createFromVector<float>({2.0f}),
10857 .dimensions = {},
10858 .isIgnored = false,
10859 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10860 .numberOfConsumers = 1,
10861 .scale = 0.0f,
10862 .type = TestOperandType::FLOAT32,
10863 .zeroPoint = 0
10864 }, { // param37
10865 .channelQuant = {},
10866 .data = TestBuffer::createFromVector<float>({2.0f}),
10867 .dimensions = {},
10868 .isIgnored = false,
10869 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10870 .numberOfConsumers = 1,
10871 .scale = 0.0f,
10872 .type = TestOperandType::FLOAT32,
10873 .zeroPoint = 0
10874 }, { // param38
10875 .channelQuant = {},
10876 .data = TestBuffer::createFromVector<int32_t>({4}),
10877 .dimensions = {},
10878 .isIgnored = false,
10879 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10880 .numberOfConsumers = 1,
10881 .scale = 0.0f,
10882 .type = TestOperandType::INT32,
10883 .zeroPoint = 0
10884 }, { // param39
10885 .channelQuant = {},
10886 .data = TestBuffer::createFromVector<int32_t>({4}),
10887 .dimensions = {},
10888 .isIgnored = false,
10889 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10890 .numberOfConsumers = 1,
10891 .scale = 0.0f,
10892 .type = TestOperandType::INT32,
10893 .zeroPoint = 0
10894 }, { // layout
10895 .channelQuant = {},
10896 .data = TestBuffer::createFromVector<bool8>({true}),
10897 .dimensions = {},
10898 .isIgnored = false,
10899 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10900 .numberOfConsumers = 2,
10901 .scale = 0.0f,
10902 .type = TestOperandType::BOOL,
10903 .zeroPoint = 0
10904 }, { // featureMap1
10905 .channelQuant = {},
10906 .data = TestBuffer::createFromVector<uint8_t>({}),
10907 .dimensions = {0, 1, 2, 2},
10908 .isIgnored = false,
10909 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
10910 .numberOfConsumers = 1,
10911 .scale = 0.1f,
10912 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
10913 .zeroPoint = 128
10914 }, { // param40
10915 .channelQuant = {},
10916 .data = TestBuffer::createFromVector<float>({1.6f}),
10917 .dimensions = {},
10918 .isIgnored = false,
10919 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10920 .numberOfConsumers = 1,
10921 .scale = 0.0f,
10922 .type = TestOperandType::FLOAT32,
10923 .zeroPoint = 0
10924 }, { // param41
10925 .channelQuant = {},
10926 .data = TestBuffer::createFromVector<float>({1.6f}),
10927 .dimensions = {},
10928 .isIgnored = false,
10929 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10930 .numberOfConsumers = 1,
10931 .scale = 0.0f,
10932 .type = TestOperandType::FLOAT32,
10933 .zeroPoint = 0
10934 }, { // out1
10935 .channelQuant = {},
10936 .data = TestBuffer::createFromVector<uint8_t>({}),
10937 .dimensions = {0, 1, 3, 3},
10938 .isIgnored = false,
10939 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
10940 .numberOfConsumers = 0,
10941 .scale = 0.1f,
10942 .type = TestOperandType::TENSOR_QUANT8_ASYMM,
10943 .zeroPoint = 128
10944 }},
10945 .operations = {{
10946 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
10947 .outputs = {9, 10, 11, 12},
10948 .type = TestOperationType::BOX_WITH_NMS_LIMIT
10949 }, {
10950 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
10951 .outputs = {21},
10952 .type = TestOperationType::ROI_ALIGN
10953 }, {
10954 .inputs = {21, 22, 23, 20},
10955 .outputs = {24},
10956 .type = TestOperationType::RESIZE_BILINEAR
10957 }},
10958 .outputIndexes = {9, 11, 24}
10959 },
10960 .minSupportedVersion = TestHalVersion::V1_2,
10961 .referenced = {}
10962 };
10963 return model;
10964 }
10965
10966 const auto dummy_test_model_zero_sized_nchw_quant8_2 = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nchw_quant8_2", get_test_model_zero_sized_nchw_quant8_2());
10967
10968 } // namespace generated_tests::resize_bilinear_v1_2
10969
10970 namespace generated_tests::resize_bilinear_v1_2 {
10971
get_test_model_zero_sized_nchw_float16_2()10972 const TestModel& get_test_model_zero_sized_nchw_float16_2() {
10973 static TestModel model = {
10974 .expectFailure = false,
10975 .expectedMultinomialDistributionTolerance = 0,
10976 .isRelaxed = false,
10977 .main = { // zero_sized
10978 .inputIndexes = {13},
10979 .operands = {{ // scores1
10980 .channelQuant = {},
10981 .data = TestBuffer::createFromVector<_Float16>({0.8999999761581421f, 0.10000000149011612f}),
10982 .dimensions = {1, 2},
10983 .isIgnored = false,
10984 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10985 .numberOfConsumers = 1,
10986 .scale = 0.0f,
10987 .type = TestOperandType::TENSOR_FLOAT16,
10988 .zeroPoint = 0
10989 }, { // roi1
10990 .channelQuant = {},
10991 .data = TestBuffer::createFromVector<_Float16>({1.0f, 1.0f, 10.0f, 10.0f, 0.0f, 0.0f, 10.0f, 10.0f}),
10992 .dimensions = {1, 8},
10993 .isIgnored = false,
10994 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
10995 .numberOfConsumers = 1,
10996 .scale = 0.0f,
10997 .type = TestOperandType::TENSOR_FLOAT16,
10998 .zeroPoint = 0
10999 }, { // param27
11000 .channelQuant = {},
11001 .data = TestBuffer::createFromVector<int32_t>({0}),
11002 .dimensions = {1},
11003 .isIgnored = false,
11004 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11005 .numberOfConsumers = 1,
11006 .scale = 0.0f,
11007 .type = TestOperandType::TENSOR_INT32,
11008 .zeroPoint = 0
11009 }, { // param28
11010 .channelQuant = {},
11011 .data = TestBuffer::createFromVector<_Float16>({0.30000001192092896f}),
11012 .dimensions = {},
11013 .isIgnored = false,
11014 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11015 .numberOfConsumers = 1,
11016 .scale = 0.0f,
11017 .type = TestOperandType::FLOAT16,
11018 .zeroPoint = 0
11019 }, { // param29
11020 .channelQuant = {},
11021 .data = TestBuffer::createFromVector<int32_t>({-1}),
11022 .dimensions = {},
11023 .isIgnored = false,
11024 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11025 .numberOfConsumers = 1,
11026 .scale = 0.0f,
11027 .type = TestOperandType::INT32,
11028 .zeroPoint = 0
11029 }, { // param30
11030 .channelQuant = {},
11031 .data = TestBuffer::createFromVector<int32_t>({0}),
11032 .dimensions = {},
11033 .isIgnored = false,
11034 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11035 .numberOfConsumers = 1,
11036 .scale = 0.0f,
11037 .type = TestOperandType::INT32,
11038 .zeroPoint = 0
11039 }, { // param31
11040 .channelQuant = {},
11041 .data = TestBuffer::createFromVector<_Float16>({0.4000000059604645f}),
11042 .dimensions = {},
11043 .isIgnored = false,
11044 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11045 .numberOfConsumers = 1,
11046 .scale = 0.0f,
11047 .type = TestOperandType::FLOAT16,
11048 .zeroPoint = 0
11049 }, { // param32
11050 .channelQuant = {},
11051 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11052 .dimensions = {},
11053 .isIgnored = false,
11054 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11055 .numberOfConsumers = 1,
11056 .scale = 0.0f,
11057 .type = TestOperandType::FLOAT16,
11058 .zeroPoint = 0
11059 }, { // param33
11060 .channelQuant = {},
11061 .data = TestBuffer::createFromVector<_Float16>({0.30000001192092896f}),
11062 .dimensions = {},
11063 .isIgnored = false,
11064 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11065 .numberOfConsumers = 1,
11066 .scale = 0.0f,
11067 .type = TestOperandType::FLOAT16,
11068 .zeroPoint = 0
11069 }, { // scoresOut1
11070 .channelQuant = {},
11071 .data = TestBuffer::createFromVector<_Float16>({}),
11072 .dimensions = {0},
11073 .isIgnored = false,
11074 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11075 .numberOfConsumers = 0,
11076 .scale = 0.0f,
11077 .type = TestOperandType::TENSOR_FLOAT16,
11078 .zeroPoint = 0
11079 }, { // roiOut1
11080 .channelQuant = {},
11081 .data = TestBuffer::createFromVector<_Float16>({}),
11082 .dimensions = {0, 4},
11083 .isIgnored = false,
11084 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
11085 .numberOfConsumers = 1,
11086 .scale = 0.0f,
11087 .type = TestOperandType::TENSOR_FLOAT16,
11088 .zeroPoint = 0
11089 }, { // classesOut1
11090 .channelQuant = {},
11091 .data = TestBuffer::createFromVector<int32_t>({}),
11092 .dimensions = {0},
11093 .isIgnored = false,
11094 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11095 .numberOfConsumers = 0,
11096 .scale = 0.0f,
11097 .type = TestOperandType::TENSOR_INT32,
11098 .zeroPoint = 0
11099 }, { // batchSplitOut1
11100 .channelQuant = {},
11101 .data = TestBuffer::createFromVector<int32_t>({}),
11102 .dimensions = {0},
11103 .isIgnored = false,
11104 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
11105 .numberOfConsumers = 1,
11106 .scale = 0.0f,
11107 .type = TestOperandType::TENSOR_INT32,
11108 .zeroPoint = 0
11109 }, { // in1
11110 .channelQuant = {},
11111 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
11112 .dimensions = {1, 1, 1, 1},
11113 .isIgnored = false,
11114 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
11115 .numberOfConsumers = 1,
11116 .scale = 0.0f,
11117 .type = TestOperandType::TENSOR_FLOAT16,
11118 .zeroPoint = 0
11119 }, { // param34
11120 .channelQuant = {},
11121 .data = TestBuffer::createFromVector<int32_t>({2}),
11122 .dimensions = {},
11123 .isIgnored = false,
11124 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11125 .numberOfConsumers = 1,
11126 .scale = 0.0f,
11127 .type = TestOperandType::INT32,
11128 .zeroPoint = 0
11129 }, { // param35
11130 .channelQuant = {},
11131 .data = TestBuffer::createFromVector<int32_t>({2}),
11132 .dimensions = {},
11133 .isIgnored = false,
11134 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11135 .numberOfConsumers = 1,
11136 .scale = 0.0f,
11137 .type = TestOperandType::INT32,
11138 .zeroPoint = 0
11139 }, { // param36
11140 .channelQuant = {},
11141 .data = TestBuffer::createFromVector<_Float16>({2.0f}),
11142 .dimensions = {},
11143 .isIgnored = false,
11144 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11145 .numberOfConsumers = 1,
11146 .scale = 0.0f,
11147 .type = TestOperandType::FLOAT16,
11148 .zeroPoint = 0
11149 }, { // param37
11150 .channelQuant = {},
11151 .data = TestBuffer::createFromVector<_Float16>({2.0f}),
11152 .dimensions = {},
11153 .isIgnored = false,
11154 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11155 .numberOfConsumers = 1,
11156 .scale = 0.0f,
11157 .type = TestOperandType::FLOAT16,
11158 .zeroPoint = 0
11159 }, { // param38
11160 .channelQuant = {},
11161 .data = TestBuffer::createFromVector<int32_t>({4}),
11162 .dimensions = {},
11163 .isIgnored = false,
11164 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11165 .numberOfConsumers = 1,
11166 .scale = 0.0f,
11167 .type = TestOperandType::INT32,
11168 .zeroPoint = 0
11169 }, { // param39
11170 .channelQuant = {},
11171 .data = TestBuffer::createFromVector<int32_t>({4}),
11172 .dimensions = {},
11173 .isIgnored = false,
11174 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11175 .numberOfConsumers = 1,
11176 .scale = 0.0f,
11177 .type = TestOperandType::INT32,
11178 .zeroPoint = 0
11179 }, { // layout
11180 .channelQuant = {},
11181 .data = TestBuffer::createFromVector<bool8>({true}),
11182 .dimensions = {},
11183 .isIgnored = false,
11184 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11185 .numberOfConsumers = 2,
11186 .scale = 0.0f,
11187 .type = TestOperandType::BOOL,
11188 .zeroPoint = 0
11189 }, { // featureMap1
11190 .channelQuant = {},
11191 .data = TestBuffer::createFromVector<_Float16>({}),
11192 .dimensions = {0, 1, 2, 2},
11193 .isIgnored = false,
11194 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
11195 .numberOfConsumers = 1,
11196 .scale = 0.0f,
11197 .type = TestOperandType::TENSOR_FLOAT16,
11198 .zeroPoint = 0
11199 }, { // param40
11200 .channelQuant = {},
11201 .data = TestBuffer::createFromVector<_Float16>({1.600000023841858f}),
11202 .dimensions = {},
11203 .isIgnored = false,
11204 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11205 .numberOfConsumers = 1,
11206 .scale = 0.0f,
11207 .type = TestOperandType::FLOAT16,
11208 .zeroPoint = 0
11209 }, { // param41
11210 .channelQuant = {},
11211 .data = TestBuffer::createFromVector<_Float16>({1.600000023841858f}),
11212 .dimensions = {},
11213 .isIgnored = false,
11214 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
11215 .numberOfConsumers = 1,
11216 .scale = 0.0f,
11217 .type = TestOperandType::FLOAT16,
11218 .zeroPoint = 0
11219 }, { // out1
11220 .channelQuant = {},
11221 .data = TestBuffer::createFromVector<_Float16>({}),
11222 .dimensions = {0, 1, 3, 3},
11223 .isIgnored = false,
11224 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
11225 .numberOfConsumers = 0,
11226 .scale = 0.0f,
11227 .type = TestOperandType::TENSOR_FLOAT16,
11228 .zeroPoint = 0
11229 }},
11230 .operations = {{
11231 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8},
11232 .outputs = {9, 10, 11, 12},
11233 .type = TestOperationType::BOX_WITH_NMS_LIMIT
11234 }, {
11235 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20},
11236 .outputs = {21},
11237 .type = TestOperationType::ROI_ALIGN
11238 }, {
11239 .inputs = {21, 22, 23, 20},
11240 .outputs = {24},
11241 .type = TestOperationType::RESIZE_BILINEAR
11242 }},
11243 .outputIndexes = {9, 11, 24}
11244 },
11245 .minSupportedVersion = TestHalVersion::V1_2,
11246 .referenced = {}
11247 };
11248 return model;
11249 }
11250
11251 const auto dummy_test_model_zero_sized_nchw_float16_2 = TestModelManager::get().add("resize_bilinear_v1_2_zero_sized_nchw_float16_2", get_test_model_zero_sized_nchw_float16_2());
11252
11253 } // namespace generated_tests::resize_bilinear_v1_2
11254
11255