1 // Generated from div.mod.py
2 // DO NOT EDIT
3 // clang-format off
4 #include "TestHarness.h"
5 using namespace test_helper;
6
7 namespace generated_tests::div {
8
get_test_model()9 const TestModel& get_test_model() {
10 static TestModel model = {
11 .expectFailure = false,
12 .expectedMultinomialDistributionTolerance = 0,
13 .isRelaxed = false,
14 .main = {
15 .inputIndexes = {0, 1},
16 .operands = {{ // op1
17 .channelQuant = {},
18 .data = TestBuffer::createFromVector<float>({2.0f, -4.0f, 8.0f, -16.0f}),
19 .dimensions = {1, 2, 2, 1},
20 .isIgnored = false,
21 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
22 .numberOfConsumers = 1,
23 .scale = 0.0f,
24 .type = TestOperandType::TENSOR_FLOAT32,
25 .zeroPoint = 0
26 }, { // op2
27 .channelQuant = {},
28 .data = TestBuffer::createFromVector<float>({2.0f, -2.0f, -4.0f, 4.0f}),
29 .dimensions = {1, 2, 2, 1},
30 .isIgnored = false,
31 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
32 .numberOfConsumers = 1,
33 .scale = 0.0f,
34 .type = TestOperandType::TENSOR_FLOAT32,
35 .zeroPoint = 0
36 }, { // act
37 .channelQuant = {},
38 .data = TestBuffer::createFromVector<int32_t>({0}),
39 .dimensions = {},
40 .isIgnored = false,
41 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
42 .numberOfConsumers = 1,
43 .scale = 0.0f,
44 .type = TestOperandType::INT32,
45 .zeroPoint = 0
46 }, { // op3
47 .channelQuant = {},
48 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, -2.0f, -4.0f}),
49 .dimensions = {1, 2, 2, 1},
50 .isIgnored = false,
51 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
52 .numberOfConsumers = 0,
53 .scale = 0.0f,
54 .type = TestOperandType::TENSOR_FLOAT32,
55 .zeroPoint = 0
56 }},
57 .operations = {{
58 .inputs = {0, 1, 2},
59 .outputs = {3},
60 .type = TestOperationType::DIV
61 }},
62 .outputIndexes = {3}
63 },
64 .minSupportedVersion = TestHalVersion::V1_1,
65 .referenced = {}
66 };
67 return model;
68 }
69
70 const auto dummy_test_model = TestModelManager::get().add("div", get_test_model());
71
72 } // namespace generated_tests::div
73
74 namespace generated_tests::div {
75
get_test_model_all_inputs_as_internal()76 const TestModel& get_test_model_all_inputs_as_internal() {
77 static TestModel model = {
78 .expectFailure = false,
79 .expectedMultinomialDistributionTolerance = 0,
80 .isRelaxed = false,
81 .main = {
82 .inputIndexes = {4, 7},
83 .operands = {{ // op1
84 .channelQuant = {},
85 .data = TestBuffer::createFromVector<float>({}),
86 .dimensions = {1, 2, 2, 1},
87 .isIgnored = false,
88 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
89 .numberOfConsumers = 1,
90 .scale = 0.0f,
91 .type = TestOperandType::TENSOR_FLOAT32,
92 .zeroPoint = 0
93 }, { // op2
94 .channelQuant = {},
95 .data = TestBuffer::createFromVector<float>({}),
96 .dimensions = {1, 2, 2, 1},
97 .isIgnored = false,
98 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
99 .numberOfConsumers = 1,
100 .scale = 0.0f,
101 .type = TestOperandType::TENSOR_FLOAT32,
102 .zeroPoint = 0
103 }, { // act
104 .channelQuant = {},
105 .data = TestBuffer::createFromVector<int32_t>({0}),
106 .dimensions = {},
107 .isIgnored = false,
108 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
109 .numberOfConsumers = 1,
110 .scale = 0.0f,
111 .type = TestOperandType::INT32,
112 .zeroPoint = 0
113 }, { // op3
114 .channelQuant = {},
115 .data = TestBuffer::createFromVector<float>({1.0f, 2.0f, -2.0f, -4.0f}),
116 .dimensions = {1, 2, 2, 1},
117 .isIgnored = false,
118 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
119 .numberOfConsumers = 0,
120 .scale = 0.0f,
121 .type = TestOperandType::TENSOR_FLOAT32,
122 .zeroPoint = 0
123 }, { // op1_new
124 .channelQuant = {},
125 .data = TestBuffer::createFromVector<float>({2.0f, -4.0f, 8.0f, -16.0f}),
126 .dimensions = {1, 2, 2, 1},
127 .isIgnored = false,
128 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
129 .numberOfConsumers = 1,
130 .scale = 0.0f,
131 .type = TestOperandType::TENSOR_FLOAT32,
132 .zeroPoint = 0
133 }, { // placeholder
134 .channelQuant = {},
135 .data = TestBuffer::createFromVector<float>({0.0f}),
136 .dimensions = {1},
137 .isIgnored = false,
138 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
139 .numberOfConsumers = 1,
140 .scale = 0.0f,
141 .type = TestOperandType::TENSOR_FLOAT32,
142 .zeroPoint = 0
143 }, { // param1
144 .channelQuant = {},
145 .data = TestBuffer::createFromVector<int32_t>({0}),
146 .dimensions = {},
147 .isIgnored = false,
148 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
149 .numberOfConsumers = 1,
150 .scale = 0.0f,
151 .type = TestOperandType::INT32,
152 .zeroPoint = 0
153 }, { // op2_new
154 .channelQuant = {},
155 .data = TestBuffer::createFromVector<float>({2.0f, -2.0f, -4.0f, 4.0f}),
156 .dimensions = {1, 2, 2, 1},
157 .isIgnored = false,
158 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
159 .numberOfConsumers = 1,
160 .scale = 0.0f,
161 .type = TestOperandType::TENSOR_FLOAT32,
162 .zeroPoint = 0
163 }, { // placeholder1
164 .channelQuant = {},
165 .data = TestBuffer::createFromVector<float>({0.0f}),
166 .dimensions = {1},
167 .isIgnored = false,
168 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
169 .numberOfConsumers = 1,
170 .scale = 0.0f,
171 .type = TestOperandType::TENSOR_FLOAT32,
172 .zeroPoint = 0
173 }, { // param2
174 .channelQuant = {},
175 .data = TestBuffer::createFromVector<int32_t>({0}),
176 .dimensions = {},
177 .isIgnored = false,
178 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
179 .numberOfConsumers = 1,
180 .scale = 0.0f,
181 .type = TestOperandType::INT32,
182 .zeroPoint = 0
183 }},
184 .operations = {{
185 .inputs = {4, 5, 6},
186 .outputs = {0},
187 .type = TestOperationType::ADD
188 }, {
189 .inputs = {7, 8, 9},
190 .outputs = {1},
191 .type = TestOperationType::ADD
192 }, {
193 .inputs = {0, 1, 2},
194 .outputs = {3},
195 .type = TestOperationType::DIV
196 }},
197 .outputIndexes = {3}
198 },
199 .minSupportedVersion = TestHalVersion::V1_1,
200 .referenced = {}
201 };
202 return model;
203 }
204
205 const auto dummy_test_model_all_inputs_as_internal = TestModelManager::get().add("div_all_inputs_as_internal", get_test_model_all_inputs_as_internal());
206
207 } // namespace generated_tests::div
208
209 namespace generated_tests::div {
210
get_test_model_by_zero()211 const TestModel& get_test_model_by_zero() {
212 static TestModel model = {
213 .expectFailure = false,
214 .expectedMultinomialDistributionTolerance = 0,
215 .isRelaxed = false,
216 .main = { // by_zero
217 .inputIndexes = {0, 1},
218 .operands = {{ // input0
219 .channelQuant = {},
220 .data = TestBuffer::createFromVector<float>({1.0f}),
221 .dimensions = {1},
222 .isIgnored = false,
223 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
224 .numberOfConsumers = 1,
225 .scale = 0.0f,
226 .type = TestOperandType::TENSOR_FLOAT32,
227 .zeroPoint = 0
228 }, { // input1
229 .channelQuant = {},
230 .data = TestBuffer::createFromVector<float>({0.0f}),
231 .dimensions = {1},
232 .isIgnored = false,
233 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
234 .numberOfConsumers = 1,
235 .scale = 0.0f,
236 .type = TestOperandType::TENSOR_FLOAT32,
237 .zeroPoint = 0
238 }, { // param
239 .channelQuant = {},
240 .data = TestBuffer::createFromVector<int32_t>({0}),
241 .dimensions = {},
242 .isIgnored = false,
243 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
244 .numberOfConsumers = 1,
245 .scale = 0.0f,
246 .type = TestOperandType::INT32,
247 .zeroPoint = 0
248 }, { // output
249 .channelQuant = {},
250 .data = TestBuffer::createFromVector<float>({0.0f}),
251 .dimensions = {1},
252 .isIgnored = true,
253 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
254 .numberOfConsumers = 0,
255 .scale = 0.0f,
256 .type = TestOperandType::TENSOR_FLOAT32,
257 .zeroPoint = 0
258 }},
259 .operations = {{
260 .inputs = {0, 1, 2},
261 .outputs = {3},
262 .type = TestOperationType::DIV
263 }},
264 .outputIndexes = {3}
265 },
266 .minSupportedVersion = TestHalVersion::V1_1,
267 .referenced = {}
268 };
269 return model;
270 }
271
272 const auto dummy_test_model_by_zero = TestModelManager::get().add("div_by_zero", get_test_model_by_zero());
273
274 } // namespace generated_tests::div
275
276 namespace generated_tests::div {
277
get_test_model_by_zero_all_inputs_as_internal()278 const TestModel& get_test_model_by_zero_all_inputs_as_internal() {
279 static TestModel model = {
280 .expectFailure = false,
281 .expectedMultinomialDistributionTolerance = 0,
282 .isRelaxed = false,
283 .main = { // by_zero
284 .inputIndexes = {4, 7},
285 .operands = {{ // input0
286 .channelQuant = {},
287 .data = TestBuffer::createFromVector<float>({}),
288 .dimensions = {1},
289 .isIgnored = false,
290 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
291 .numberOfConsumers = 1,
292 .scale = 0.0f,
293 .type = TestOperandType::TENSOR_FLOAT32,
294 .zeroPoint = 0
295 }, { // input1
296 .channelQuant = {},
297 .data = TestBuffer::createFromVector<float>({}),
298 .dimensions = {1},
299 .isIgnored = false,
300 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
301 .numberOfConsumers = 1,
302 .scale = 0.0f,
303 .type = TestOperandType::TENSOR_FLOAT32,
304 .zeroPoint = 0
305 }, { // param
306 .channelQuant = {},
307 .data = TestBuffer::createFromVector<int32_t>({0}),
308 .dimensions = {},
309 .isIgnored = false,
310 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
311 .numberOfConsumers = 1,
312 .scale = 0.0f,
313 .type = TestOperandType::INT32,
314 .zeroPoint = 0
315 }, { // output
316 .channelQuant = {},
317 .data = TestBuffer::createFromVector<float>({0.0f}),
318 .dimensions = {1},
319 .isIgnored = true,
320 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
321 .numberOfConsumers = 0,
322 .scale = 0.0f,
323 .type = TestOperandType::TENSOR_FLOAT32,
324 .zeroPoint = 0
325 }, { // input0_new
326 .channelQuant = {},
327 .data = TestBuffer::createFromVector<float>({1.0f}),
328 .dimensions = {1},
329 .isIgnored = false,
330 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
331 .numberOfConsumers = 1,
332 .scale = 0.0f,
333 .type = TestOperandType::TENSOR_FLOAT32,
334 .zeroPoint = 0
335 }, { // placeholder2
336 .channelQuant = {},
337 .data = TestBuffer::createFromVector<float>({0.0f}),
338 .dimensions = {1},
339 .isIgnored = false,
340 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
341 .numberOfConsumers = 1,
342 .scale = 0.0f,
343 .type = TestOperandType::TENSOR_FLOAT32,
344 .zeroPoint = 0
345 }, { // param3
346 .channelQuant = {},
347 .data = TestBuffer::createFromVector<int32_t>({0}),
348 .dimensions = {},
349 .isIgnored = false,
350 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
351 .numberOfConsumers = 1,
352 .scale = 0.0f,
353 .type = TestOperandType::INT32,
354 .zeroPoint = 0
355 }, { // input1_new
356 .channelQuant = {},
357 .data = TestBuffer::createFromVector<float>({0.0f}),
358 .dimensions = {1},
359 .isIgnored = false,
360 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
361 .numberOfConsumers = 1,
362 .scale = 0.0f,
363 .type = TestOperandType::TENSOR_FLOAT32,
364 .zeroPoint = 0
365 }, { // placeholder3
366 .channelQuant = {},
367 .data = TestBuffer::createFromVector<float>({0.0f}),
368 .dimensions = {1},
369 .isIgnored = false,
370 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
371 .numberOfConsumers = 1,
372 .scale = 0.0f,
373 .type = TestOperandType::TENSOR_FLOAT32,
374 .zeroPoint = 0
375 }, { // param4
376 .channelQuant = {},
377 .data = TestBuffer::createFromVector<int32_t>({0}),
378 .dimensions = {},
379 .isIgnored = false,
380 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
381 .numberOfConsumers = 1,
382 .scale = 0.0f,
383 .type = TestOperandType::INT32,
384 .zeroPoint = 0
385 }},
386 .operations = {{
387 .inputs = {4, 5, 6},
388 .outputs = {0},
389 .type = TestOperationType::ADD
390 }, {
391 .inputs = {7, 8, 9},
392 .outputs = {1},
393 .type = TestOperationType::ADD
394 }, {
395 .inputs = {0, 1, 2},
396 .outputs = {3},
397 .type = TestOperationType::DIV
398 }},
399 .outputIndexes = {3}
400 },
401 .minSupportedVersion = TestHalVersion::V1_1,
402 .referenced = {}
403 };
404 return model;
405 }
406
407 const auto dummy_test_model_by_zero_all_inputs_as_internal = TestModelManager::get().add("div_by_zero_all_inputs_as_internal", get_test_model_by_zero_all_inputs_as_internal());
408
409 } // namespace generated_tests::div
410
411 namespace generated_tests::div {
412
get_test_model_by_zero_relaxed()413 const TestModel& get_test_model_by_zero_relaxed() {
414 static TestModel model = {
415 .expectFailure = false,
416 .expectedMultinomialDistributionTolerance = 0,
417 .isRelaxed = true,
418 .main = { // by_zero
419 .inputIndexes = {0, 1},
420 .operands = {{ // input0
421 .channelQuant = {},
422 .data = TestBuffer::createFromVector<float>({1.0f}),
423 .dimensions = {1},
424 .isIgnored = false,
425 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
426 .numberOfConsumers = 1,
427 .scale = 0.0f,
428 .type = TestOperandType::TENSOR_FLOAT32,
429 .zeroPoint = 0
430 }, { // input1
431 .channelQuant = {},
432 .data = TestBuffer::createFromVector<float>({0.0f}),
433 .dimensions = {1},
434 .isIgnored = false,
435 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
436 .numberOfConsumers = 1,
437 .scale = 0.0f,
438 .type = TestOperandType::TENSOR_FLOAT32,
439 .zeroPoint = 0
440 }, { // param
441 .channelQuant = {},
442 .data = TestBuffer::createFromVector<int32_t>({0}),
443 .dimensions = {},
444 .isIgnored = false,
445 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
446 .numberOfConsumers = 1,
447 .scale = 0.0f,
448 .type = TestOperandType::INT32,
449 .zeroPoint = 0
450 }, { // output
451 .channelQuant = {},
452 .data = TestBuffer::createFromVector<float>({0.0f}),
453 .dimensions = {1},
454 .isIgnored = true,
455 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
456 .numberOfConsumers = 0,
457 .scale = 0.0f,
458 .type = TestOperandType::TENSOR_FLOAT32,
459 .zeroPoint = 0
460 }},
461 .operations = {{
462 .inputs = {0, 1, 2},
463 .outputs = {3},
464 .type = TestOperationType::DIV
465 }},
466 .outputIndexes = {3}
467 },
468 .minSupportedVersion = TestHalVersion::UNKNOWN,
469 .referenced = {}
470 };
471 return model;
472 }
473
474 const auto dummy_test_model_by_zero_relaxed = TestModelManager::get().add("div_by_zero_relaxed", get_test_model_by_zero_relaxed());
475
476 } // namespace generated_tests::div
477
478 namespace generated_tests::div {
479
get_test_model_by_zero_relaxed_all_inputs_as_internal()480 const TestModel& get_test_model_by_zero_relaxed_all_inputs_as_internal() {
481 static TestModel model = {
482 .expectFailure = false,
483 .expectedMultinomialDistributionTolerance = 0,
484 .isRelaxed = true,
485 .main = { // by_zero
486 .inputIndexes = {4, 7},
487 .operands = {{ // input0
488 .channelQuant = {},
489 .data = TestBuffer::createFromVector<float>({}),
490 .dimensions = {1},
491 .isIgnored = false,
492 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
493 .numberOfConsumers = 1,
494 .scale = 0.0f,
495 .type = TestOperandType::TENSOR_FLOAT32,
496 .zeroPoint = 0
497 }, { // input1
498 .channelQuant = {},
499 .data = TestBuffer::createFromVector<float>({}),
500 .dimensions = {1},
501 .isIgnored = false,
502 .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
503 .numberOfConsumers = 1,
504 .scale = 0.0f,
505 .type = TestOperandType::TENSOR_FLOAT32,
506 .zeroPoint = 0
507 }, { // param
508 .channelQuant = {},
509 .data = TestBuffer::createFromVector<int32_t>({0}),
510 .dimensions = {},
511 .isIgnored = false,
512 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
513 .numberOfConsumers = 1,
514 .scale = 0.0f,
515 .type = TestOperandType::INT32,
516 .zeroPoint = 0
517 }, { // output
518 .channelQuant = {},
519 .data = TestBuffer::createFromVector<float>({0.0f}),
520 .dimensions = {1},
521 .isIgnored = true,
522 .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
523 .numberOfConsumers = 0,
524 .scale = 0.0f,
525 .type = TestOperandType::TENSOR_FLOAT32,
526 .zeroPoint = 0
527 }, { // input0_new
528 .channelQuant = {},
529 .data = TestBuffer::createFromVector<float>({1.0f}),
530 .dimensions = {1},
531 .isIgnored = false,
532 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
533 .numberOfConsumers = 1,
534 .scale = 0.0f,
535 .type = TestOperandType::TENSOR_FLOAT32,
536 .zeroPoint = 0
537 }, { // placeholder4
538 .channelQuant = {},
539 .data = TestBuffer::createFromVector<float>({0.0f}),
540 .dimensions = {1},
541 .isIgnored = false,
542 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
543 .numberOfConsumers = 1,
544 .scale = 0.0f,
545 .type = TestOperandType::TENSOR_FLOAT32,
546 .zeroPoint = 0
547 }, { // param5
548 .channelQuant = {},
549 .data = TestBuffer::createFromVector<int32_t>({0}),
550 .dimensions = {},
551 .isIgnored = false,
552 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
553 .numberOfConsumers = 1,
554 .scale = 0.0f,
555 .type = TestOperandType::INT32,
556 .zeroPoint = 0
557 }, { // input1_new
558 .channelQuant = {},
559 .data = TestBuffer::createFromVector<float>({0.0f}),
560 .dimensions = {1},
561 .isIgnored = false,
562 .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
563 .numberOfConsumers = 1,
564 .scale = 0.0f,
565 .type = TestOperandType::TENSOR_FLOAT32,
566 .zeroPoint = 0
567 }, { // placeholder5
568 .channelQuant = {},
569 .data = TestBuffer::createFromVector<float>({0.0f}),
570 .dimensions = {1},
571 .isIgnored = false,
572 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
573 .numberOfConsumers = 1,
574 .scale = 0.0f,
575 .type = TestOperandType::TENSOR_FLOAT32,
576 .zeroPoint = 0
577 }, { // param6
578 .channelQuant = {},
579 .data = TestBuffer::createFromVector<int32_t>({0}),
580 .dimensions = {},
581 .isIgnored = false,
582 .lifetime = TestOperandLifeTime::CONSTANT_COPY,
583 .numberOfConsumers = 1,
584 .scale = 0.0f,
585 .type = TestOperandType::INT32,
586 .zeroPoint = 0
587 }},
588 .operations = {{
589 .inputs = {4, 5, 6},
590 .outputs = {0},
591 .type = TestOperationType::ADD
592 }, {
593 .inputs = {7, 8, 9},
594 .outputs = {1},
595 .type = TestOperationType::ADD
596 }, {
597 .inputs = {0, 1, 2},
598 .outputs = {3},
599 .type = TestOperationType::DIV
600 }},
601 .outputIndexes = {3}
602 },
603 .minSupportedVersion = TestHalVersion::UNKNOWN,
604 .referenced = {}
605 };
606 return model;
607 }
608
609 const auto dummy_test_model_by_zero_relaxed_all_inputs_as_internal = TestModelManager::get().add("div_by_zero_relaxed_all_inputs_as_internal", get_test_model_by_zero_relaxed_all_inputs_as_internal());
610
611 } // namespace generated_tests::div
612
613