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