1 // clang-format off
2 // Generated file (from: sub_v1_2.mod.py). Do not edit
get_examples_none()3 std::vector<MixedTypedExample>& get_examples_none() {
4 static std::vector<MixedTypedExample> examples_none = {
5 // Begin of an example
6 {
7 .operands = {
8 //Input(s)
9 { // See tools/test_generator/include/TestHarness.h:MixedTyped
10   // int -> Dimensions map
11   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
12   // int -> FLOAT32 map
13   .float32Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
14   // int -> INT32 map
15   .int32Operands = {},
16   // int -> QUANT8_ASYMM map
17   .quant8AsymmOperands = {},
18   // int -> QUANT16_SYMM map
19   .quant16SymmOperands = {},
20   // int -> FLOAT16 map
21   .float16Operands = {},
22   // int -> BOOL8 map
23   .bool8Operands = {},
24   // int -> QUANT8_SYMM_PER_CHANNEL map
25   .quant8ChannelOperands = {},
26   // int -> QUANT16_ASYMM map
27   .quant16AsymmOperands = {},
28   // int -> QUANT8_SYMM map
29   .quant8SymmOperands = {},
30 },
31 //Output(s)
32 { // See tools/test_generator/include/TestHarness.h:MixedTyped
33   // int -> Dimensions map
34   .operandDimensions = {{0, {1, 2, 2, 1}}},
35   // int -> FLOAT32 map
36   .float32Operands = {{0, {0.0f, -2.0f, 12.0f, -20.0f}}},
37   // int -> INT32 map
38   .int32Operands = {},
39   // int -> QUANT8_ASYMM map
40   .quant8AsymmOperands = {},
41   // int -> QUANT16_SYMM map
42   .quant16SymmOperands = {},
43   // int -> FLOAT16 map
44   .float16Operands = {},
45   // int -> BOOL8 map
46   .bool8Operands = {},
47   // int -> QUANT8_SYMM_PER_CHANNEL map
48   .quant8ChannelOperands = {},
49   // int -> QUANT16_ASYMM map
50   .quant16AsymmOperands = {},
51   // int -> QUANT8_SYMM map
52   .quant8SymmOperands = {},
53 }
54 },
55 }, // End of an example
56 };
57 return examples_none;
58 };
59 
get_examples_relu()60 std::vector<MixedTypedExample>& get_examples_relu() {
61 static std::vector<MixedTypedExample> examples_relu = {
62 // Begin of an example
63 {
64 .operands = {
65 //Input(s)
66 { // See tools/test_generator/include/TestHarness.h:MixedTyped
67   // int -> Dimensions map
68   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
69   // int -> FLOAT32 map
70   .float32Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
71   // int -> INT32 map
72   .int32Operands = {},
73   // int -> QUANT8_ASYMM map
74   .quant8AsymmOperands = {},
75   // int -> QUANT16_SYMM map
76   .quant16SymmOperands = {},
77   // int -> FLOAT16 map
78   .float16Operands = {},
79   // int -> BOOL8 map
80   .bool8Operands = {},
81   // int -> QUANT8_SYMM_PER_CHANNEL map
82   .quant8ChannelOperands = {},
83   // int -> QUANT16_ASYMM map
84   .quant16AsymmOperands = {},
85   // int -> QUANT8_SYMM map
86   .quant8SymmOperands = {},
87 },
88 //Output(s)
89 { // See tools/test_generator/include/TestHarness.h:MixedTyped
90   // int -> Dimensions map
91   .operandDimensions = {{0, {1, 2, 2, 1}}},
92   // int -> FLOAT32 map
93   .float32Operands = {{0, {0.0f, 0.0f, 12.0f, 0.0f}}},
94   // int -> INT32 map
95   .int32Operands = {},
96   // int -> QUANT8_ASYMM map
97   .quant8AsymmOperands = {},
98   // int -> QUANT16_SYMM map
99   .quant16SymmOperands = {},
100   // int -> FLOAT16 map
101   .float16Operands = {},
102   // int -> BOOL8 map
103   .bool8Operands = {},
104   // int -> QUANT8_SYMM_PER_CHANNEL map
105   .quant8ChannelOperands = {},
106   // int -> QUANT16_ASYMM map
107   .quant16AsymmOperands = {},
108   // int -> QUANT8_SYMM map
109   .quant8SymmOperands = {},
110 }
111 },
112 }, // End of an example
113 };
114 return examples_relu;
115 };
116 
get_examples_relu1()117 std::vector<MixedTypedExample>& get_examples_relu1() {
118 static std::vector<MixedTypedExample> examples_relu1 = {
119 // Begin of an example
120 {
121 .operands = {
122 //Input(s)
123 { // See tools/test_generator/include/TestHarness.h:MixedTyped
124   // int -> Dimensions map
125   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
126   // int -> FLOAT32 map
127   .float32Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
128   // int -> INT32 map
129   .int32Operands = {},
130   // int -> QUANT8_ASYMM map
131   .quant8AsymmOperands = {},
132   // int -> QUANT16_SYMM map
133   .quant16SymmOperands = {},
134   // int -> FLOAT16 map
135   .float16Operands = {},
136   // int -> BOOL8 map
137   .bool8Operands = {},
138   // int -> QUANT8_SYMM_PER_CHANNEL map
139   .quant8ChannelOperands = {},
140   // int -> QUANT16_ASYMM map
141   .quant16AsymmOperands = {},
142   // int -> QUANT8_SYMM map
143   .quant8SymmOperands = {},
144 },
145 //Output(s)
146 { // See tools/test_generator/include/TestHarness.h:MixedTyped
147   // int -> Dimensions map
148   .operandDimensions = {{0, {1, 2, 2, 1}}},
149   // int -> FLOAT32 map
150   .float32Operands = {{0, {0.0f, -1.0f, 1.0f, -1.0f}}},
151   // int -> INT32 map
152   .int32Operands = {},
153   // int -> QUANT8_ASYMM map
154   .quant8AsymmOperands = {},
155   // int -> QUANT16_SYMM map
156   .quant16SymmOperands = {},
157   // int -> FLOAT16 map
158   .float16Operands = {},
159   // int -> BOOL8 map
160   .bool8Operands = {},
161   // int -> QUANT8_SYMM_PER_CHANNEL map
162   .quant8ChannelOperands = {},
163   // int -> QUANT16_ASYMM map
164   .quant16AsymmOperands = {},
165   // int -> QUANT8_SYMM map
166   .quant8SymmOperands = {},
167 }
168 },
169 }, // End of an example
170 };
171 return examples_relu1;
172 };
173 
get_examples_relu6()174 std::vector<MixedTypedExample>& get_examples_relu6() {
175 static std::vector<MixedTypedExample> examples_relu6 = {
176 // Begin of an example
177 {
178 .operands = {
179 //Input(s)
180 { // See tools/test_generator/include/TestHarness.h:MixedTyped
181   // int -> Dimensions map
182   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
183   // int -> FLOAT32 map
184   .float32Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
185   // int -> INT32 map
186   .int32Operands = {},
187   // int -> QUANT8_ASYMM map
188   .quant8AsymmOperands = {},
189   // int -> QUANT16_SYMM map
190   .quant16SymmOperands = {},
191   // int -> FLOAT16 map
192   .float16Operands = {},
193   // int -> BOOL8 map
194   .bool8Operands = {},
195   // int -> QUANT8_SYMM_PER_CHANNEL map
196   .quant8ChannelOperands = {},
197   // int -> QUANT16_ASYMM map
198   .quant16AsymmOperands = {},
199   // int -> QUANT8_SYMM map
200   .quant8SymmOperands = {},
201 },
202 //Output(s)
203 { // See tools/test_generator/include/TestHarness.h:MixedTyped
204   // int -> Dimensions map
205   .operandDimensions = {{0, {1, 2, 2, 1}}},
206   // int -> FLOAT32 map
207   .float32Operands = {{0, {0.0f, 0.0f, 6.0f, 0.0f}}},
208   // int -> INT32 map
209   .int32Operands = {},
210   // int -> QUANT8_ASYMM map
211   .quant8AsymmOperands = {},
212   // int -> QUANT16_SYMM map
213   .quant16SymmOperands = {},
214   // int -> FLOAT16 map
215   .float16Operands = {},
216   // int -> BOOL8 map
217   .bool8Operands = {},
218   // int -> QUANT8_SYMM_PER_CHANNEL map
219   .quant8ChannelOperands = {},
220   // int -> QUANT16_ASYMM map
221   .quant16AsymmOperands = {},
222   // int -> QUANT8_SYMM map
223   .quant8SymmOperands = {},
224 }
225 },
226 }, // End of an example
227 };
228 return examples_relu6;
229 };
230 
get_examples_float16_none()231 std::vector<MixedTypedExample>& get_examples_float16_none() {
232 static std::vector<MixedTypedExample> examples_float16_none = {
233 // Begin of an example
234 {
235 .operands = {
236 //Input(s)
237 { // See tools/test_generator/include/TestHarness.h:MixedTyped
238   // int -> Dimensions map
239   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
240   // int -> FLOAT32 map
241   .float32Operands = {},
242   // int -> INT32 map
243   .int32Operands = {},
244   // int -> QUANT8_ASYMM map
245   .quant8AsymmOperands = {},
246   // int -> QUANT16_SYMM map
247   .quant16SymmOperands = {},
248   // int -> FLOAT16 map
249   .float16Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
250   // int -> BOOL8 map
251   .bool8Operands = {},
252   // int -> QUANT8_SYMM_PER_CHANNEL map
253   .quant8ChannelOperands = {},
254   // int -> QUANT16_ASYMM map
255   .quant16AsymmOperands = {},
256   // int -> QUANT8_SYMM map
257   .quant8SymmOperands = {},
258 },
259 //Output(s)
260 { // See tools/test_generator/include/TestHarness.h:MixedTyped
261   // int -> Dimensions map
262   .operandDimensions = {{0, {1, 2, 2, 1}}},
263   // int -> FLOAT32 map
264   .float32Operands = {},
265   // int -> INT32 map
266   .int32Operands = {},
267   // int -> QUANT8_ASYMM map
268   .quant8AsymmOperands = {},
269   // int -> QUANT16_SYMM map
270   .quant16SymmOperands = {},
271   // int -> FLOAT16 map
272   .float16Operands = {{0, {0.0f, -2.0f, 12.0f, -20.0f}}},
273   // int -> BOOL8 map
274   .bool8Operands = {},
275   // int -> QUANT8_SYMM_PER_CHANNEL map
276   .quant8ChannelOperands = {},
277   // int -> QUANT16_ASYMM map
278   .quant16AsymmOperands = {},
279   // int -> QUANT8_SYMM map
280   .quant8SymmOperands = {},
281 }
282 },
283 }, // End of an example
284 };
285 return examples_float16_none;
286 };
287 
get_examples_float16_relu()288 std::vector<MixedTypedExample>& get_examples_float16_relu() {
289 static std::vector<MixedTypedExample> examples_float16_relu = {
290 // Begin of an example
291 {
292 .operands = {
293 //Input(s)
294 { // See tools/test_generator/include/TestHarness.h:MixedTyped
295   // int -> Dimensions map
296   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
297   // int -> FLOAT32 map
298   .float32Operands = {},
299   // int -> INT32 map
300   .int32Operands = {},
301   // int -> QUANT8_ASYMM map
302   .quant8AsymmOperands = {},
303   // int -> QUANT16_SYMM map
304   .quant16SymmOperands = {},
305   // int -> FLOAT16 map
306   .float16Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
307   // int -> BOOL8 map
308   .bool8Operands = {},
309   // int -> QUANT8_SYMM_PER_CHANNEL map
310   .quant8ChannelOperands = {},
311   // int -> QUANT16_ASYMM map
312   .quant16AsymmOperands = {},
313   // int -> QUANT8_SYMM map
314   .quant8SymmOperands = {},
315 },
316 //Output(s)
317 { // See tools/test_generator/include/TestHarness.h:MixedTyped
318   // int -> Dimensions map
319   .operandDimensions = {{0, {1, 2, 2, 1}}},
320   // int -> FLOAT32 map
321   .float32Operands = {},
322   // int -> INT32 map
323   .int32Operands = {},
324   // int -> QUANT8_ASYMM map
325   .quant8AsymmOperands = {},
326   // int -> QUANT16_SYMM map
327   .quant16SymmOperands = {},
328   // int -> FLOAT16 map
329   .float16Operands = {{0, {0.0f, 0.0f, 12.0f, 0.0f}}},
330   // int -> BOOL8 map
331   .bool8Operands = {},
332   // int -> QUANT8_SYMM_PER_CHANNEL map
333   .quant8ChannelOperands = {},
334   // int -> QUANT16_ASYMM map
335   .quant16AsymmOperands = {},
336   // int -> QUANT8_SYMM map
337   .quant8SymmOperands = {},
338 }
339 },
340 }, // End of an example
341 };
342 return examples_float16_relu;
343 };
344 
get_examples_float16_relu1()345 std::vector<MixedTypedExample>& get_examples_float16_relu1() {
346 static std::vector<MixedTypedExample> examples_float16_relu1 = {
347 // Begin of an example
348 {
349 .operands = {
350 //Input(s)
351 { // See tools/test_generator/include/TestHarness.h:MixedTyped
352   // int -> Dimensions map
353   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
354   // int -> FLOAT32 map
355   .float32Operands = {},
356   // int -> INT32 map
357   .int32Operands = {},
358   // int -> QUANT8_ASYMM map
359   .quant8AsymmOperands = {},
360   // int -> QUANT16_SYMM map
361   .quant16SymmOperands = {},
362   // int -> FLOAT16 map
363   .float16Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
364   // int -> BOOL8 map
365   .bool8Operands = {},
366   // int -> QUANT8_SYMM_PER_CHANNEL map
367   .quant8ChannelOperands = {},
368   // int -> QUANT16_ASYMM map
369   .quant16AsymmOperands = {},
370   // int -> QUANT8_SYMM map
371   .quant8SymmOperands = {},
372 },
373 //Output(s)
374 { // See tools/test_generator/include/TestHarness.h:MixedTyped
375   // int -> Dimensions map
376   .operandDimensions = {{0, {1, 2, 2, 1}}},
377   // int -> FLOAT32 map
378   .float32Operands = {},
379   // int -> INT32 map
380   .int32Operands = {},
381   // int -> QUANT8_ASYMM map
382   .quant8AsymmOperands = {},
383   // int -> QUANT16_SYMM map
384   .quant16SymmOperands = {},
385   // int -> FLOAT16 map
386   .float16Operands = {{0, {0.0f, -1.0f, 1.0f, -1.0f}}},
387   // int -> BOOL8 map
388   .bool8Operands = {},
389   // int -> QUANT8_SYMM_PER_CHANNEL map
390   .quant8ChannelOperands = {},
391   // int -> QUANT16_ASYMM map
392   .quant16AsymmOperands = {},
393   // int -> QUANT8_SYMM map
394   .quant8SymmOperands = {},
395 }
396 },
397 }, // End of an example
398 };
399 return examples_float16_relu1;
400 };
401 
get_examples_float16_relu6()402 std::vector<MixedTypedExample>& get_examples_float16_relu6() {
403 static std::vector<MixedTypedExample> examples_float16_relu6 = {
404 // Begin of an example
405 {
406 .operands = {
407 //Input(s)
408 { // See tools/test_generator/include/TestHarness.h:MixedTyped
409   // int -> Dimensions map
410   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
411   // int -> FLOAT32 map
412   .float32Operands = {},
413   // int -> INT32 map
414   .int32Operands = {},
415   // int -> QUANT8_ASYMM map
416   .quant8AsymmOperands = {},
417   // int -> QUANT16_SYMM map
418   .quant16SymmOperands = {},
419   // int -> FLOAT16 map
420   .float16Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
421   // int -> BOOL8 map
422   .bool8Operands = {},
423   // int -> QUANT8_SYMM_PER_CHANNEL map
424   .quant8ChannelOperands = {},
425   // int -> QUANT16_ASYMM map
426   .quant16AsymmOperands = {},
427   // int -> QUANT8_SYMM map
428   .quant8SymmOperands = {},
429 },
430 //Output(s)
431 { // See tools/test_generator/include/TestHarness.h:MixedTyped
432   // int -> Dimensions map
433   .operandDimensions = {{0, {1, 2, 2, 1}}},
434   // int -> FLOAT32 map
435   .float32Operands = {},
436   // int -> INT32 map
437   .int32Operands = {},
438   // int -> QUANT8_ASYMM map
439   .quant8AsymmOperands = {},
440   // int -> QUANT16_SYMM map
441   .quant16SymmOperands = {},
442   // int -> FLOAT16 map
443   .float16Operands = {{0, {0.0f, 0.0f, 6.0f, 0.0f}}},
444   // int -> BOOL8 map
445   .bool8Operands = {},
446   // int -> QUANT8_SYMM_PER_CHANNEL map
447   .quant8ChannelOperands = {},
448   // int -> QUANT16_ASYMM map
449   .quant16AsymmOperands = {},
450   // int -> QUANT8_SYMM map
451   .quant8SymmOperands = {},
452 }
453 },
454 }, // End of an example
455 };
456 return examples_float16_relu6;
457 };
458 
get_examples_dynamic_output_shape_none()459 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_none() {
460 static std::vector<MixedTypedExample> examples_dynamic_output_shape_none = {
461 // Begin of an example
462 {
463 .operands = {
464 //Input(s)
465 { // See tools/test_generator/include/TestHarness.h:MixedTyped
466   // int -> Dimensions map
467   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
468   // int -> FLOAT32 map
469   .float32Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
470   // int -> INT32 map
471   .int32Operands = {},
472   // int -> QUANT8_ASYMM map
473   .quant8AsymmOperands = {},
474   // int -> QUANT16_SYMM map
475   .quant16SymmOperands = {},
476   // int -> FLOAT16 map
477   .float16Operands = {},
478   // int -> BOOL8 map
479   .bool8Operands = {},
480   // int -> QUANT8_SYMM_PER_CHANNEL map
481   .quant8ChannelOperands = {},
482   // int -> QUANT16_ASYMM map
483   .quant16AsymmOperands = {},
484   // int -> QUANT8_SYMM map
485   .quant8SymmOperands = {},
486 },
487 //Output(s)
488 { // See tools/test_generator/include/TestHarness.h:MixedTyped
489   // int -> Dimensions map
490   .operandDimensions = {{0, {1, 2, 2, 1}}},
491   // int -> FLOAT32 map
492   .float32Operands = {{0, {0.0f, -2.0f, 12.0f, -20.0f}}},
493   // int -> INT32 map
494   .int32Operands = {},
495   // int -> QUANT8_ASYMM map
496   .quant8AsymmOperands = {},
497   // int -> QUANT16_SYMM map
498   .quant16SymmOperands = {},
499   // int -> FLOAT16 map
500   .float16Operands = {},
501   // int -> BOOL8 map
502   .bool8Operands = {},
503   // int -> QUANT8_SYMM_PER_CHANNEL map
504   .quant8ChannelOperands = {},
505   // int -> QUANT16_ASYMM map
506   .quant16AsymmOperands = {},
507   // int -> QUANT8_SYMM map
508   .quant8SymmOperands = {},
509 }
510 },
511 }, // End of an example
512 };
513 return examples_dynamic_output_shape_none;
514 };
515 
get_examples_dynamic_output_shape_relu()516 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_relu() {
517 static std::vector<MixedTypedExample> examples_dynamic_output_shape_relu = {
518 // Begin of an example
519 {
520 .operands = {
521 //Input(s)
522 { // See tools/test_generator/include/TestHarness.h:MixedTyped
523   // int -> Dimensions map
524   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
525   // int -> FLOAT32 map
526   .float32Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
527   // int -> INT32 map
528   .int32Operands = {},
529   // int -> QUANT8_ASYMM map
530   .quant8AsymmOperands = {},
531   // int -> QUANT16_SYMM map
532   .quant16SymmOperands = {},
533   // int -> FLOAT16 map
534   .float16Operands = {},
535   // int -> BOOL8 map
536   .bool8Operands = {},
537   // int -> QUANT8_SYMM_PER_CHANNEL map
538   .quant8ChannelOperands = {},
539   // int -> QUANT16_ASYMM map
540   .quant16AsymmOperands = {},
541   // int -> QUANT8_SYMM map
542   .quant8SymmOperands = {},
543 },
544 //Output(s)
545 { // See tools/test_generator/include/TestHarness.h:MixedTyped
546   // int -> Dimensions map
547   .operandDimensions = {{0, {1, 2, 2, 1}}},
548   // int -> FLOAT32 map
549   .float32Operands = {{0, {0.0f, 0.0f, 12.0f, 0.0f}}},
550   // int -> INT32 map
551   .int32Operands = {},
552   // int -> QUANT8_ASYMM map
553   .quant8AsymmOperands = {},
554   // int -> QUANT16_SYMM map
555   .quant16SymmOperands = {},
556   // int -> FLOAT16 map
557   .float16Operands = {},
558   // int -> BOOL8 map
559   .bool8Operands = {},
560   // int -> QUANT8_SYMM_PER_CHANNEL map
561   .quant8ChannelOperands = {},
562   // int -> QUANT16_ASYMM map
563   .quant16AsymmOperands = {},
564   // int -> QUANT8_SYMM map
565   .quant8SymmOperands = {},
566 }
567 },
568 }, // End of an example
569 };
570 return examples_dynamic_output_shape_relu;
571 };
572 
get_examples_dynamic_output_shape_relu1()573 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_relu1() {
574 static std::vector<MixedTypedExample> examples_dynamic_output_shape_relu1 = {
575 // Begin of an example
576 {
577 .operands = {
578 //Input(s)
579 { // See tools/test_generator/include/TestHarness.h:MixedTyped
580   // int -> Dimensions map
581   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
582   // int -> FLOAT32 map
583   .float32Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
584   // int -> INT32 map
585   .int32Operands = {},
586   // int -> QUANT8_ASYMM map
587   .quant8AsymmOperands = {},
588   // int -> QUANT16_SYMM map
589   .quant16SymmOperands = {},
590   // int -> FLOAT16 map
591   .float16Operands = {},
592   // int -> BOOL8 map
593   .bool8Operands = {},
594   // int -> QUANT8_SYMM_PER_CHANNEL map
595   .quant8ChannelOperands = {},
596   // int -> QUANT16_ASYMM map
597   .quant16AsymmOperands = {},
598   // int -> QUANT8_SYMM map
599   .quant8SymmOperands = {},
600 },
601 //Output(s)
602 { // See tools/test_generator/include/TestHarness.h:MixedTyped
603   // int -> Dimensions map
604   .operandDimensions = {{0, {1, 2, 2, 1}}},
605   // int -> FLOAT32 map
606   .float32Operands = {{0, {0.0f, -1.0f, 1.0f, -1.0f}}},
607   // int -> INT32 map
608   .int32Operands = {},
609   // int -> QUANT8_ASYMM map
610   .quant8AsymmOperands = {},
611   // int -> QUANT16_SYMM map
612   .quant16SymmOperands = {},
613   // int -> FLOAT16 map
614   .float16Operands = {},
615   // int -> BOOL8 map
616   .bool8Operands = {},
617   // int -> QUANT8_SYMM_PER_CHANNEL map
618   .quant8ChannelOperands = {},
619   // int -> QUANT16_ASYMM map
620   .quant16AsymmOperands = {},
621   // int -> QUANT8_SYMM map
622   .quant8SymmOperands = {},
623 }
624 },
625 }, // End of an example
626 };
627 return examples_dynamic_output_shape_relu1;
628 };
629 
get_examples_dynamic_output_shape_relu6()630 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_relu6() {
631 static std::vector<MixedTypedExample> examples_dynamic_output_shape_relu6 = {
632 // Begin of an example
633 {
634 .operands = {
635 //Input(s)
636 { // See tools/test_generator/include/TestHarness.h:MixedTyped
637   // int -> Dimensions map
638   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
639   // int -> FLOAT32 map
640   .float32Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
641   // int -> INT32 map
642   .int32Operands = {},
643   // int -> QUANT8_ASYMM map
644   .quant8AsymmOperands = {},
645   // int -> QUANT16_SYMM map
646   .quant16SymmOperands = {},
647   // int -> FLOAT16 map
648   .float16Operands = {},
649   // int -> BOOL8 map
650   .bool8Operands = {},
651   // int -> QUANT8_SYMM_PER_CHANNEL map
652   .quant8ChannelOperands = {},
653   // int -> QUANT16_ASYMM map
654   .quant16AsymmOperands = {},
655   // int -> QUANT8_SYMM map
656   .quant8SymmOperands = {},
657 },
658 //Output(s)
659 { // See tools/test_generator/include/TestHarness.h:MixedTyped
660   // int -> Dimensions map
661   .operandDimensions = {{0, {1, 2, 2, 1}}},
662   // int -> FLOAT32 map
663   .float32Operands = {{0, {0.0f, 0.0f, 6.0f, 0.0f}}},
664   // int -> INT32 map
665   .int32Operands = {},
666   // int -> QUANT8_ASYMM map
667   .quant8AsymmOperands = {},
668   // int -> QUANT16_SYMM map
669   .quant16SymmOperands = {},
670   // int -> FLOAT16 map
671   .float16Operands = {},
672   // int -> BOOL8 map
673   .bool8Operands = {},
674   // int -> QUANT8_SYMM_PER_CHANNEL map
675   .quant8ChannelOperands = {},
676   // int -> QUANT16_ASYMM map
677   .quant16AsymmOperands = {},
678   // int -> QUANT8_SYMM map
679   .quant8SymmOperands = {},
680 }
681 },
682 }, // End of an example
683 };
684 return examples_dynamic_output_shape_relu6;
685 };
686 
get_examples_dynamic_output_shape_float16_none()687 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_float16_none() {
688 static std::vector<MixedTypedExample> examples_dynamic_output_shape_float16_none = {
689 // Begin of an example
690 {
691 .operands = {
692 //Input(s)
693 { // See tools/test_generator/include/TestHarness.h:MixedTyped
694   // int -> Dimensions map
695   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
696   // int -> FLOAT32 map
697   .float32Operands = {},
698   // int -> INT32 map
699   .int32Operands = {},
700   // int -> QUANT8_ASYMM map
701   .quant8AsymmOperands = {},
702   // int -> QUANT16_SYMM map
703   .quant16SymmOperands = {},
704   // int -> FLOAT16 map
705   .float16Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
706   // int -> BOOL8 map
707   .bool8Operands = {},
708   // int -> QUANT8_SYMM_PER_CHANNEL map
709   .quant8ChannelOperands = {},
710   // int -> QUANT16_ASYMM map
711   .quant16AsymmOperands = {},
712   // int -> QUANT8_SYMM map
713   .quant8SymmOperands = {},
714 },
715 //Output(s)
716 { // See tools/test_generator/include/TestHarness.h:MixedTyped
717   // int -> Dimensions map
718   .operandDimensions = {{0, {1, 2, 2, 1}}},
719   // int -> FLOAT32 map
720   .float32Operands = {},
721   // int -> INT32 map
722   .int32Operands = {},
723   // int -> QUANT8_ASYMM map
724   .quant8AsymmOperands = {},
725   // int -> QUANT16_SYMM map
726   .quant16SymmOperands = {},
727   // int -> FLOAT16 map
728   .float16Operands = {{0, {0.0f, -2.0f, 12.0f, -20.0f}}},
729   // int -> BOOL8 map
730   .bool8Operands = {},
731   // int -> QUANT8_SYMM_PER_CHANNEL map
732   .quant8ChannelOperands = {},
733   // int -> QUANT16_ASYMM map
734   .quant16AsymmOperands = {},
735   // int -> QUANT8_SYMM map
736   .quant8SymmOperands = {},
737 }
738 },
739 }, // End of an example
740 };
741 return examples_dynamic_output_shape_float16_none;
742 };
743 
get_examples_dynamic_output_shape_float16_relu()744 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_float16_relu() {
745 static std::vector<MixedTypedExample> examples_dynamic_output_shape_float16_relu = {
746 // Begin of an example
747 {
748 .operands = {
749 //Input(s)
750 { // See tools/test_generator/include/TestHarness.h:MixedTyped
751   // int -> Dimensions map
752   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
753   // int -> FLOAT32 map
754   .float32Operands = {},
755   // int -> INT32 map
756   .int32Operands = {},
757   // int -> QUANT8_ASYMM map
758   .quant8AsymmOperands = {},
759   // int -> QUANT16_SYMM map
760   .quant16SymmOperands = {},
761   // int -> FLOAT16 map
762   .float16Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
763   // int -> BOOL8 map
764   .bool8Operands = {},
765   // int -> QUANT8_SYMM_PER_CHANNEL map
766   .quant8ChannelOperands = {},
767   // int -> QUANT16_ASYMM map
768   .quant16AsymmOperands = {},
769   // int -> QUANT8_SYMM map
770   .quant8SymmOperands = {},
771 },
772 //Output(s)
773 { // See tools/test_generator/include/TestHarness.h:MixedTyped
774   // int -> Dimensions map
775   .operandDimensions = {{0, {1, 2, 2, 1}}},
776   // int -> FLOAT32 map
777   .float32Operands = {},
778   // int -> INT32 map
779   .int32Operands = {},
780   // int -> QUANT8_ASYMM map
781   .quant8AsymmOperands = {},
782   // int -> QUANT16_SYMM map
783   .quant16SymmOperands = {},
784   // int -> FLOAT16 map
785   .float16Operands = {{0, {0.0f, 0.0f, 12.0f, 0.0f}}},
786   // int -> BOOL8 map
787   .bool8Operands = {},
788   // int -> QUANT8_SYMM_PER_CHANNEL map
789   .quant8ChannelOperands = {},
790   // int -> QUANT16_ASYMM map
791   .quant16AsymmOperands = {},
792   // int -> QUANT8_SYMM map
793   .quant8SymmOperands = {},
794 }
795 },
796 }, // End of an example
797 };
798 return examples_dynamic_output_shape_float16_relu;
799 };
800 
get_examples_dynamic_output_shape_float16_relu1()801 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_float16_relu1() {
802 static std::vector<MixedTypedExample> examples_dynamic_output_shape_float16_relu1 = {
803 // Begin of an example
804 {
805 .operands = {
806 //Input(s)
807 { // See tools/test_generator/include/TestHarness.h:MixedTyped
808   // int -> Dimensions map
809   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
810   // int -> FLOAT32 map
811   .float32Operands = {},
812   // int -> INT32 map
813   .int32Operands = {},
814   // int -> QUANT8_ASYMM map
815   .quant8AsymmOperands = {},
816   // int -> QUANT16_SYMM map
817   .quant16SymmOperands = {},
818   // int -> FLOAT16 map
819   .float16Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
820   // int -> BOOL8 map
821   .bool8Operands = {},
822   // int -> QUANT8_SYMM_PER_CHANNEL map
823   .quant8ChannelOperands = {},
824   // int -> QUANT16_ASYMM map
825   .quant16AsymmOperands = {},
826   // int -> QUANT8_SYMM map
827   .quant8SymmOperands = {},
828 },
829 //Output(s)
830 { // See tools/test_generator/include/TestHarness.h:MixedTyped
831   // int -> Dimensions map
832   .operandDimensions = {{0, {1, 2, 2, 1}}},
833   // int -> FLOAT32 map
834   .float32Operands = {},
835   // int -> INT32 map
836   .int32Operands = {},
837   // int -> QUANT8_ASYMM map
838   .quant8AsymmOperands = {},
839   // int -> QUANT16_SYMM map
840   .quant16SymmOperands = {},
841   // int -> FLOAT16 map
842   .float16Operands = {{0, {0.0f, -1.0f, 1.0f, -1.0f}}},
843   // int -> BOOL8 map
844   .bool8Operands = {},
845   // int -> QUANT8_SYMM_PER_CHANNEL map
846   .quant8ChannelOperands = {},
847   // int -> QUANT16_ASYMM map
848   .quant16AsymmOperands = {},
849   // int -> QUANT8_SYMM map
850   .quant8SymmOperands = {},
851 }
852 },
853 }, // End of an example
854 };
855 return examples_dynamic_output_shape_float16_relu1;
856 };
857 
get_examples_dynamic_output_shape_float16_relu6()858 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_float16_relu6() {
859 static std::vector<MixedTypedExample> examples_dynamic_output_shape_float16_relu6 = {
860 // Begin of an example
861 {
862 .operands = {
863 //Input(s)
864 { // See tools/test_generator/include/TestHarness.h:MixedTyped
865   // int -> Dimensions map
866   .operandDimensions = {{0, {1, 2, 2, 1}}, {1, {1, 2, 2, 1}}},
867   // int -> FLOAT32 map
868   .float32Operands = {},
869   // int -> INT32 map
870   .int32Operands = {},
871   // int -> QUANT8_ASYMM map
872   .quant8AsymmOperands = {},
873   // int -> QUANT16_SYMM map
874   .quant16SymmOperands = {},
875   // int -> FLOAT16 map
876   .float16Operands = {{0, {2.0f, -4.0f, 8.0f, -16.0f}}, {1, {2.0f, -2.0f, -4.0f, 4.0f}}},
877   // int -> BOOL8 map
878   .bool8Operands = {},
879   // int -> QUANT8_SYMM_PER_CHANNEL map
880   .quant8ChannelOperands = {},
881   // int -> QUANT16_ASYMM map
882   .quant16AsymmOperands = {},
883   // int -> QUANT8_SYMM map
884   .quant8SymmOperands = {},
885 },
886 //Output(s)
887 { // See tools/test_generator/include/TestHarness.h:MixedTyped
888   // int -> Dimensions map
889   .operandDimensions = {{0, {1, 2, 2, 1}}},
890   // int -> FLOAT32 map
891   .float32Operands = {},
892   // int -> INT32 map
893   .int32Operands = {},
894   // int -> QUANT8_ASYMM map
895   .quant8AsymmOperands = {},
896   // int -> QUANT16_SYMM map
897   .quant16SymmOperands = {},
898   // int -> FLOAT16 map
899   .float16Operands = {{0, {0.0f, 0.0f, 6.0f, 0.0f}}},
900   // int -> BOOL8 map
901   .bool8Operands = {},
902   // int -> QUANT8_SYMM_PER_CHANNEL map
903   .quant8ChannelOperands = {},
904   // int -> QUANT16_ASYMM map
905   .quant16AsymmOperands = {},
906   // int -> QUANT8_SYMM map
907   .quant8SymmOperands = {},
908 }
909 },
910 }, // End of an example
911 };
912 return examples_dynamic_output_shape_float16_relu6;
913 };
914 
get_examples_quant8()915 std::vector<MixedTypedExample>& get_examples_quant8() {
916 static std::vector<MixedTypedExample> examples_quant8 = {
917 // Begin of an example
918 {
919 .operands = {
920 //Input(s)
921 { // See tools/test_generator/include/TestHarness.h:MixedTyped
922   // int -> Dimensions map
923   .operandDimensions = {{0, {2, 4, 16, 2}}, {1, {2, 4, 16, 2}}},
924   // int -> FLOAT32 map
925   .float32Operands = {},
926   // int -> INT32 map
927   .int32Operands = {},
928   // int -> QUANT8_ASYMM map
929   .quant8AsymmOperands = {{0, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255}}, {1, {1, 88, 132, 233, 162, 39, 185, 237, 238, 159, 164, 76, 59, 144, 97, 94, 214, 196, 213, 221, 65, 116, 49, 222, 224, 63, 51, 118, 157, 106, 53, 45, 191, 58, 253, 71, 148, 254, 131, 40, 43, 57, 13, 128, 178, 30, 46, 226, 183, 67, 243, 44, 6, 192, 172, 29, 32, 210, 82, 170, 142, 19, 231, 127, 161, 146, 168, 195, 105, 69, 249, 246, 26, 151, 215, 190, 92, 245, 86, 4, 112, 109, 11, 50, 99, 96, 176, 117, 95, 244, 198, 177, 87, 169, 68, 153, 229, 5, 110, 89, 218, 137, 12, 7, 104, 54, 119, 21, 101, 155, 28, 211, 123, 34, 93, 2, 166, 230, 108, 42, 209, 75, 187, 14, 78, 41, 251, 240, 189, 115, 135, 252, 236, 60, 202, 70, 134, 100, 174, 9, 38, 33, 22, 17, 121, 201, 8, 239, 182, 47, 167, 179, 147, 173, 98, 152, 216, 203, 73, 150, 165, 223, 206, 138, 188, 199, 31, 74, 205, 242, 27, 125, 248, 81, 20, 255, 114, 139, 36, 61, 56, 145, 48, 16, 225, 83, 219, 62, 85, 126, 208, 0, 160, 171, 181, 102, 184, 23, 3, 140, 15, 250, 133, 113, 241, 141, 52, 163, 156, 80, 111, 90, 220, 143, 120, 84, 175, 217, 18, 186, 25, 79, 37, 154, 207, 180, 136, 64, 204, 158, 24, 193, 234, 72, 35, 129, 55, 232, 228, 149, 91, 122, 77, 212, 200, 235, 103, 124, 130, 247, 66, 10, 107, 227, 194, 197}}},
930   // int -> QUANT16_SYMM map
931   .quant16SymmOperands = {},
932   // int -> FLOAT16 map
933   .float16Operands = {},
934   // int -> BOOL8 map
935   .bool8Operands = {},
936   // int -> QUANT8_SYMM_PER_CHANNEL map
937   .quant8ChannelOperands = {},
938   // int -> QUANT16_ASYMM map
939   .quant16AsymmOperands = {},
940   // int -> QUANT8_SYMM map
941   .quant8SymmOperands = {},
942 },
943 //Output(s)
944 { // See tools/test_generator/include/TestHarness.h:MixedTyped
945   // int -> Dimensions map
946   .operandDimensions = {{0, {2, 4, 16, 2}}},
947   // int -> FLOAT32 map
948   .float32Operands = {},
949   // int -> INT32 map
950   .int32Operands = {},
951   // int -> QUANT8_ASYMM map
952   .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 0, 0, 15, 0, 0, 0, 0, 0, 7, 46, 0, 0, 26, 24, 0, 0, 0, 0, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 75, 0, 0, 71, 33, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 26, 0, 0, 92, 0, 10, 0, 0, 90, 96, 0, 51, 0, 86, 7, 0, 82, 0, 0, 79, 21, 113, 0, 0, 10, 77, 0, 46, 0, 109, 46, 84, 0, 0, 0, 14, 0, 0, 0, 73, 0, 65, 2, 37, 0, 130, 102, 108, 120, 126, 23, 0, 138, 0, 0, 102, 0, 0, 5, 0, 56, 3, 0, 0, 85, 9, 0, 0, 0, 25, 0, 0, 135, 93, 0, 0, 143, 46, 0, 92, 154, 0, 62, 38, 142, 118, 124, 36, 134, 167, 0, 102, 0, 125, 103, 63, 0, 191, 32, 22, 13, 93, 12, 174, 195, 59, 185, 0, 69, 90, 0, 64, 154, 44, 52, 129, 99, 121, 0, 70, 94, 131, 41, 0, 200, 33, 195, 142, 185, 69, 17, 45, 90, 163, 24, 71, 206, 38, 0, 161, 199, 106, 181, 5, 10, 90, 149, 119, 165, 31, 44, 10, 143, 123, 118, 2, 184, 241, 145, 26, 60, 58}}},
953   // int -> QUANT16_SYMM map
954   .quant16SymmOperands = {},
955   // int -> FLOAT16 map
956   .float16Operands = {},
957   // int -> BOOL8 map
958   .bool8Operands = {},
959   // int -> QUANT8_SYMM_PER_CHANNEL map
960   .quant8ChannelOperands = {},
961   // int -> QUANT16_ASYMM map
962   .quant16AsymmOperands = {},
963   // int -> QUANT8_SYMM map
964   .quant8SymmOperands = {},
965 }
966 },
967 }, // End of an example
968 };
969 return examples_quant8;
970 };
971 
get_examples_quant8_dynamic_output_shape()972 std::vector<MixedTypedExample>& get_examples_quant8_dynamic_output_shape() {
973 static std::vector<MixedTypedExample> examples_quant8_dynamic_output_shape = {
974 // Begin of an example
975 {
976 .operands = {
977 //Input(s)
978 { // See tools/test_generator/include/TestHarness.h:MixedTyped
979   // int -> Dimensions map
980   .operandDimensions = {{0, {2, 4, 16, 2}}, {1, {2, 4, 16, 2}}},
981   // int -> FLOAT32 map
982   .float32Operands = {},
983   // int -> INT32 map
984   .int32Operands = {},
985   // int -> QUANT8_ASYMM map
986   .quant8AsymmOperands = {{0, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255}}, {1, {1, 88, 132, 233, 162, 39, 185, 237, 238, 159, 164, 76, 59, 144, 97, 94, 214, 196, 213, 221, 65, 116, 49, 222, 224, 63, 51, 118, 157, 106, 53, 45, 191, 58, 253, 71, 148, 254, 131, 40, 43, 57, 13, 128, 178, 30, 46, 226, 183, 67, 243, 44, 6, 192, 172, 29, 32, 210, 82, 170, 142, 19, 231, 127, 161, 146, 168, 195, 105, 69, 249, 246, 26, 151, 215, 190, 92, 245, 86, 4, 112, 109, 11, 50, 99, 96, 176, 117, 95, 244, 198, 177, 87, 169, 68, 153, 229, 5, 110, 89, 218, 137, 12, 7, 104, 54, 119, 21, 101, 155, 28, 211, 123, 34, 93, 2, 166, 230, 108, 42, 209, 75, 187, 14, 78, 41, 251, 240, 189, 115, 135, 252, 236, 60, 202, 70, 134, 100, 174, 9, 38, 33, 22, 17, 121, 201, 8, 239, 182, 47, 167, 179, 147, 173, 98, 152, 216, 203, 73, 150, 165, 223, 206, 138, 188, 199, 31, 74, 205, 242, 27, 125, 248, 81, 20, 255, 114, 139, 36, 61, 56, 145, 48, 16, 225, 83, 219, 62, 85, 126, 208, 0, 160, 171, 181, 102, 184, 23, 3, 140, 15, 250, 133, 113, 241, 141, 52, 163, 156, 80, 111, 90, 220, 143, 120, 84, 175, 217, 18, 186, 25, 79, 37, 154, 207, 180, 136, 64, 204, 158, 24, 193, 234, 72, 35, 129, 55, 232, 228, 149, 91, 122, 77, 212, 200, 235, 103, 124, 130, 247, 66, 10, 107, 227, 194, 197}}},
987   // int -> QUANT16_SYMM map
988   .quant16SymmOperands = {},
989   // int -> FLOAT16 map
990   .float16Operands = {},
991   // int -> BOOL8 map
992   .bool8Operands = {},
993   // int -> QUANT8_SYMM_PER_CHANNEL map
994   .quant8ChannelOperands = {},
995   // int -> QUANT16_ASYMM map
996   .quant16AsymmOperands = {},
997   // int -> QUANT8_SYMM map
998   .quant8SymmOperands = {},
999 },
1000 //Output(s)
1001 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1002   // int -> Dimensions map
1003   .operandDimensions = {{0, {2, 4, 16, 2}}},
1004   // int -> FLOAT32 map
1005   .float32Operands = {},
1006   // int -> INT32 map
1007   .int32Operands = {},
1008   // int -> QUANT8_ASYMM map
1009   .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 0, 0, 15, 0, 0, 0, 0, 0, 7, 46, 0, 0, 26, 24, 0, 0, 0, 0, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, 0, 0, 0, 0, 0, 75, 0, 0, 71, 33, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 26, 0, 0, 92, 0, 10, 0, 0, 90, 96, 0, 51, 0, 86, 7, 0, 82, 0, 0, 79, 21, 113, 0, 0, 10, 77, 0, 46, 0, 109, 46, 84, 0, 0, 0, 14, 0, 0, 0, 73, 0, 65, 2, 37, 0, 130, 102, 108, 120, 126, 23, 0, 138, 0, 0, 102, 0, 0, 5, 0, 56, 3, 0, 0, 85, 9, 0, 0, 0, 25, 0, 0, 135, 93, 0, 0, 143, 46, 0, 92, 154, 0, 62, 38, 142, 118, 124, 36, 134, 167, 0, 102, 0, 125, 103, 63, 0, 191, 32, 22, 13, 93, 12, 174, 195, 59, 185, 0, 69, 90, 0, 64, 154, 44, 52, 129, 99, 121, 0, 70, 94, 131, 41, 0, 200, 33, 195, 142, 185, 69, 17, 45, 90, 163, 24, 71, 206, 38, 0, 161, 199, 106, 181, 5, 10, 90, 149, 119, 165, 31, 44, 10, 143, 123, 118, 2, 184, 241, 145, 26, 60, 58}}},
1010   // int -> QUANT16_SYMM map
1011   .quant16SymmOperands = {},
1012   // int -> FLOAT16 map
1013   .float16Operands = {},
1014   // int -> BOOL8 map
1015   .bool8Operands = {},
1016   // int -> QUANT8_SYMM_PER_CHANNEL map
1017   .quant8ChannelOperands = {},
1018   // int -> QUANT16_ASYMM map
1019   .quant16AsymmOperands = {},
1020   // int -> QUANT8_SYMM map
1021   .quant8SymmOperands = {},
1022 }
1023 },
1024 }, // End of an example
1025 };
1026 return examples_quant8_dynamic_output_shape;
1027 };
1028 
get_examples_zero_sized()1029 std::vector<MixedTypedExample>& get_examples_zero_sized() {
1030 static std::vector<MixedTypedExample> examples_zero_sized = {
1031 // Begin of an example
1032 {
1033 .operands = {
1034 //Input(s)
1035 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1036   // int -> Dimensions map
1037   .operandDimensions = {{0, {1, 1, 1, 2}}},
1038   // int -> FLOAT32 map
1039   .float32Operands = {{0, {1.0f, 2.0f}}},
1040   // int -> INT32 map
1041   .int32Operands = {},
1042   // int -> QUANT8_ASYMM map
1043   .quant8AsymmOperands = {},
1044   // int -> QUANT16_SYMM map
1045   .quant16SymmOperands = {},
1046   // int -> FLOAT16 map
1047   .float16Operands = {},
1048   // int -> BOOL8 map
1049   .bool8Operands = {},
1050   // int -> QUANT8_SYMM_PER_CHANNEL map
1051   .quant8ChannelOperands = {},
1052   // int -> QUANT16_ASYMM map
1053   .quant16AsymmOperands = {},
1054   // int -> QUANT8_SYMM map
1055   .quant8SymmOperands = {},
1056 },
1057 //Output(s)
1058 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1059   // int -> Dimensions map
1060   .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 2, 2}}},
1061   // int -> FLOAT32 map
1062   .float32Operands = {{0, {0.0f}}, {2, {0.0f}}},
1063   // int -> INT32 map
1064   .int32Operands = {{1, {0}}},
1065   // int -> QUANT8_ASYMM map
1066   .quant8AsymmOperands = {},
1067   // int -> QUANT16_SYMM map
1068   .quant16SymmOperands = {},
1069   // int -> FLOAT16 map
1070   .float16Operands = {},
1071   // int -> BOOL8 map
1072   .bool8Operands = {},
1073   // int -> QUANT8_SYMM_PER_CHANNEL map
1074   .quant8ChannelOperands = {},
1075   // int -> QUANT16_ASYMM map
1076   .quant16AsymmOperands = {},
1077   // int -> QUANT8_SYMM map
1078   .quant8SymmOperands = {},
1079 }
1080 },
1081 }, // End of an example
1082 };
1083 return examples_zero_sized;
1084 };
1085 
get_examples_zero_sized_relaxed()1086 std::vector<MixedTypedExample>& get_examples_zero_sized_relaxed() {
1087 static std::vector<MixedTypedExample> examples_zero_sized_relaxed = {
1088 // Begin of an example
1089 {
1090 .operands = {
1091 //Input(s)
1092 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1093   // int -> Dimensions map
1094   .operandDimensions = {{0, {1, 1, 1, 2}}},
1095   // int -> FLOAT32 map
1096   .float32Operands = {{0, {1.0f, 2.0f}}},
1097   // int -> INT32 map
1098   .int32Operands = {},
1099   // int -> QUANT8_ASYMM map
1100   .quant8AsymmOperands = {},
1101   // int -> QUANT16_SYMM map
1102   .quant16SymmOperands = {},
1103   // int -> FLOAT16 map
1104   .float16Operands = {},
1105   // int -> BOOL8 map
1106   .bool8Operands = {},
1107   // int -> QUANT8_SYMM_PER_CHANNEL map
1108   .quant8ChannelOperands = {},
1109   // int -> QUANT16_ASYMM map
1110   .quant16AsymmOperands = {},
1111   // int -> QUANT8_SYMM map
1112   .quant8SymmOperands = {},
1113 },
1114 //Output(s)
1115 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1116   // int -> Dimensions map
1117   .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 2, 2}}},
1118   // int -> FLOAT32 map
1119   .float32Operands = {{0, {0.0f}}, {2, {0.0f}}},
1120   // int -> INT32 map
1121   .int32Operands = {{1, {0}}},
1122   // int -> QUANT8_ASYMM map
1123   .quant8AsymmOperands = {},
1124   // int -> QUANT16_SYMM map
1125   .quant16SymmOperands = {},
1126   // int -> FLOAT16 map
1127   .float16Operands = {},
1128   // int -> BOOL8 map
1129   .bool8Operands = {},
1130   // int -> QUANT8_SYMM_PER_CHANNEL map
1131   .quant8ChannelOperands = {},
1132   // int -> QUANT16_ASYMM map
1133   .quant16AsymmOperands = {},
1134   // int -> QUANT8_SYMM map
1135   .quant8SymmOperands = {},
1136 }
1137 },
1138 }, // End of an example
1139 };
1140 return examples_zero_sized_relaxed;
1141 };
1142 
get_examples_zero_sized_quant8()1143 std::vector<MixedTypedExample>& get_examples_zero_sized_quant8() {
1144 static std::vector<MixedTypedExample> examples_zero_sized_quant8 = {
1145 // Begin of an example
1146 {
1147 .operands = {
1148 //Input(s)
1149 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1150   // int -> Dimensions map
1151   .operandDimensions = {{0, {1, 1, 1, 2}}},
1152   // int -> FLOAT32 map
1153   .float32Operands = {},
1154   // int -> INT32 map
1155   .int32Operands = {},
1156   // int -> QUANT8_ASYMM map
1157   .quant8AsymmOperands = {{0, {138, 148}}},
1158   // int -> QUANT16_SYMM map
1159   .quant16SymmOperands = {},
1160   // int -> FLOAT16 map
1161   .float16Operands = {},
1162   // int -> BOOL8 map
1163   .bool8Operands = {},
1164   // int -> QUANT8_SYMM_PER_CHANNEL map
1165   .quant8ChannelOperands = {},
1166   // int -> QUANT16_ASYMM map
1167   .quant16AsymmOperands = {},
1168   // int -> QUANT8_SYMM map
1169   .quant8SymmOperands = {},
1170 },
1171 //Output(s)
1172 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1173   // int -> Dimensions map
1174   .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 2, 2}}},
1175   // int -> FLOAT32 map
1176   .float32Operands = {},
1177   // int -> INT32 map
1178   .int32Operands = {{1, {0}}},
1179   // int -> QUANT8_ASYMM map
1180   .quant8AsymmOperands = {{0, {0}}, {2, {0}}},
1181   // int -> QUANT16_SYMM map
1182   .quant16SymmOperands = {},
1183   // int -> FLOAT16 map
1184   .float16Operands = {},
1185   // int -> BOOL8 map
1186   .bool8Operands = {},
1187   // int -> QUANT8_SYMM_PER_CHANNEL map
1188   .quant8ChannelOperands = {},
1189   // int -> QUANT16_ASYMM map
1190   .quant16AsymmOperands = {},
1191   // int -> QUANT8_SYMM map
1192   .quant8SymmOperands = {},
1193 }
1194 },
1195 }, // End of an example
1196 };
1197 return examples_zero_sized_quant8;
1198 };
1199 
get_examples_zero_sized_float16()1200 std::vector<MixedTypedExample>& get_examples_zero_sized_float16() {
1201 static std::vector<MixedTypedExample> examples_zero_sized_float16 = {
1202 // Begin of an example
1203 {
1204 .operands = {
1205 //Input(s)
1206 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1207   // int -> Dimensions map
1208   .operandDimensions = {{0, {1, 1, 1, 2}}},
1209   // int -> FLOAT32 map
1210   .float32Operands = {},
1211   // int -> INT32 map
1212   .int32Operands = {},
1213   // int -> QUANT8_ASYMM map
1214   .quant8AsymmOperands = {},
1215   // int -> QUANT16_SYMM map
1216   .quant16SymmOperands = {},
1217   // int -> FLOAT16 map
1218   .float16Operands = {{0, {1.0f, 2.0f}}},
1219   // int -> BOOL8 map
1220   .bool8Operands = {},
1221   // int -> QUANT8_SYMM_PER_CHANNEL map
1222   .quant8ChannelOperands = {},
1223   // int -> QUANT16_ASYMM map
1224   .quant16AsymmOperands = {},
1225   // int -> QUANT8_SYMM map
1226   .quant8SymmOperands = {},
1227 },
1228 //Output(s)
1229 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1230   // int -> Dimensions map
1231   .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 2, 2}}},
1232   // int -> FLOAT32 map
1233   .float32Operands = {},
1234   // int -> INT32 map
1235   .int32Operands = {{1, {0}}},
1236   // int -> QUANT8_ASYMM map
1237   .quant8AsymmOperands = {},
1238   // int -> QUANT16_SYMM map
1239   .quant16SymmOperands = {},
1240   // int -> FLOAT16 map
1241   .float16Operands = {{0, {0.0f}}, {2, {0.0f}}},
1242   // int -> BOOL8 map
1243   .bool8Operands = {},
1244   // int -> QUANT8_SYMM_PER_CHANNEL map
1245   .quant8ChannelOperands = {},
1246   // int -> QUANT16_ASYMM map
1247   .quant16AsymmOperands = {},
1248   // int -> QUANT8_SYMM map
1249   .quant8SymmOperands = {},
1250 }
1251 },
1252 }, // End of an example
1253 };
1254 return examples_zero_sized_float16;
1255 };
1256 
get_examples_zero_sized_dynamic_output_shape()1257 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape() {
1258 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape = {
1259 // Begin of an example
1260 {
1261 .operands = {
1262 //Input(s)
1263 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1264   // int -> Dimensions map
1265   .operandDimensions = {{0, {1, 1, 1, 2}}},
1266   // int -> FLOAT32 map
1267   .float32Operands = {{0, {1.0f, 2.0f}}},
1268   // int -> INT32 map
1269   .int32Operands = {},
1270   // int -> QUANT8_ASYMM map
1271   .quant8AsymmOperands = {},
1272   // int -> QUANT16_SYMM map
1273   .quant16SymmOperands = {},
1274   // int -> FLOAT16 map
1275   .float16Operands = {},
1276   // int -> BOOL8 map
1277   .bool8Operands = {},
1278   // int -> QUANT8_SYMM_PER_CHANNEL map
1279   .quant8ChannelOperands = {},
1280   // int -> QUANT16_ASYMM map
1281   .quant16AsymmOperands = {},
1282   // int -> QUANT8_SYMM map
1283   .quant8SymmOperands = {},
1284 },
1285 //Output(s)
1286 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1287   // int -> Dimensions map
1288   .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 2, 2}}},
1289   // int -> FLOAT32 map
1290   .float32Operands = {{0, {0.0f}}, {2, {0.0f}}},
1291   // int -> INT32 map
1292   .int32Operands = {{1, {0}}},
1293   // int -> QUANT8_ASYMM map
1294   .quant8AsymmOperands = {},
1295   // int -> QUANT16_SYMM map
1296   .quant16SymmOperands = {},
1297   // int -> FLOAT16 map
1298   .float16Operands = {},
1299   // int -> BOOL8 map
1300   .bool8Operands = {},
1301   // int -> QUANT8_SYMM_PER_CHANNEL map
1302   .quant8ChannelOperands = {},
1303   // int -> QUANT16_ASYMM map
1304   .quant16AsymmOperands = {},
1305   // int -> QUANT8_SYMM map
1306   .quant8SymmOperands = {},
1307 }
1308 },
1309 }, // End of an example
1310 };
1311 return examples_zero_sized_dynamic_output_shape;
1312 };
1313 
get_examples_zero_sized_dynamic_output_shape_relaxed()1314 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_relaxed() {
1315 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_relaxed = {
1316 // Begin of an example
1317 {
1318 .operands = {
1319 //Input(s)
1320 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1321   // int -> Dimensions map
1322   .operandDimensions = {{0, {1, 1, 1, 2}}},
1323   // int -> FLOAT32 map
1324   .float32Operands = {{0, {1.0f, 2.0f}}},
1325   // int -> INT32 map
1326   .int32Operands = {},
1327   // int -> QUANT8_ASYMM map
1328   .quant8AsymmOperands = {},
1329   // int -> QUANT16_SYMM map
1330   .quant16SymmOperands = {},
1331   // int -> FLOAT16 map
1332   .float16Operands = {},
1333   // int -> BOOL8 map
1334   .bool8Operands = {},
1335   // int -> QUANT8_SYMM_PER_CHANNEL map
1336   .quant8ChannelOperands = {},
1337   // int -> QUANT16_ASYMM map
1338   .quant16AsymmOperands = {},
1339   // int -> QUANT8_SYMM map
1340   .quant8SymmOperands = {},
1341 },
1342 //Output(s)
1343 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1344   // int -> Dimensions map
1345   .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 2, 2}}},
1346   // int -> FLOAT32 map
1347   .float32Operands = {{0, {0.0f}}, {2, {0.0f}}},
1348   // int -> INT32 map
1349   .int32Operands = {{1, {0}}},
1350   // int -> QUANT8_ASYMM map
1351   .quant8AsymmOperands = {},
1352   // int -> QUANT16_SYMM map
1353   .quant16SymmOperands = {},
1354   // int -> FLOAT16 map
1355   .float16Operands = {},
1356   // int -> BOOL8 map
1357   .bool8Operands = {},
1358   // int -> QUANT8_SYMM_PER_CHANNEL map
1359   .quant8ChannelOperands = {},
1360   // int -> QUANT16_ASYMM map
1361   .quant16AsymmOperands = {},
1362   // int -> QUANT8_SYMM map
1363   .quant8SymmOperands = {},
1364 }
1365 },
1366 }, // End of an example
1367 };
1368 return examples_zero_sized_dynamic_output_shape_relaxed;
1369 };
1370 
get_examples_zero_sized_dynamic_output_shape_quant8()1371 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_quant8() {
1372 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_quant8 = {
1373 // Begin of an example
1374 {
1375 .operands = {
1376 //Input(s)
1377 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1378   // int -> Dimensions map
1379   .operandDimensions = {{0, {1, 1, 1, 2}}},
1380   // int -> FLOAT32 map
1381   .float32Operands = {},
1382   // int -> INT32 map
1383   .int32Operands = {},
1384   // int -> QUANT8_ASYMM map
1385   .quant8AsymmOperands = {{0, {138, 148}}},
1386   // int -> QUANT16_SYMM map
1387   .quant16SymmOperands = {},
1388   // int -> FLOAT16 map
1389   .float16Operands = {},
1390   // int -> BOOL8 map
1391   .bool8Operands = {},
1392   // int -> QUANT8_SYMM_PER_CHANNEL map
1393   .quant8ChannelOperands = {},
1394   // int -> QUANT16_ASYMM map
1395   .quant16AsymmOperands = {},
1396   // int -> QUANT8_SYMM map
1397   .quant8SymmOperands = {},
1398 },
1399 //Output(s)
1400 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1401   // int -> Dimensions map
1402   .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 2, 2}}},
1403   // int -> FLOAT32 map
1404   .float32Operands = {},
1405   // int -> INT32 map
1406   .int32Operands = {{1, {0}}},
1407   // int -> QUANT8_ASYMM map
1408   .quant8AsymmOperands = {{0, {0}}, {2, {0}}},
1409   // int -> QUANT16_SYMM map
1410   .quant16SymmOperands = {},
1411   // int -> FLOAT16 map
1412   .float16Operands = {},
1413   // int -> BOOL8 map
1414   .bool8Operands = {},
1415   // int -> QUANT8_SYMM_PER_CHANNEL map
1416   .quant8ChannelOperands = {},
1417   // int -> QUANT16_ASYMM map
1418   .quant16AsymmOperands = {},
1419   // int -> QUANT8_SYMM map
1420   .quant8SymmOperands = {},
1421 }
1422 },
1423 }, // End of an example
1424 };
1425 return examples_zero_sized_dynamic_output_shape_quant8;
1426 };
1427 
get_examples_zero_sized_dynamic_output_shape_float16()1428 std::vector<MixedTypedExample>& get_examples_zero_sized_dynamic_output_shape_float16() {
1429 static std::vector<MixedTypedExample> examples_zero_sized_dynamic_output_shape_float16 = {
1430 // Begin of an example
1431 {
1432 .operands = {
1433 //Input(s)
1434 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1435   // int -> Dimensions map
1436   .operandDimensions = {{0, {1, 1, 1, 2}}},
1437   // int -> FLOAT32 map
1438   .float32Operands = {},
1439   // int -> INT32 map
1440   .int32Operands = {},
1441   // int -> QUANT8_ASYMM map
1442   .quant8AsymmOperands = {},
1443   // int -> QUANT16_SYMM map
1444   .quant16SymmOperands = {},
1445   // int -> FLOAT16 map
1446   .float16Operands = {{0, {1.0f, 2.0f}}},
1447   // int -> BOOL8 map
1448   .bool8Operands = {},
1449   // int -> QUANT8_SYMM_PER_CHANNEL map
1450   .quant8ChannelOperands = {},
1451   // int -> QUANT16_ASYMM map
1452   .quant16AsymmOperands = {},
1453   // int -> QUANT8_SYMM map
1454   .quant8SymmOperands = {},
1455 },
1456 //Output(s)
1457 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1458   // int -> Dimensions map
1459   .operandDimensions = {{0, {0}}, {1, {0}}, {2, {0, 2, 2, 2}}},
1460   // int -> FLOAT32 map
1461   .float32Operands = {},
1462   // int -> INT32 map
1463   .int32Operands = {{1, {0}}},
1464   // int -> QUANT8_ASYMM map
1465   .quant8AsymmOperands = {},
1466   // int -> QUANT16_SYMM map
1467   .quant16SymmOperands = {},
1468   // int -> FLOAT16 map
1469   .float16Operands = {{0, {0.0f}}, {2, {0.0f}}},
1470   // int -> BOOL8 map
1471   .bool8Operands = {},
1472   // int -> QUANT8_SYMM_PER_CHANNEL map
1473   .quant8ChannelOperands = {},
1474   // int -> QUANT16_ASYMM map
1475   .quant16AsymmOperands = {},
1476   // int -> QUANT8_SYMM map
1477   .quant8SymmOperands = {},
1478 }
1479 },
1480 }, // End of an example
1481 };
1482 return examples_zero_sized_dynamic_output_shape_float16;
1483 };
1484 
1485