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