1 // Generated from elu.mod.py
2 // DO NOT EDIT
3 // clang-format off
4 #include "TestHarness.h"
5 using namespace test_helper;
6
7 namespace generated_tests::elu {
8
get_test_model_alpha_one()9 const TestModel& get_test_model_alpha_one() {
10 static TestModel model = {
11 .expectFailure = false,
12 .expectedMultinomialDistributionTolerance = 0,
13 .isRelaxed = false,
14 .main = {
15 .inputIndexes = {0},
16 .operands = {{ // input0
17 .channelQuant = {},
18 .data = TestBuffer::createFromVector<float>({0.0f, -6.0f, 2.0f, -4.0f, 3.0f, -2.0f, 10.0f, -0.1f}),
19 .dimensions = {8},
20 .isIgnored = false,
21 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22 .numberOfConsumers = 1,
23 .scale = 0.0f,
24 .type = TestOperandType::TENSOR_FLOAT32,
25 .zeroPoint = 0
26 }, { // alpha
27 .channelQuant = {},
28 .data = TestBuffer::createFromVector<float>({1.0f}),
29 .dimensions = {},
30 .isIgnored = false,
31 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
32 .numberOfConsumers = 1,
33 .scale = 0.0f,
34 .type = TestOperandType::FLOAT32,
35 .zeroPoint = 0
36 }, { // output0
37 .channelQuant = {},
38 .data = TestBuffer::createFromVector<float>({0.0f, -0.997521f, 2.0f, -0.981684f, 3.0f, -0.864665f, 10.0f, -0.0951626f}),
39 .dimensions = {8},
40 .isIgnored = false,
41 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
42 .numberOfConsumers = 0,
43 .scale = 0.0f,
44 .type = TestOperandType::TENSOR_FLOAT32,
45 .zeroPoint = 0
46 }},
47 .operations = {{
48 .inputs = {0, 1},
49 .outputs = {2},
50 .type = TestOperationType::ELU
51 }},
52 .outputIndexes = {2}
53 },
54 .minSupportedVersion = TestHalVersion::V1_3,
55 .referenced = {}
56 };
57 return model;
58 }
59
60 const auto dummy_test_model_alpha_one = TestModelManager::get().add("elu_alpha_one", get_test_model_alpha_one());
61
62 } // namespace generated_tests::elu
63
64 namespace generated_tests::elu {
65
get_test_model_alpha_one_all_inputs_as_internal()66 const TestModel& get_test_model_alpha_one_all_inputs_as_internal() {
67 static TestModel model = {
68 .expectFailure = false,
69 .expectedMultinomialDistributionTolerance = 0,
70 .isRelaxed = false,
71 .main = {
72 .inputIndexes = {3},
73 .operands = {{ // input0
74 .channelQuant = {},
75 .data = TestBuffer::createFromVector<float>({}),
76 .dimensions = {8},
77 .isIgnored = false,
78 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
79 .numberOfConsumers = 1,
80 .scale = 0.0f,
81 .type = TestOperandType::TENSOR_FLOAT32,
82 .zeroPoint = 0
83 }, { // alpha
84 .channelQuant = {},
85 .data = TestBuffer::createFromVector<float>({1.0f}),
86 .dimensions = {},
87 .isIgnored = false,
88 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
89 .numberOfConsumers = 1,
90 .scale = 0.0f,
91 .type = TestOperandType::FLOAT32,
92 .zeroPoint = 0
93 }, { // output0
94 .channelQuant = {},
95 .data = TestBuffer::createFromVector<float>({0.0f, -0.997521f, 2.0f, -0.981684f, 3.0f, -0.864665f, 10.0f, -0.0951626f}),
96 .dimensions = {8},
97 .isIgnored = false,
98 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
99 .numberOfConsumers = 0,
100 .scale = 0.0f,
101 .type = TestOperandType::TENSOR_FLOAT32,
102 .zeroPoint = 0
103 }, { // input0_new
104 .channelQuant = {},
105 .data = TestBuffer::createFromVector<float>({0.0f, -6.0f, 2.0f, -4.0f, 3.0f, -2.0f, 10.0f, -0.1f}),
106 .dimensions = {8},
107 .isIgnored = false,
108 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
109 .numberOfConsumers = 1,
110 .scale = 0.0f,
111 .type = TestOperandType::TENSOR_FLOAT32,
112 .zeroPoint = 0
113 }, { // placeholder
114 .channelQuant = {},
115 .data = TestBuffer::createFromVector<float>({0.0f}),
116 .dimensions = {1},
117 .isIgnored = false,
118 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
119 .numberOfConsumers = 1,
120 .scale = 0.0f,
121 .type = TestOperandType::TENSOR_FLOAT32,
122 .zeroPoint = 0
123 }, { // param
124 .channelQuant = {},
125 .data = TestBuffer::createFromVector<int32_t>({0}),
126 .dimensions = {},
127 .isIgnored = false,
128 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
129 .numberOfConsumers = 1,
130 .scale = 0.0f,
131 .type = TestOperandType::INT32,
132 .zeroPoint = 0
133 }},
134 .operations = {{
135 .inputs = {3, 4, 5},
136 .outputs = {0},
137 .type = TestOperationType::ADD
138 }, {
139 .inputs = {0, 1},
140 .outputs = {2},
141 .type = TestOperationType::ELU
142 }},
143 .outputIndexes = {2}
144 },
145 .minSupportedVersion = TestHalVersion::V1_3,
146 .referenced = {}
147 };
148 return model;
149 }
150
151 const auto dummy_test_model_alpha_one_all_inputs_as_internal = TestModelManager::get().add("elu_alpha_one_all_inputs_as_internal", get_test_model_alpha_one_all_inputs_as_internal());
152
153 } // namespace generated_tests::elu
154
155 namespace generated_tests::elu {
156
get_test_model_alpha_one_float16()157 const TestModel& get_test_model_alpha_one_float16() {
158 static TestModel model = {
159 .expectFailure = false,
160 .expectedMultinomialDistributionTolerance = 0,
161 .isRelaxed = false,
162 .main = {
163 .inputIndexes = {0},
164 .operands = {{ // input0
165 .channelQuant = {},
166 .data = TestBuffer::createFromVector<_Float16>({0.0f, -6.0f, 2.0f, -4.0f, 3.0f, -2.0f, 10.0f, -0.10000000149011612f}),
167 .dimensions = {8},
168 .isIgnored = false,
169 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
170 .numberOfConsumers = 1,
171 .scale = 0.0f,
172 .type = TestOperandType::TENSOR_FLOAT16,
173 .zeroPoint = 0
174 }, { // alpha
175 .channelQuant = {},
176 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
177 .dimensions = {},
178 .isIgnored = false,
179 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
180 .numberOfConsumers = 1,
181 .scale = 0.0f,
182 .type = TestOperandType::FLOAT16,
183 .zeroPoint = 0
184 }, { // output0
185 .channelQuant = {},
186 .data = TestBuffer::createFromVector<_Float16>({0.0f, -0.9975209832191467f, 2.0f, -0.9816840291023254f, 3.0f, -0.8646649718284607f, 10.0f, -0.09516260027885437f}),
187 .dimensions = {8},
188 .isIgnored = false,
189 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
190 .numberOfConsumers = 0,
191 .scale = 0.0f,
192 .type = TestOperandType::TENSOR_FLOAT16,
193 .zeroPoint = 0
194 }},
195 .operations = {{
196 .inputs = {0, 1},
197 .outputs = {2},
198 .type = TestOperationType::ELU
199 }},
200 .outputIndexes = {2}
201 },
202 .minSupportedVersion = TestHalVersion::V1_3,
203 .referenced = {}
204 };
205 return model;
206 }
207
208 const auto dummy_test_model_alpha_one_float16 = TestModelManager::get().add("elu_alpha_one_float16", get_test_model_alpha_one_float16());
209
210 } // namespace generated_tests::elu
211
212 namespace generated_tests::elu {
213
get_test_model_alpha_one_float16_all_inputs_as_internal()214 const TestModel& get_test_model_alpha_one_float16_all_inputs_as_internal() {
215 static TestModel model = {
216 .expectFailure = false,
217 .expectedMultinomialDistributionTolerance = 0,
218 .isRelaxed = false,
219 .main = {
220 .inputIndexes = {3},
221 .operands = {{ // input0
222 .channelQuant = {},
223 .data = TestBuffer::createFromVector<_Float16>({}),
224 .dimensions = {8},
225 .isIgnored = false,
226 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
227 .numberOfConsumers = 1,
228 .scale = 0.0f,
229 .type = TestOperandType::TENSOR_FLOAT16,
230 .zeroPoint = 0
231 }, { // alpha
232 .channelQuant = {},
233 .data = TestBuffer::createFromVector<_Float16>({1.0f}),
234 .dimensions = {},
235 .isIgnored = false,
236 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
237 .numberOfConsumers = 1,
238 .scale = 0.0f,
239 .type = TestOperandType::FLOAT16,
240 .zeroPoint = 0
241 }, { // output0
242 .channelQuant = {},
243 .data = TestBuffer::createFromVector<_Float16>({0.0f, -0.9975209832191467f, 2.0f, -0.9816840291023254f, 3.0f, -0.8646649718284607f, 10.0f, -0.09516260027885437f}),
244 .dimensions = {8},
245 .isIgnored = false,
246 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
247 .numberOfConsumers = 0,
248 .scale = 0.0f,
249 .type = TestOperandType::TENSOR_FLOAT16,
250 .zeroPoint = 0
251 }, { // input0_new
252 .channelQuant = {},
253 .data = TestBuffer::createFromVector<_Float16>({0.0f, -6.0f, 2.0f, -4.0f, 3.0f, -2.0f, 10.0f, -0.10000000149011612f}),
254 .dimensions = {8},
255 .isIgnored = false,
256 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
257 .numberOfConsumers = 1,
258 .scale = 0.0f,
259 .type = TestOperandType::TENSOR_FLOAT16,
260 .zeroPoint = 0
261 }, { // placeholder1
262 .channelQuant = {},
263 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
264 .dimensions = {1},
265 .isIgnored = false,
266 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
267 .numberOfConsumers = 1,
268 .scale = 0.0f,
269 .type = TestOperandType::TENSOR_FLOAT16,
270 .zeroPoint = 0
271 }, { // param1
272 .channelQuant = {},
273 .data = TestBuffer::createFromVector<int32_t>({0}),
274 .dimensions = {},
275 .isIgnored = false,
276 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
277 .numberOfConsumers = 1,
278 .scale = 0.0f,
279 .type = TestOperandType::INT32,
280 .zeroPoint = 0
281 }},
282 .operations = {{
283 .inputs = {3, 4, 5},
284 .outputs = {0},
285 .type = TestOperationType::ADD
286 }, {
287 .inputs = {0, 1},
288 .outputs = {2},
289 .type = TestOperationType::ELU
290 }},
291 .outputIndexes = {2}
292 },
293 .minSupportedVersion = TestHalVersion::V1_3,
294 .referenced = {}
295 };
296 return model;
297 }
298
299 const auto dummy_test_model_alpha_one_float16_all_inputs_as_internal = TestModelManager::get().add("elu_alpha_one_float16_all_inputs_as_internal", get_test_model_alpha_one_float16_all_inputs_as_internal());
300
301 } // namespace generated_tests::elu
302
303 namespace generated_tests::elu {
304
get_test_model_alpha_one_relaxed()305 const TestModel& get_test_model_alpha_one_relaxed() {
306 static TestModel model = {
307 .expectFailure = false,
308 .expectedMultinomialDistributionTolerance = 0,
309 .isRelaxed = true,
310 .main = {
311 .inputIndexes = {0},
312 .operands = {{ // input0
313 .channelQuant = {},
314 .data = TestBuffer::createFromVector<float>({0.0f, -6.0f, 2.0f, -4.0f, 3.0f, -2.0f, 10.0f, -0.1f}),
315 .dimensions = {8},
316 .isIgnored = false,
317 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
318 .numberOfConsumers = 1,
319 .scale = 0.0f,
320 .type = TestOperandType::TENSOR_FLOAT32,
321 .zeroPoint = 0
322 }, { // alpha
323 .channelQuant = {},
324 .data = TestBuffer::createFromVector<float>({1.0f}),
325 .dimensions = {},
326 .isIgnored = false,
327 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
328 .numberOfConsumers = 1,
329 .scale = 0.0f,
330 .type = TestOperandType::FLOAT32,
331 .zeroPoint = 0
332 }, { // output0
333 .channelQuant = {},
334 .data = TestBuffer::createFromVector<float>({0.0f, -0.997521f, 2.0f, -0.981684f, 3.0f, -0.864665f, 10.0f, -0.0951626f}),
335 .dimensions = {8},
336 .isIgnored = false,
337 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
338 .numberOfConsumers = 0,
339 .scale = 0.0f,
340 .type = TestOperandType::TENSOR_FLOAT32,
341 .zeroPoint = 0
342 }},
343 .operations = {{
344 .inputs = {0, 1},
345 .outputs = {2},
346 .type = TestOperationType::ELU
347 }},
348 .outputIndexes = {2}
349 },
350 .minSupportedVersion = TestHalVersion::UNKNOWN,
351 .referenced = {}
352 };
353 return model;
354 }
355
356 const auto dummy_test_model_alpha_one_relaxed = TestModelManager::get().add("elu_alpha_one_relaxed", get_test_model_alpha_one_relaxed());
357
358 } // namespace generated_tests::elu
359
360 namespace generated_tests::elu {
361
get_test_model_alpha_one_relaxed_all_inputs_as_internal()362 const TestModel& get_test_model_alpha_one_relaxed_all_inputs_as_internal() {
363 static TestModel model = {
364 .expectFailure = false,
365 .expectedMultinomialDistributionTolerance = 0,
366 .isRelaxed = true,
367 .main = {
368 .inputIndexes = {3},
369 .operands = {{ // input0
370 .channelQuant = {},
371 .data = TestBuffer::createFromVector<float>({}),
372 .dimensions = {8},
373 .isIgnored = false,
374 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
375 .numberOfConsumers = 1,
376 .scale = 0.0f,
377 .type = TestOperandType::TENSOR_FLOAT32,
378 .zeroPoint = 0
379 }, { // alpha
380 .channelQuant = {},
381 .data = TestBuffer::createFromVector<float>({1.0f}),
382 .dimensions = {},
383 .isIgnored = false,
384 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
385 .numberOfConsumers = 1,
386 .scale = 0.0f,
387 .type = TestOperandType::FLOAT32,
388 .zeroPoint = 0
389 }, { // output0
390 .channelQuant = {},
391 .data = TestBuffer::createFromVector<float>({0.0f, -0.997521f, 2.0f, -0.981684f, 3.0f, -0.864665f, 10.0f, -0.0951626f}),
392 .dimensions = {8},
393 .isIgnored = false,
394 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
395 .numberOfConsumers = 0,
396 .scale = 0.0f,
397 .type = TestOperandType::TENSOR_FLOAT32,
398 .zeroPoint = 0
399 }, { // input0_new
400 .channelQuant = {},
401 .data = TestBuffer::createFromVector<float>({0.0f, -6.0f, 2.0f, -4.0f, 3.0f, -2.0f, 10.0f, -0.1f}),
402 .dimensions = {8},
403 .isIgnored = false,
404 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
405 .numberOfConsumers = 1,
406 .scale = 0.0f,
407 .type = TestOperandType::TENSOR_FLOAT32,
408 .zeroPoint = 0
409 }, { // placeholder2
410 .channelQuant = {},
411 .data = TestBuffer::createFromVector<float>({0.0f}),
412 .dimensions = {1},
413 .isIgnored = false,
414 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
415 .numberOfConsumers = 1,
416 .scale = 0.0f,
417 .type = TestOperandType::TENSOR_FLOAT32,
418 .zeroPoint = 0
419 }, { // param2
420 .channelQuant = {},
421 .data = TestBuffer::createFromVector<int32_t>({0}),
422 .dimensions = {},
423 .isIgnored = false,
424 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
425 .numberOfConsumers = 1,
426 .scale = 0.0f,
427 .type = TestOperandType::INT32,
428 .zeroPoint = 0
429 }},
430 .operations = {{
431 .inputs = {3, 4, 5},
432 .outputs = {0},
433 .type = TestOperationType::ADD
434 }, {
435 .inputs = {0, 1},
436 .outputs = {2},
437 .type = TestOperationType::ELU
438 }},
439 .outputIndexes = {2}
440 },
441 .minSupportedVersion = TestHalVersion::UNKNOWN,
442 .referenced = {}
443 };
444 return model;
445 }
446
447 const auto dummy_test_model_alpha_one_relaxed_all_inputs_as_internal = TestModelManager::get().add("elu_alpha_one_relaxed_all_inputs_as_internal", get_test_model_alpha_one_relaxed_all_inputs_as_internal());
448
449 } // namespace generated_tests::elu
450
451 namespace generated_tests::elu {
452
get_test_model_alpha01()453 const TestModel& get_test_model_alpha01() {
454 static TestModel model = {
455 .expectFailure = false,
456 .expectedMultinomialDistributionTolerance = 0,
457 .isRelaxed = false,
458 .main = {
459 .inputIndexes = {0},
460 .operands = {{ // input01
461 .channelQuant = {},
462 .data = TestBuffer::createFromVector<float>({-0.2f, -0.1f, 0.0f, 0.1f}),
463 .dimensions = {2, 2},
464 .isIgnored = false,
465 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
466 .numberOfConsumers = 1,
467 .scale = 0.0f,
468 .type = TestOperandType::TENSOR_FLOAT32,
469 .zeroPoint = 0
470 }, { // alpha1
471 .channelQuant = {},
472 .data = TestBuffer::createFromVector<float>({0.1f}),
473 .dimensions = {},
474 .isIgnored = false,
475 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
476 .numberOfConsumers = 1,
477 .scale = 0.0f,
478 .type = TestOperandType::FLOAT32,
479 .zeroPoint = 0
480 }, { // output01
481 .channelQuant = {},
482 .data = TestBuffer::createFromVector<float>({-0.018127f, -0.009516f, 0.0f, 0.1f}),
483 .dimensions = {2, 2},
484 .isIgnored = false,
485 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
486 .numberOfConsumers = 0,
487 .scale = 0.0f,
488 .type = TestOperandType::TENSOR_FLOAT32,
489 .zeroPoint = 0
490 }},
491 .operations = {{
492 .inputs = {0, 1},
493 .outputs = {2},
494 .type = TestOperationType::ELU
495 }},
496 .outputIndexes = {2}
497 },
498 .minSupportedVersion = TestHalVersion::V1_3,
499 .referenced = {}
500 };
501 return model;
502 }
503
504 const auto dummy_test_model_alpha01 = TestModelManager::get().add("elu_alpha01", get_test_model_alpha01());
505
506 } // namespace generated_tests::elu
507
508 namespace generated_tests::elu {
509
get_test_model_alpha01_all_inputs_as_internal()510 const TestModel& get_test_model_alpha01_all_inputs_as_internal() {
511 static TestModel model = {
512 .expectFailure = false,
513 .expectedMultinomialDistributionTolerance = 0,
514 .isRelaxed = false,
515 .main = {
516 .inputIndexes = {3},
517 .operands = {{ // input01
518 .channelQuant = {},
519 .data = TestBuffer::createFromVector<float>({}),
520 .dimensions = {2, 2},
521 .isIgnored = false,
522 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
523 .numberOfConsumers = 1,
524 .scale = 0.0f,
525 .type = TestOperandType::TENSOR_FLOAT32,
526 .zeroPoint = 0
527 }, { // alpha1
528 .channelQuant = {},
529 .data = TestBuffer::createFromVector<float>({0.1f}),
530 .dimensions = {},
531 .isIgnored = false,
532 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
533 .numberOfConsumers = 1,
534 .scale = 0.0f,
535 .type = TestOperandType::FLOAT32,
536 .zeroPoint = 0
537 }, { // output01
538 .channelQuant = {},
539 .data = TestBuffer::createFromVector<float>({-0.018127f, -0.009516f, 0.0f, 0.1f}),
540 .dimensions = {2, 2},
541 .isIgnored = false,
542 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
543 .numberOfConsumers = 0,
544 .scale = 0.0f,
545 .type = TestOperandType::TENSOR_FLOAT32,
546 .zeroPoint = 0
547 }, { // input01_new
548 .channelQuant = {},
549 .data = TestBuffer::createFromVector<float>({-0.2f, -0.1f, 0.0f, 0.1f}),
550 .dimensions = {2, 2},
551 .isIgnored = false,
552 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
553 .numberOfConsumers = 1,
554 .scale = 0.0f,
555 .type = TestOperandType::TENSOR_FLOAT32,
556 .zeroPoint = 0
557 }, { // placeholder3
558 .channelQuant = {},
559 .data = TestBuffer::createFromVector<float>({0.0f}),
560 .dimensions = {1},
561 .isIgnored = false,
562 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
563 .numberOfConsumers = 1,
564 .scale = 0.0f,
565 .type = TestOperandType::TENSOR_FLOAT32,
566 .zeroPoint = 0
567 }, { // param3
568 .channelQuant = {},
569 .data = TestBuffer::createFromVector<int32_t>({0}),
570 .dimensions = {},
571 .isIgnored = false,
572 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
573 .numberOfConsumers = 1,
574 .scale = 0.0f,
575 .type = TestOperandType::INT32,
576 .zeroPoint = 0
577 }},
578 .operations = {{
579 .inputs = {3, 4, 5},
580 .outputs = {0},
581 .type = TestOperationType::ADD
582 }, {
583 .inputs = {0, 1},
584 .outputs = {2},
585 .type = TestOperationType::ELU
586 }},
587 .outputIndexes = {2}
588 },
589 .minSupportedVersion = TestHalVersion::V1_3,
590 .referenced = {}
591 };
592 return model;
593 }
594
595 const auto dummy_test_model_alpha01_all_inputs_as_internal = TestModelManager::get().add("elu_alpha01_all_inputs_as_internal", get_test_model_alpha01_all_inputs_as_internal());
596
597 } // namespace generated_tests::elu
598
599 namespace generated_tests::elu {
600
get_test_model_alpha01_float16()601 const TestModel& get_test_model_alpha01_float16() {
602 static TestModel model = {
603 .expectFailure = false,
604 .expectedMultinomialDistributionTolerance = 0,
605 .isRelaxed = false,
606 .main = {
607 .inputIndexes = {0},
608 .operands = {{ // input01
609 .channelQuant = {},
610 .data = TestBuffer::createFromVector<_Float16>({-0.20000000298023224f, -0.10000000149011612f, 0.0f, 0.10000000149011612f}),
611 .dimensions = {2, 2},
612 .isIgnored = false,
613 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
614 .numberOfConsumers = 1,
615 .scale = 0.0f,
616 .type = TestOperandType::TENSOR_FLOAT16,
617 .zeroPoint = 0
618 }, { // alpha1
619 .channelQuant = {},
620 .data = TestBuffer::createFromVector<_Float16>({0.10000000149011612f}),
621 .dimensions = {},
622 .isIgnored = false,
623 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
624 .numberOfConsumers = 1,
625 .scale = 0.0f,
626 .type = TestOperandType::FLOAT16,
627 .zeroPoint = 0
628 }, { // output01
629 .channelQuant = {},
630 .data = TestBuffer::createFromVector<_Float16>({-0.018126999959349632f, -0.00951599981635809f, 0.0f, 0.10000000149011612f}),
631 .dimensions = {2, 2},
632 .isIgnored = false,
633 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
634 .numberOfConsumers = 0,
635 .scale = 0.0f,
636 .type = TestOperandType::TENSOR_FLOAT16,
637 .zeroPoint = 0
638 }},
639 .operations = {{
640 .inputs = {0, 1},
641 .outputs = {2},
642 .type = TestOperationType::ELU
643 }},
644 .outputIndexes = {2}
645 },
646 .minSupportedVersion = TestHalVersion::V1_3,
647 .referenced = {}
648 };
649 return model;
650 }
651
652 const auto dummy_test_model_alpha01_float16 = TestModelManager::get().add("elu_alpha01_float16", get_test_model_alpha01_float16());
653
654 } // namespace generated_tests::elu
655
656 namespace generated_tests::elu {
657
get_test_model_alpha01_float16_all_inputs_as_internal()658 const TestModel& get_test_model_alpha01_float16_all_inputs_as_internal() {
659 static TestModel model = {
660 .expectFailure = false,
661 .expectedMultinomialDistributionTolerance = 0,
662 .isRelaxed = false,
663 .main = {
664 .inputIndexes = {3},
665 .operands = {{ // input01
666 .channelQuant = {},
667 .data = TestBuffer::createFromVector<_Float16>({}),
668 .dimensions = {2, 2},
669 .isIgnored = false,
670 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
671 .numberOfConsumers = 1,
672 .scale = 0.0f,
673 .type = TestOperandType::TENSOR_FLOAT16,
674 .zeroPoint = 0
675 }, { // alpha1
676 .channelQuant = {},
677 .data = TestBuffer::createFromVector<_Float16>({0.10000000149011612f}),
678 .dimensions = {},
679 .isIgnored = false,
680 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
681 .numberOfConsumers = 1,
682 .scale = 0.0f,
683 .type = TestOperandType::FLOAT16,
684 .zeroPoint = 0
685 }, { // output01
686 .channelQuant = {},
687 .data = TestBuffer::createFromVector<_Float16>({-0.018126999959349632f, -0.00951599981635809f, 0.0f, 0.10000000149011612f}),
688 .dimensions = {2, 2},
689 .isIgnored = false,
690 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
691 .numberOfConsumers = 0,
692 .scale = 0.0f,
693 .type = TestOperandType::TENSOR_FLOAT16,
694 .zeroPoint = 0
695 }, { // input01_new
696 .channelQuant = {},
697 .data = TestBuffer::createFromVector<_Float16>({-0.20000000298023224f, -0.10000000149011612f, 0.0f, 0.10000000149011612f}),
698 .dimensions = {2, 2},
699 .isIgnored = false,
700 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
701 .numberOfConsumers = 1,
702 .scale = 0.0f,
703 .type = TestOperandType::TENSOR_FLOAT16,
704 .zeroPoint = 0
705 }, { // placeholder4
706 .channelQuant = {},
707 .data = TestBuffer::createFromVector<_Float16>({0.0f}),
708 .dimensions = {1},
709 .isIgnored = false,
710 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
711 .numberOfConsumers = 1,
712 .scale = 0.0f,
713 .type = TestOperandType::TENSOR_FLOAT16,
714 .zeroPoint = 0
715 }, { // param4
716 .channelQuant = {},
717 .data = TestBuffer::createFromVector<int32_t>({0}),
718 .dimensions = {},
719 .isIgnored = false,
720 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
721 .numberOfConsumers = 1,
722 .scale = 0.0f,
723 .type = TestOperandType::INT32,
724 .zeroPoint = 0
725 }},
726 .operations = {{
727 .inputs = {3, 4, 5},
728 .outputs = {0},
729 .type = TestOperationType::ADD
730 }, {
731 .inputs = {0, 1},
732 .outputs = {2},
733 .type = TestOperationType::ELU
734 }},
735 .outputIndexes = {2}
736 },
737 .minSupportedVersion = TestHalVersion::V1_3,
738 .referenced = {}
739 };
740 return model;
741 }
742
743 const auto dummy_test_model_alpha01_float16_all_inputs_as_internal = TestModelManager::get().add("elu_alpha01_float16_all_inputs_as_internal", get_test_model_alpha01_float16_all_inputs_as_internal());
744
745 } // namespace generated_tests::elu
746
747 namespace generated_tests::elu {
748
get_test_model_alpha01_relaxed()749 const TestModel& get_test_model_alpha01_relaxed() {
750 static TestModel model = {
751 .expectFailure = false,
752 .expectedMultinomialDistributionTolerance = 0,
753 .isRelaxed = true,
754 .main = {
755 .inputIndexes = {0},
756 .operands = {{ // input01
757 .channelQuant = {},
758 .data = TestBuffer::createFromVector<float>({-0.2f, -0.1f, 0.0f, 0.1f}),
759 .dimensions = {2, 2},
760 .isIgnored = false,
761 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
762 .numberOfConsumers = 1,
763 .scale = 0.0f,
764 .type = TestOperandType::TENSOR_FLOAT32,
765 .zeroPoint = 0
766 }, { // alpha1
767 .channelQuant = {},
768 .data = TestBuffer::createFromVector<float>({0.1f}),
769 .dimensions = {},
770 .isIgnored = false,
771 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
772 .numberOfConsumers = 1,
773 .scale = 0.0f,
774 .type = TestOperandType::FLOAT32,
775 .zeroPoint = 0
776 }, { // output01
777 .channelQuant = {},
778 .data = TestBuffer::createFromVector<float>({-0.018127f, -0.009516f, 0.0f, 0.1f}),
779 .dimensions = {2, 2},
780 .isIgnored = false,
781 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
782 .numberOfConsumers = 0,
783 .scale = 0.0f,
784 .type = TestOperandType::TENSOR_FLOAT32,
785 .zeroPoint = 0
786 }},
787 .operations = {{
788 .inputs = {0, 1},
789 .outputs = {2},
790 .type = TestOperationType::ELU
791 }},
792 .outputIndexes = {2}
793 },
794 .minSupportedVersion = TestHalVersion::UNKNOWN,
795 .referenced = {}
796 };
797 return model;
798 }
799
800 const auto dummy_test_model_alpha01_relaxed = TestModelManager::get().add("elu_alpha01_relaxed", get_test_model_alpha01_relaxed());
801
802 } // namespace generated_tests::elu
803
804 namespace generated_tests::elu {
805
get_test_model_alpha01_relaxed_all_inputs_as_internal()806 const TestModel& get_test_model_alpha01_relaxed_all_inputs_as_internal() {
807 static TestModel model = {
808 .expectFailure = false,
809 .expectedMultinomialDistributionTolerance = 0,
810 .isRelaxed = true,
811 .main = {
812 .inputIndexes = {3},
813 .operands = {{ // input01
814 .channelQuant = {},
815 .data = TestBuffer::createFromVector<float>({}),
816 .dimensions = {2, 2},
817 .isIgnored = false,
818 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
819 .numberOfConsumers = 1,
820 .scale = 0.0f,
821 .type = TestOperandType::TENSOR_FLOAT32,
822 .zeroPoint = 0
823 }, { // alpha1
824 .channelQuant = {},
825 .data = TestBuffer::createFromVector<float>({0.1f}),
826 .dimensions = {},
827 .isIgnored = false,
828 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
829 .numberOfConsumers = 1,
830 .scale = 0.0f,
831 .type = TestOperandType::FLOAT32,
832 .zeroPoint = 0
833 }, { // output01
834 .channelQuant = {},
835 .data = TestBuffer::createFromVector<float>({-0.018127f, -0.009516f, 0.0f, 0.1f}),
836 .dimensions = {2, 2},
837 .isIgnored = false,
838 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
839 .numberOfConsumers = 0,
840 .scale = 0.0f,
841 .type = TestOperandType::TENSOR_FLOAT32,
842 .zeroPoint = 0
843 }, { // input01_new
844 .channelQuant = {},
845 .data = TestBuffer::createFromVector<float>({-0.2f, -0.1f, 0.0f, 0.1f}),
846 .dimensions = {2, 2},
847 .isIgnored = false,
848 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
849 .numberOfConsumers = 1,
850 .scale = 0.0f,
851 .type = TestOperandType::TENSOR_FLOAT32,
852 .zeroPoint = 0
853 }, { // placeholder5
854 .channelQuant = {},
855 .data = TestBuffer::createFromVector<float>({0.0f}),
856 .dimensions = {1},
857 .isIgnored = false,
858 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
859 .numberOfConsumers = 1,
860 .scale = 0.0f,
861 .type = TestOperandType::TENSOR_FLOAT32,
862 .zeroPoint = 0
863 }, { // param5
864 .channelQuant = {},
865 .data = TestBuffer::createFromVector<int32_t>({0}),
866 .dimensions = {},
867 .isIgnored = false,
868 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
869 .numberOfConsumers = 1,
870 .scale = 0.0f,
871 .type = TestOperandType::INT32,
872 .zeroPoint = 0
873 }},
874 .operations = {{
875 .inputs = {3, 4, 5},
876 .outputs = {0},
877 .type = TestOperationType::ADD
878 }, {
879 .inputs = {0, 1},
880 .outputs = {2},
881 .type = TestOperationType::ELU
882 }},
883 .outputIndexes = {2}
884 },
885 .minSupportedVersion = TestHalVersion::UNKNOWN,
886 .referenced = {}
887 };
888 return model;
889 }
890
891 const auto dummy_test_model_alpha01_relaxed_all_inputs_as_internal = TestModelManager::get().add("elu_alpha01_relaxed_all_inputs_as_internal", get_test_model_alpha01_relaxed_all_inputs_as_internal());
892
893 } // namespace generated_tests::elu
894
895 namespace generated_tests::elu {
896
get_test_model_alpha10()897 const TestModel& get_test_model_alpha10() {
898 static TestModel model = {
899 .expectFailure = false,
900 .expectedMultinomialDistributionTolerance = 0,
901 .isRelaxed = false,
902 .main = {
903 .inputIndexes = {0},
904 .operands = {{ // input02
905 .channelQuant = {},
906 .data = TestBuffer::createFromVector<float>({-10.0f, -5.0f, 0.0f, 5.0f}),
907 .dimensions = {2, 1, 1, 1, 2},
908 .isIgnored = false,
909 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
910 .numberOfConsumers = 1,
911 .scale = 0.0f,
912 .type = TestOperandType::TENSOR_FLOAT32,
913 .zeroPoint = 0
914 }, { // alpha2
915 .channelQuant = {},
916 .data = TestBuffer::createFromVector<float>({10.0f}),
917 .dimensions = {},
918 .isIgnored = false,
919 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
920 .numberOfConsumers = 1,
921 .scale = 0.0f,
922 .type = TestOperandType::FLOAT32,
923 .zeroPoint = 0
924 }, { // output02
925 .channelQuant = {},
926 .data = TestBuffer::createFromVector<float>({-9.999546f, -9.93262f, 0.0f, 5.0f}),
927 .dimensions = {2, 1, 1, 1, 2},
928 .isIgnored = false,
929 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
930 .numberOfConsumers = 0,
931 .scale = 0.0f,
932 .type = TestOperandType::TENSOR_FLOAT32,
933 .zeroPoint = 0
934 }},
935 .operations = {{
936 .inputs = {0, 1},
937 .outputs = {2},
938 .type = TestOperationType::ELU
939 }},
940 .outputIndexes = {2}
941 },
942 .minSupportedVersion = TestHalVersion::V1_3,
943 .referenced = {}
944 };
945 return model;
946 }
947
948 const auto dummy_test_model_alpha10 = TestModelManager::get().add("elu_alpha10", get_test_model_alpha10());
949
950 } // namespace generated_tests::elu
951
952 namespace generated_tests::elu {
953
get_test_model_alpha10_float16()954 const TestModel& get_test_model_alpha10_float16() {
955 static TestModel model = {
956 .expectFailure = false,
957 .expectedMultinomialDistributionTolerance = 0,
958 .isRelaxed = false,
959 .main = {
960 .inputIndexes = {0},
961 .operands = {{ // input02
962 .channelQuant = {},
963 .data = TestBuffer::createFromVector<_Float16>({-10.0f, -5.0f, 0.0f, 5.0f}),
964 .dimensions = {2, 1, 1, 1, 2},
965 .isIgnored = false,
966 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
967 .numberOfConsumers = 1,
968 .scale = 0.0f,
969 .type = TestOperandType::TENSOR_FLOAT16,
970 .zeroPoint = 0
971 }, { // alpha2
972 .channelQuant = {},
973 .data = TestBuffer::createFromVector<_Float16>({10.0f}),
974 .dimensions = {},
975 .isIgnored = false,
976 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
977 .numberOfConsumers = 1,
978 .scale = 0.0f,
979 .type = TestOperandType::FLOAT16,
980 .zeroPoint = 0
981 }, { // output02
982 .channelQuant = {},
983 .data = TestBuffer::createFromVector<_Float16>({-9.99954605102539f, -9.93262004852295f, 0.0f, 5.0f}),
984 .dimensions = {2, 1, 1, 1, 2},
985 .isIgnored = false,
986 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
987 .numberOfConsumers = 0,
988 .scale = 0.0f,
989 .type = TestOperandType::TENSOR_FLOAT16,
990 .zeroPoint = 0
991 }},
992 .operations = {{
993 .inputs = {0, 1},
994 .outputs = {2},
995 .type = TestOperationType::ELU
996 }},
997 .outputIndexes = {2}
998 },
999 .minSupportedVersion = TestHalVersion::V1_3,
1000 .referenced = {}
1001 };
1002 return model;
1003 }
1004
1005 const auto dummy_test_model_alpha10_float16 = TestModelManager::get().add("elu_alpha10_float16", get_test_model_alpha10_float16());
1006
1007 } // namespace generated_tests::elu
1008
1009 namespace generated_tests::elu {
1010
get_test_model_alpha10_relaxed()1011 const TestModel& get_test_model_alpha10_relaxed() {
1012 static TestModel model = {
1013 .expectFailure = false,
1014 .expectedMultinomialDistributionTolerance = 0,
1015 .isRelaxed = true,
1016 .main = {
1017 .inputIndexes = {0},
1018 .operands = {{ // input02
1019 .channelQuant = {},
1020 .data = TestBuffer::createFromVector<float>({-10.0f, -5.0f, 0.0f, 5.0f}),
1021 .dimensions = {2, 1, 1, 1, 2},
1022 .isIgnored = false,
1023 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
1024 .numberOfConsumers = 1,
1025 .scale = 0.0f,
1026 .type = TestOperandType::TENSOR_FLOAT32,
1027 .zeroPoint = 0
1028 }, { // alpha2
1029 .channelQuant = {},
1030 .data = TestBuffer::createFromVector<float>({10.0f}),
1031 .dimensions = {},
1032 .isIgnored = false,
1033 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
1034 .numberOfConsumers = 1,
1035 .scale = 0.0f,
1036 .type = TestOperandType::FLOAT32,
1037 .zeroPoint = 0
1038 }, { // output02
1039 .channelQuant = {},
1040 .data = TestBuffer::createFromVector<float>({-9.999546f, -9.93262f, 0.0f, 5.0f}),
1041 .dimensions = {2, 1, 1, 1, 2},
1042 .isIgnored = false,
1043 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
1044 .numberOfConsumers = 0,
1045 .scale = 0.0f,
1046 .type = TestOperandType::TENSOR_FLOAT32,
1047 .zeroPoint = 0
1048 }},
1049 .operations = {{
1050 .inputs = {0, 1},
1051 .outputs = {2},
1052 .type = TestOperationType::ELU
1053 }},
1054 .outputIndexes = {2}
1055 },
1056 .minSupportedVersion = TestHalVersion::UNKNOWN,
1057 .referenced = {}
1058 };
1059 return model;
1060 }
1061
1062 const auto dummy_test_model_alpha10_relaxed = TestModelManager::get().add("elu_alpha10_relaxed", get_test_model_alpha10_relaxed());
1063
1064 } // namespace generated_tests::elu
1065
1066