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