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