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