1 // clang-format off
2 // Generated file (from: topk_v2.mod.py). Do not edit
get_examples()3 std::vector<MixedTypedExample>& get_examples() {
4 static std::vector<MixedTypedExample> examples = {
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, {2, 2}}},
12   // int -> FLOAT32 map
13   .float32Operands = {{0, {-2.0f, 0.2f, 0.8f, 0.1f}}},
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, {2, 2}}, {1, {2, 2}}},
35   // int -> FLOAT32 map
36   .float32Operands = {{0, {0.2f, -2.0f, 0.8f, 0.1f}}},
37   // int -> INT32 map
38   .int32Operands = {{1, {1, 0, 0, 1}}},
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;
58 };
59 
get_examples_relaxed()60 std::vector<MixedTypedExample>& get_examples_relaxed() {
61 static std::vector<MixedTypedExample> examples_relaxed = {
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, {2, 2}}},
69   // int -> FLOAT32 map
70   .float32Operands = {{0, {-2.0f, 0.2f, 0.8f, 0.1f}}},
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, {2, 2}}, {1, {2, 2}}},
92   // int -> FLOAT32 map
93   .float32Operands = {{0, {0.2f, -2.0f, 0.8f, 0.1f}}},
94   // int -> INT32 map
95   .int32Operands = {{1, {1, 0, 0, 1}}},
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_relaxed;
115 };
116 
get_examples_float16()117 std::vector<MixedTypedExample>& get_examples_float16() {
118 static std::vector<MixedTypedExample> examples_float16 = {
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, {2, 2}}},
126   // int -> FLOAT32 map
127   .float32Operands = {},
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 = {{0, {-2.0f, 0.20000000298023224f, 0.800000011920929f, 0.10000000149011612f}}},
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, {2, 2}}, {1, {2, 2}}},
149   // int -> FLOAT32 map
150   .float32Operands = {},
151   // int -> INT32 map
152   .int32Operands = {{1, {1, 0, 0, 1}}},
153   // int -> QUANT8_ASYMM map
154   .quant8AsymmOperands = {},
155   // int -> QUANT16_SYMM map
156   .quant16SymmOperands = {},
157   // int -> FLOAT16 map
158   .float16Operands = {{0, {0.20000000298023224f, -2.0f, 0.800000011920929f, 0.10000000149011612f}}},
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_float16;
172 };
173 
get_examples_dynamic_output_shape()174 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape() {
175 static std::vector<MixedTypedExample> examples_dynamic_output_shape = {
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, {2, 2}}},
183   // int -> FLOAT32 map
184   .float32Operands = {{0, {-2.0f, 0.2f, 0.8f, 0.1f}}},
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, {2, 2}}, {1, {2, 2}}},
206   // int -> FLOAT32 map
207   .float32Operands = {{0, {0.2f, -2.0f, 0.8f, 0.1f}}},
208   // int -> INT32 map
209   .int32Operands = {{1, {1, 0, 0, 1}}},
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_dynamic_output_shape;
229 };
230 
get_examples_dynamic_output_shape_relaxed()231 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_relaxed() {
232 static std::vector<MixedTypedExample> examples_dynamic_output_shape_relaxed = {
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, {2, 2}}},
240   // int -> FLOAT32 map
241   .float32Operands = {{0, {-2.0f, 0.2f, 0.8f, 0.1f}}},
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 = {},
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, {2, 2}}, {1, {2, 2}}},
263   // int -> FLOAT32 map
264   .float32Operands = {{0, {0.2f, -2.0f, 0.8f, 0.1f}}},
265   // int -> INT32 map
266   .int32Operands = {{1, {1, 0, 0, 1}}},
267   // int -> QUANT8_ASYMM map
268   .quant8AsymmOperands = {},
269   // int -> QUANT16_SYMM map
270   .quant16SymmOperands = {},
271   // int -> FLOAT16 map
272   .float16Operands = {},
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_dynamic_output_shape_relaxed;
286 };
287 
get_examples_dynamic_output_shape_float16()288 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_float16() {
289 static std::vector<MixedTypedExample> examples_dynamic_output_shape_float16 = {
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, {2, 2}}},
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, 0.20000000298023224f, 0.800000011920929f, 0.10000000149011612f}}},
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, {2, 2}}, {1, {2, 2}}},
320   // int -> FLOAT32 map
321   .float32Operands = {},
322   // int -> INT32 map
323   .int32Operands = {{1, {1, 0, 0, 1}}},
324   // int -> QUANT8_ASYMM map
325   .quant8AsymmOperands = {},
326   // int -> QUANT16_SYMM map
327   .quant16SymmOperands = {},
328   // int -> FLOAT16 map
329   .float16Operands = {{0, {0.20000000298023224f, -2.0f, 0.800000011920929f, 0.10000000149011612f}}},
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_dynamic_output_shape_float16;
343 };
344 
get_examples_2()345 std::vector<MixedTypedExample>& get_examples_2() {
346 static std::vector<MixedTypedExample> examples_2 = {
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, {2, 3}}},
354   // int -> FLOAT32 map
355   .float32Operands = {{0, {-2.0f, -3.0f, 0.2f, 0.8f, 0.1f, -0.1f}}},
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 = {},
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, {2, 2}}, {1, {2, 2}}},
377   // int -> FLOAT32 map
378   .float32Operands = {{0, {0.2f, -2.0f, 0.8f, 0.1f}}},
379   // int -> INT32 map
380   .int32Operands = {{1, {2, 0, 0, 1}}},
381   // int -> QUANT8_ASYMM map
382   .quant8AsymmOperands = {},
383   // int -> QUANT16_SYMM map
384   .quant16SymmOperands = {},
385   // int -> FLOAT16 map
386   .float16Operands = {},
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_2;
400 };
401 
get_examples_relaxed_2()402 std::vector<MixedTypedExample>& get_examples_relaxed_2() {
403 static std::vector<MixedTypedExample> examples_relaxed_2 = {
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, {2, 3}}},
411   // int -> FLOAT32 map
412   .float32Operands = {{0, {-2.0f, -3.0f, 0.2f, 0.8f, 0.1f, -0.1f}}},
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 = {},
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, {2, 2}}, {1, {2, 2}}},
434   // int -> FLOAT32 map
435   .float32Operands = {{0, {0.2f, -2.0f, 0.8f, 0.1f}}},
436   // int -> INT32 map
437   .int32Operands = {{1, {2, 0, 0, 1}}},
438   // int -> QUANT8_ASYMM map
439   .quant8AsymmOperands = {},
440   // int -> QUANT16_SYMM map
441   .quant16SymmOperands = {},
442   // int -> FLOAT16 map
443   .float16Operands = {},
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_relaxed_2;
457 };
458 
get_examples_float16_2()459 std::vector<MixedTypedExample>& get_examples_float16_2() {
460 static std::vector<MixedTypedExample> examples_float16_2 = {
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, {2, 3}}},
468   // int -> FLOAT32 map
469   .float32Operands = {},
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 = {{0, {-2.0f, -3.0f, 0.20000000298023224f, 0.800000011920929f, 0.10000000149011612f, -0.10000000149011612f}}},
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, {2, 2}}, {1, {2, 2}}},
491   // int -> FLOAT32 map
492   .float32Operands = {},
493   // int -> INT32 map
494   .int32Operands = {{1, {2, 0, 0, 1}}},
495   // int -> QUANT8_ASYMM map
496   .quant8AsymmOperands = {},
497   // int -> QUANT16_SYMM map
498   .quant16SymmOperands = {},
499   // int -> FLOAT16 map
500   .float16Operands = {{0, {0.20000000298023224f, -2.0f, 0.800000011920929f, 0.10000000149011612f}}},
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_float16_2;
514 };
515 
get_examples_dynamic_output_shape_2()516 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_2() {
517 static std::vector<MixedTypedExample> examples_dynamic_output_shape_2 = {
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, {2, 3}}},
525   // int -> FLOAT32 map
526   .float32Operands = {{0, {-2.0f, -3.0f, 0.2f, 0.8f, 0.1f, -0.1f}}},
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, {2, 2}}, {1, {2, 2}}},
548   // int -> FLOAT32 map
549   .float32Operands = {{0, {0.2f, -2.0f, 0.8f, 0.1f}}},
550   // int -> INT32 map
551   .int32Operands = {{1, {2, 0, 0, 1}}},
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_2;
571 };
572 
get_examples_dynamic_output_shape_relaxed_2()573 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_relaxed_2() {
574 static std::vector<MixedTypedExample> examples_dynamic_output_shape_relaxed_2 = {
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, {2, 3}}},
582   // int -> FLOAT32 map
583   .float32Operands = {{0, {-2.0f, -3.0f, 0.2f, 0.8f, 0.1f, -0.1f}}},
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, {2, 2}}, {1, {2, 2}}},
605   // int -> FLOAT32 map
606   .float32Operands = {{0, {0.2f, -2.0f, 0.8f, 0.1f}}},
607   // int -> INT32 map
608   .int32Operands = {{1, {2, 0, 0, 1}}},
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_relaxed_2;
628 };
629 
get_examples_dynamic_output_shape_float16_2()630 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_float16_2() {
631 static std::vector<MixedTypedExample> examples_dynamic_output_shape_float16_2 = {
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, {2, 3}}},
639   // int -> FLOAT32 map
640   .float32Operands = {},
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 = {{0, {-2.0f, -3.0f, 0.20000000298023224f, 0.800000011920929f, 0.10000000149011612f, -0.10000000149011612f}}},
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, {2, 2}}, {1, {2, 2}}},
662   // int -> FLOAT32 map
663   .float32Operands = {},
664   // int -> INT32 map
665   .int32Operands = {{1, {2, 0, 0, 1}}},
666   // int -> QUANT8_ASYMM map
667   .quant8AsymmOperands = {},
668   // int -> QUANT16_SYMM map
669   .quant16SymmOperands = {},
670   // int -> FLOAT16 map
671   .float16Operands = {{0, {0.20000000298023224f, -2.0f, 0.800000011920929f, 0.10000000149011612f}}},
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_float16_2;
685 };
686 
get_examples_3()687 std::vector<MixedTypedExample>& get_examples_3() {
688 static std::vector<MixedTypedExample> examples_3 = {
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, {2, 4}}},
696   // int -> FLOAT32 map
697   .float32Operands = {{0, {-2.0f, -3.0f, -4.0f, 0.2f, 0.8f, 0.1f, -0.1f, -0.8f}}},
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 = {},
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, {2, 2}}, {1, {2, 2}}},
719   // int -> FLOAT32 map
720   .float32Operands = {{0, {0.2f, -2.0f, 0.8f, 0.1f}}},
721   // int -> INT32 map
722   .int32Operands = {{1, {3, 0, 0, 1}}},
723   // int -> QUANT8_ASYMM map
724   .quant8AsymmOperands = {},
725   // int -> QUANT16_SYMM map
726   .quant16SymmOperands = {},
727   // int -> FLOAT16 map
728   .float16Operands = {},
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_3;
742 };
743 
get_examples_relaxed_3()744 std::vector<MixedTypedExample>& get_examples_relaxed_3() {
745 static std::vector<MixedTypedExample> examples_relaxed_3 = {
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, {2, 4}}},
753   // int -> FLOAT32 map
754   .float32Operands = {{0, {-2.0f, -3.0f, -4.0f, 0.2f, 0.8f, 0.1f, -0.1f, -0.8f}}},
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 = {},
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, {2, 2}}, {1, {2, 2}}},
776   // int -> FLOAT32 map
777   .float32Operands = {{0, {0.2f, -2.0f, 0.8f, 0.1f}}},
778   // int -> INT32 map
779   .int32Operands = {{1, {3, 0, 0, 1}}},
780   // int -> QUANT8_ASYMM map
781   .quant8AsymmOperands = {},
782   // int -> QUANT16_SYMM map
783   .quant16SymmOperands = {},
784   // int -> FLOAT16 map
785   .float16Operands = {},
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_relaxed_3;
799 };
800 
get_examples_float16_3()801 std::vector<MixedTypedExample>& get_examples_float16_3() {
802 static std::vector<MixedTypedExample> examples_float16_3 = {
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, {2, 4}}},
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, -3.0f, -4.0f, 0.20000000298023224f, 0.800000011920929f, 0.10000000149011612f, -0.10000000149011612f, -0.800000011920929f}}},
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, {2, 2}}, {1, {2, 2}}},
833   // int -> FLOAT32 map
834   .float32Operands = {},
835   // int -> INT32 map
836   .int32Operands = {{1, {3, 0, 0, 1}}},
837   // int -> QUANT8_ASYMM map
838   .quant8AsymmOperands = {},
839   // int -> QUANT16_SYMM map
840   .quant16SymmOperands = {},
841   // int -> FLOAT16 map
842   .float16Operands = {{0, {0.20000000298023224f, -2.0f, 0.800000011920929f, 0.10000000149011612f}}},
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_float16_3;
856 };
857 
get_examples_dynamic_output_shape_3()858 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_3() {
859 static std::vector<MixedTypedExample> examples_dynamic_output_shape_3 = {
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, {2, 4}}},
867   // int -> FLOAT32 map
868   .float32Operands = {{0, {-2.0f, -3.0f, -4.0f, 0.2f, 0.8f, 0.1f, -0.1f, -0.8f}}},
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 = {},
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, {2, 2}}, {1, {2, 2}}},
890   // int -> FLOAT32 map
891   .float32Operands = {{0, {0.2f, -2.0f, 0.8f, 0.1f}}},
892   // int -> INT32 map
893   .int32Operands = {{1, {3, 0, 0, 1}}},
894   // int -> QUANT8_ASYMM map
895   .quant8AsymmOperands = {},
896   // int -> QUANT16_SYMM map
897   .quant16SymmOperands = {},
898   // int -> FLOAT16 map
899   .float16Operands = {},
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_3;
913 };
914 
get_examples_dynamic_output_shape_relaxed_3()915 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_relaxed_3() {
916 static std::vector<MixedTypedExample> examples_dynamic_output_shape_relaxed_3 = {
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}}},
924   // int -> FLOAT32 map
925   .float32Operands = {{0, {-2.0f, -3.0f, -4.0f, 0.2f, 0.8f, 0.1f, -0.1f, -0.8f}}},
926   // int -> INT32 map
927   .int32Operands = {},
928   // int -> QUANT8_ASYMM map
929   .quant8AsymmOperands = {},
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, 2}}, {1, {2, 2}}},
947   // int -> FLOAT32 map
948   .float32Operands = {{0, {0.2f, -2.0f, 0.8f, 0.1f}}},
949   // int -> INT32 map
950   .int32Operands = {{1, {3, 0, 0, 1}}},
951   // int -> QUANT8_ASYMM map
952   .quant8AsymmOperands = {},
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_dynamic_output_shape_relaxed_3;
970 };
971 
get_examples_dynamic_output_shape_float16_3()972 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_float16_3() {
973 static std::vector<MixedTypedExample> examples_dynamic_output_shape_float16_3 = {
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}}},
981   // int -> FLOAT32 map
982   .float32Operands = {},
983   // int -> INT32 map
984   .int32Operands = {},
985   // int -> QUANT8_ASYMM map
986   .quant8AsymmOperands = {},
987   // int -> QUANT16_SYMM map
988   .quant16SymmOperands = {},
989   // int -> FLOAT16 map
990   .float16Operands = {{0, {-2.0f, -3.0f, -4.0f, 0.20000000298023224f, 0.800000011920929f, 0.10000000149011612f, -0.10000000149011612f, -0.800000011920929f}}},
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, 2}}, {1, {2, 2}}},
1004   // int -> FLOAT32 map
1005   .float32Operands = {},
1006   // int -> INT32 map
1007   .int32Operands = {{1, {3, 0, 0, 1}}},
1008   // int -> QUANT8_ASYMM map
1009   .quant8AsymmOperands = {},
1010   // int -> QUANT16_SYMM map
1011   .quant16SymmOperands = {},
1012   // int -> FLOAT16 map
1013   .float16Operands = {{0, {0.20000000298023224f, -2.0f, 0.800000011920929f, 0.10000000149011612f}}},
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_dynamic_output_shape_float16_3;
1027 };
1028 
get_examples_4()1029 std::vector<MixedTypedExample>& get_examples_4() {
1030 static std::vector<MixedTypedExample> examples_4 = {
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, {8}}},
1038   // int -> FLOAT32 map
1039   .float32Operands = {{0, {-2.0f, -3.0f, -4.0f, 0.2f, 0.8f, 0.1f, -0.1f, -0.8f}}},
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, {2}}, {1, {2}}},
1061   // int -> FLOAT32 map
1062   .float32Operands = {{0, {0.8f, 0.2f}}},
1063   // int -> INT32 map
1064   .int32Operands = {{1, {4, 3}}},
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_4;
1084 };
1085 
get_examples_relaxed_4()1086 std::vector<MixedTypedExample>& get_examples_relaxed_4() {
1087 static std::vector<MixedTypedExample> examples_relaxed_4 = {
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, {8}}},
1095   // int -> FLOAT32 map
1096   .float32Operands = {{0, {-2.0f, -3.0f, -4.0f, 0.2f, 0.8f, 0.1f, -0.1f, -0.8f}}},
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, {2}}, {1, {2}}},
1118   // int -> FLOAT32 map
1119   .float32Operands = {{0, {0.8f, 0.2f}}},
1120   // int -> INT32 map
1121   .int32Operands = {{1, {4, 3}}},
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_relaxed_4;
1141 };
1142 
get_examples_float16_4()1143 std::vector<MixedTypedExample>& get_examples_float16_4() {
1144 static std::vector<MixedTypedExample> examples_float16_4 = {
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, {8}}},
1152   // int -> FLOAT32 map
1153   .float32Operands = {},
1154   // int -> INT32 map
1155   .int32Operands = {},
1156   // int -> QUANT8_ASYMM map
1157   .quant8AsymmOperands = {},
1158   // int -> QUANT16_SYMM map
1159   .quant16SymmOperands = {},
1160   // int -> FLOAT16 map
1161   .float16Operands = {{0, {-2.0f, -3.0f, -4.0f, 0.20000000298023224f, 0.800000011920929f, 0.10000000149011612f, -0.10000000149011612f, -0.800000011920929f}}},
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, {2}}, {1, {2}}},
1175   // int -> FLOAT32 map
1176   .float32Operands = {},
1177   // int -> INT32 map
1178   .int32Operands = {{1, {4, 3}}},
1179   // int -> QUANT8_ASYMM map
1180   .quant8AsymmOperands = {},
1181   // int -> QUANT16_SYMM map
1182   .quant16SymmOperands = {},
1183   // int -> FLOAT16 map
1184   .float16Operands = {{0, {0.800000011920929f, 0.20000000298023224f}}},
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_float16_4;
1198 };
1199 
get_examples_dynamic_output_shape_4()1200 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_4() {
1201 static std::vector<MixedTypedExample> examples_dynamic_output_shape_4 = {
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, {8}}},
1209   // int -> FLOAT32 map
1210   .float32Operands = {{0, {-2.0f, -3.0f, -4.0f, 0.2f, 0.8f, 0.1f, -0.1f, -0.8f}}},
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 = {},
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, {2}}, {1, {2}}},
1232   // int -> FLOAT32 map
1233   .float32Operands = {{0, {0.8f, 0.2f}}},
1234   // int -> INT32 map
1235   .int32Operands = {{1, {4, 3}}},
1236   // int -> QUANT8_ASYMM map
1237   .quant8AsymmOperands = {},
1238   // int -> QUANT16_SYMM map
1239   .quant16SymmOperands = {},
1240   // int -> FLOAT16 map
1241   .float16Operands = {},
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_dynamic_output_shape_4;
1255 };
1256 
get_examples_dynamic_output_shape_relaxed_4()1257 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_relaxed_4() {
1258 static std::vector<MixedTypedExample> examples_dynamic_output_shape_relaxed_4 = {
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, {8}}},
1266   // int -> FLOAT32 map
1267   .float32Operands = {{0, {-2.0f, -3.0f, -4.0f, 0.2f, 0.8f, 0.1f, -0.1f, -0.8f}}},
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, {2}}, {1, {2}}},
1289   // int -> FLOAT32 map
1290   .float32Operands = {{0, {0.8f, 0.2f}}},
1291   // int -> INT32 map
1292   .int32Operands = {{1, {4, 3}}},
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_dynamic_output_shape_relaxed_4;
1312 };
1313 
get_examples_dynamic_output_shape_float16_4()1314 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_float16_4() {
1315 static std::vector<MixedTypedExample> examples_dynamic_output_shape_float16_4 = {
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, {8}}},
1323   // int -> FLOAT32 map
1324   .float32Operands = {},
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 = {{0, {-2.0f, -3.0f, -4.0f, 0.20000000298023224f, 0.800000011920929f, 0.10000000149011612f, -0.10000000149011612f, -0.800000011920929f}}},
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, {2}}, {1, {2}}},
1346   // int -> FLOAT32 map
1347   .float32Operands = {},
1348   // int -> INT32 map
1349   .int32Operands = {{1, {4, 3}}},
1350   // int -> QUANT8_ASYMM map
1351   .quant8AsymmOperands = {},
1352   // int -> QUANT16_SYMM map
1353   .quant16SymmOperands = {},
1354   // int -> FLOAT16 map
1355   .float16Operands = {{0, {0.800000011920929f, 0.20000000298023224f}}},
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_dynamic_output_shape_float16_4;
1369 };
1370 
get_examples_5()1371 std::vector<MixedTypedExample>& get_examples_5() {
1372 static std::vector<MixedTypedExample> examples_5 = {
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, {2, 3}}},
1380   // int -> FLOAT32 map
1381   .float32Operands = {},
1382   // int -> INT32 map
1383   .int32Operands = {},
1384   // int -> QUANT8_ASYMM map
1385   .quant8AsymmOperands = {{0, {1, 2, 3, 251, 250, 249}}},
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, {2, 2}}, {1, {2, 2}}},
1403   // int -> FLOAT32 map
1404   .float32Operands = {},
1405   // int -> INT32 map
1406   .int32Operands = {{1, {2, 1, 0, 1}}},
1407   // int -> QUANT8_ASYMM map
1408   .quant8AsymmOperands = {{0, {3, 2, 251, 250}}},
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_5;
1426 };
1427 
get_examples_relaxed_5()1428 std::vector<MixedTypedExample>& get_examples_relaxed_5() {
1429 static std::vector<MixedTypedExample> examples_relaxed_5 = {
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, {2, 3}}},
1437   // int -> FLOAT32 map
1438   .float32Operands = {},
1439   // int -> INT32 map
1440   .int32Operands = {},
1441   // int -> QUANT8_ASYMM map
1442   .quant8AsymmOperands = {{0, {1, 2, 3, 251, 250, 249}}},
1443   // int -> QUANT16_SYMM map
1444   .quant16SymmOperands = {},
1445   // int -> FLOAT16 map
1446   .float16Operands = {},
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, {2, 2}}, {1, {2, 2}}},
1460   // int -> FLOAT32 map
1461   .float32Operands = {},
1462   // int -> INT32 map
1463   .int32Operands = {{1, {2, 1, 0, 1}}},
1464   // int -> QUANT8_ASYMM map
1465   .quant8AsymmOperands = {{0, {3, 2, 251, 250}}},
1466   // int -> QUANT16_SYMM map
1467   .quant16SymmOperands = {},
1468   // int -> FLOAT16 map
1469   .float16Operands = {},
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_relaxed_5;
1483 };
1484 
get_examples_float16_5()1485 std::vector<MixedTypedExample>& get_examples_float16_5() {
1486 static std::vector<MixedTypedExample> examples_float16_5 = {
1487 // Begin of an example
1488 {
1489 .operands = {
1490 //Input(s)
1491 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1492   // int -> Dimensions map
1493   .operandDimensions = {{0, {2, 3}}},
1494   // int -> FLOAT32 map
1495   .float32Operands = {},
1496   // int -> INT32 map
1497   .int32Operands = {},
1498   // int -> QUANT8_ASYMM map
1499   .quant8AsymmOperands = {{0, {1, 2, 3, 251, 250, 249}}},
1500   // int -> QUANT16_SYMM map
1501   .quant16SymmOperands = {},
1502   // int -> FLOAT16 map
1503   .float16Operands = {},
1504   // int -> BOOL8 map
1505   .bool8Operands = {},
1506   // int -> QUANT8_SYMM_PER_CHANNEL map
1507   .quant8ChannelOperands = {},
1508   // int -> QUANT16_ASYMM map
1509   .quant16AsymmOperands = {},
1510   // int -> QUANT8_SYMM map
1511   .quant8SymmOperands = {},
1512 },
1513 //Output(s)
1514 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1515   // int -> Dimensions map
1516   .operandDimensions = {{0, {2, 2}}, {1, {2, 2}}},
1517   // int -> FLOAT32 map
1518   .float32Operands = {},
1519   // int -> INT32 map
1520   .int32Operands = {{1, {2, 1, 0, 1}}},
1521   // int -> QUANT8_ASYMM map
1522   .quant8AsymmOperands = {{0, {3, 2, 251, 250}}},
1523   // int -> QUANT16_SYMM map
1524   .quant16SymmOperands = {},
1525   // int -> FLOAT16 map
1526   .float16Operands = {},
1527   // int -> BOOL8 map
1528   .bool8Operands = {},
1529   // int -> QUANT8_SYMM_PER_CHANNEL map
1530   .quant8ChannelOperands = {},
1531   // int -> QUANT16_ASYMM map
1532   .quant16AsymmOperands = {},
1533   // int -> QUANT8_SYMM map
1534   .quant8SymmOperands = {},
1535 }
1536 },
1537 }, // End of an example
1538 };
1539 return examples_float16_5;
1540 };
1541 
get_examples_dynamic_output_shape_5()1542 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_5() {
1543 static std::vector<MixedTypedExample> examples_dynamic_output_shape_5 = {
1544 // Begin of an example
1545 {
1546 .operands = {
1547 //Input(s)
1548 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1549   // int -> Dimensions map
1550   .operandDimensions = {{0, {2, 3}}},
1551   // int -> FLOAT32 map
1552   .float32Operands = {},
1553   // int -> INT32 map
1554   .int32Operands = {},
1555   // int -> QUANT8_ASYMM map
1556   .quant8AsymmOperands = {{0, {1, 2, 3, 251, 250, 249}}},
1557   // int -> QUANT16_SYMM map
1558   .quant16SymmOperands = {},
1559   // int -> FLOAT16 map
1560   .float16Operands = {},
1561   // int -> BOOL8 map
1562   .bool8Operands = {},
1563   // int -> QUANT8_SYMM_PER_CHANNEL map
1564   .quant8ChannelOperands = {},
1565   // int -> QUANT16_ASYMM map
1566   .quant16AsymmOperands = {},
1567   // int -> QUANT8_SYMM map
1568   .quant8SymmOperands = {},
1569 },
1570 //Output(s)
1571 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1572   // int -> Dimensions map
1573   .operandDimensions = {{0, {2, 2}}, {1, {2, 2}}},
1574   // int -> FLOAT32 map
1575   .float32Operands = {},
1576   // int -> INT32 map
1577   .int32Operands = {{1, {2, 1, 0, 1}}},
1578   // int -> QUANT8_ASYMM map
1579   .quant8AsymmOperands = {{0, {3, 2, 251, 250}}},
1580   // int -> QUANT16_SYMM map
1581   .quant16SymmOperands = {},
1582   // int -> FLOAT16 map
1583   .float16Operands = {},
1584   // int -> BOOL8 map
1585   .bool8Operands = {},
1586   // int -> QUANT8_SYMM_PER_CHANNEL map
1587   .quant8ChannelOperands = {},
1588   // int -> QUANT16_ASYMM map
1589   .quant16AsymmOperands = {},
1590   // int -> QUANT8_SYMM map
1591   .quant8SymmOperands = {},
1592 }
1593 },
1594 }, // End of an example
1595 };
1596 return examples_dynamic_output_shape_5;
1597 };
1598 
get_examples_dynamic_output_shape_relaxed_5()1599 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_relaxed_5() {
1600 static std::vector<MixedTypedExample> examples_dynamic_output_shape_relaxed_5 = {
1601 // Begin of an example
1602 {
1603 .operands = {
1604 //Input(s)
1605 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1606   // int -> Dimensions map
1607   .operandDimensions = {{0, {2, 3}}},
1608   // int -> FLOAT32 map
1609   .float32Operands = {},
1610   // int -> INT32 map
1611   .int32Operands = {},
1612   // int -> QUANT8_ASYMM map
1613   .quant8AsymmOperands = {{0, {1, 2, 3, 251, 250, 249}}},
1614   // int -> QUANT16_SYMM map
1615   .quant16SymmOperands = {},
1616   // int -> FLOAT16 map
1617   .float16Operands = {},
1618   // int -> BOOL8 map
1619   .bool8Operands = {},
1620   // int -> QUANT8_SYMM_PER_CHANNEL map
1621   .quant8ChannelOperands = {},
1622   // int -> QUANT16_ASYMM map
1623   .quant16AsymmOperands = {},
1624   // int -> QUANT8_SYMM map
1625   .quant8SymmOperands = {},
1626 },
1627 //Output(s)
1628 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1629   // int -> Dimensions map
1630   .operandDimensions = {{0, {2, 2}}, {1, {2, 2}}},
1631   // int -> FLOAT32 map
1632   .float32Operands = {},
1633   // int -> INT32 map
1634   .int32Operands = {{1, {2, 1, 0, 1}}},
1635   // int -> QUANT8_ASYMM map
1636   .quant8AsymmOperands = {{0, {3, 2, 251, 250}}},
1637   // int -> QUANT16_SYMM map
1638   .quant16SymmOperands = {},
1639   // int -> FLOAT16 map
1640   .float16Operands = {},
1641   // int -> BOOL8 map
1642   .bool8Operands = {},
1643   // int -> QUANT8_SYMM_PER_CHANNEL map
1644   .quant8ChannelOperands = {},
1645   // int -> QUANT16_ASYMM map
1646   .quant16AsymmOperands = {},
1647   // int -> QUANT8_SYMM map
1648   .quant8SymmOperands = {},
1649 }
1650 },
1651 }, // End of an example
1652 };
1653 return examples_dynamic_output_shape_relaxed_5;
1654 };
1655 
get_examples_dynamic_output_shape_float16_5()1656 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_float16_5() {
1657 static std::vector<MixedTypedExample> examples_dynamic_output_shape_float16_5 = {
1658 // Begin of an example
1659 {
1660 .operands = {
1661 //Input(s)
1662 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1663   // int -> Dimensions map
1664   .operandDimensions = {{0, {2, 3}}},
1665   // int -> FLOAT32 map
1666   .float32Operands = {},
1667   // int -> INT32 map
1668   .int32Operands = {},
1669   // int -> QUANT8_ASYMM map
1670   .quant8AsymmOperands = {{0, {1, 2, 3, 251, 250, 249}}},
1671   // int -> QUANT16_SYMM map
1672   .quant16SymmOperands = {},
1673   // int -> FLOAT16 map
1674   .float16Operands = {},
1675   // int -> BOOL8 map
1676   .bool8Operands = {},
1677   // int -> QUANT8_SYMM_PER_CHANNEL map
1678   .quant8ChannelOperands = {},
1679   // int -> QUANT16_ASYMM map
1680   .quant16AsymmOperands = {},
1681   // int -> QUANT8_SYMM map
1682   .quant8SymmOperands = {},
1683 },
1684 //Output(s)
1685 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1686   // int -> Dimensions map
1687   .operandDimensions = {{0, {2, 2}}, {1, {2, 2}}},
1688   // int -> FLOAT32 map
1689   .float32Operands = {},
1690   // int -> INT32 map
1691   .int32Operands = {{1, {2, 1, 0, 1}}},
1692   // int -> QUANT8_ASYMM map
1693   .quant8AsymmOperands = {{0, {3, 2, 251, 250}}},
1694   // int -> QUANT16_SYMM map
1695   .quant16SymmOperands = {},
1696   // int -> FLOAT16 map
1697   .float16Operands = {},
1698   // int -> BOOL8 map
1699   .bool8Operands = {},
1700   // int -> QUANT8_SYMM_PER_CHANNEL map
1701   .quant8ChannelOperands = {},
1702   // int -> QUANT16_ASYMM map
1703   .quant16AsymmOperands = {},
1704   // int -> QUANT8_SYMM map
1705   .quant8SymmOperands = {},
1706 }
1707 },
1708 }, // End of an example
1709 };
1710 return examples_dynamic_output_shape_float16_5;
1711 };
1712 
get_examples_6()1713 std::vector<MixedTypedExample>& get_examples_6() {
1714 static std::vector<MixedTypedExample> examples_6 = {
1715 // Begin of an example
1716 {
1717 .operands = {
1718 //Input(s)
1719 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1720   // int -> Dimensions map
1721   .operandDimensions = {{0, {2, 3}}},
1722   // int -> FLOAT32 map
1723   .float32Operands = {},
1724   // int -> INT32 map
1725   .int32Operands = {{0, {1, 2, 3, 10251, 10250, 10249}}},
1726   // int -> QUANT8_ASYMM map
1727   .quant8AsymmOperands = {},
1728   // int -> QUANT16_SYMM map
1729   .quant16SymmOperands = {},
1730   // int -> FLOAT16 map
1731   .float16Operands = {},
1732   // int -> BOOL8 map
1733   .bool8Operands = {},
1734   // int -> QUANT8_SYMM_PER_CHANNEL map
1735   .quant8ChannelOperands = {},
1736   // int -> QUANT16_ASYMM map
1737   .quant16AsymmOperands = {},
1738   // int -> QUANT8_SYMM map
1739   .quant8SymmOperands = {},
1740 },
1741 //Output(s)
1742 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1743   // int -> Dimensions map
1744   .operandDimensions = {{0, {2, 2}}, {1, {2, 2}}},
1745   // int -> FLOAT32 map
1746   .float32Operands = {},
1747   // int -> INT32 map
1748   .int32Operands = {{0, {3, 2, 10251, 10250}}, {1, {2, 1, 0, 1}}},
1749   // int -> QUANT8_ASYMM map
1750   .quant8AsymmOperands = {},
1751   // int -> QUANT16_SYMM map
1752   .quant16SymmOperands = {},
1753   // int -> FLOAT16 map
1754   .float16Operands = {},
1755   // int -> BOOL8 map
1756   .bool8Operands = {},
1757   // int -> QUANT8_SYMM_PER_CHANNEL map
1758   .quant8ChannelOperands = {},
1759   // int -> QUANT16_ASYMM map
1760   .quant16AsymmOperands = {},
1761   // int -> QUANT8_SYMM map
1762   .quant8SymmOperands = {},
1763 }
1764 },
1765 }, // End of an example
1766 };
1767 return examples_6;
1768 };
1769 
get_examples_relaxed_6()1770 std::vector<MixedTypedExample>& get_examples_relaxed_6() {
1771 static std::vector<MixedTypedExample> examples_relaxed_6 = {
1772 // Begin of an example
1773 {
1774 .operands = {
1775 //Input(s)
1776 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1777   // int -> Dimensions map
1778   .operandDimensions = {{0, {2, 3}}},
1779   // int -> FLOAT32 map
1780   .float32Operands = {},
1781   // int -> INT32 map
1782   .int32Operands = {{0, {1, 2, 3, 10251, 10250, 10249}}},
1783   // int -> QUANT8_ASYMM map
1784   .quant8AsymmOperands = {},
1785   // int -> QUANT16_SYMM map
1786   .quant16SymmOperands = {},
1787   // int -> FLOAT16 map
1788   .float16Operands = {},
1789   // int -> BOOL8 map
1790   .bool8Operands = {},
1791   // int -> QUANT8_SYMM_PER_CHANNEL map
1792   .quant8ChannelOperands = {},
1793   // int -> QUANT16_ASYMM map
1794   .quant16AsymmOperands = {},
1795   // int -> QUANT8_SYMM map
1796   .quant8SymmOperands = {},
1797 },
1798 //Output(s)
1799 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1800   // int -> Dimensions map
1801   .operandDimensions = {{0, {2, 2}}, {1, {2, 2}}},
1802   // int -> FLOAT32 map
1803   .float32Operands = {},
1804   // int -> INT32 map
1805   .int32Operands = {{0, {3, 2, 10251, 10250}}, {1, {2, 1, 0, 1}}},
1806   // int -> QUANT8_ASYMM map
1807   .quant8AsymmOperands = {},
1808   // int -> QUANT16_SYMM map
1809   .quant16SymmOperands = {},
1810   // int -> FLOAT16 map
1811   .float16Operands = {},
1812   // int -> BOOL8 map
1813   .bool8Operands = {},
1814   // int -> QUANT8_SYMM_PER_CHANNEL map
1815   .quant8ChannelOperands = {},
1816   // int -> QUANT16_ASYMM map
1817   .quant16AsymmOperands = {},
1818   // int -> QUANT8_SYMM map
1819   .quant8SymmOperands = {},
1820 }
1821 },
1822 }, // End of an example
1823 };
1824 return examples_relaxed_6;
1825 };
1826 
get_examples_float16_6()1827 std::vector<MixedTypedExample>& get_examples_float16_6() {
1828 static std::vector<MixedTypedExample> examples_float16_6 = {
1829 // Begin of an example
1830 {
1831 .operands = {
1832 //Input(s)
1833 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1834   // int -> Dimensions map
1835   .operandDimensions = {{0, {2, 3}}},
1836   // int -> FLOAT32 map
1837   .float32Operands = {},
1838   // int -> INT32 map
1839   .int32Operands = {{0, {1, 2, 3, 10251, 10250, 10249}}},
1840   // int -> QUANT8_ASYMM map
1841   .quant8AsymmOperands = {},
1842   // int -> QUANT16_SYMM map
1843   .quant16SymmOperands = {},
1844   // int -> FLOAT16 map
1845   .float16Operands = {},
1846   // int -> BOOL8 map
1847   .bool8Operands = {},
1848   // int -> QUANT8_SYMM_PER_CHANNEL map
1849   .quant8ChannelOperands = {},
1850   // int -> QUANT16_ASYMM map
1851   .quant16AsymmOperands = {},
1852   // int -> QUANT8_SYMM map
1853   .quant8SymmOperands = {},
1854 },
1855 //Output(s)
1856 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1857   // int -> Dimensions map
1858   .operandDimensions = {{0, {2, 2}}, {1, {2, 2}}},
1859   // int -> FLOAT32 map
1860   .float32Operands = {},
1861   // int -> INT32 map
1862   .int32Operands = {{0, {3, 2, 10251, 10250}}, {1, {2, 1, 0, 1}}},
1863   // int -> QUANT8_ASYMM map
1864   .quant8AsymmOperands = {},
1865   // int -> QUANT16_SYMM map
1866   .quant16SymmOperands = {},
1867   // int -> FLOAT16 map
1868   .float16Operands = {},
1869   // int -> BOOL8 map
1870   .bool8Operands = {},
1871   // int -> QUANT8_SYMM_PER_CHANNEL map
1872   .quant8ChannelOperands = {},
1873   // int -> QUANT16_ASYMM map
1874   .quant16AsymmOperands = {},
1875   // int -> QUANT8_SYMM map
1876   .quant8SymmOperands = {},
1877 }
1878 },
1879 }, // End of an example
1880 };
1881 return examples_float16_6;
1882 };
1883 
get_examples_dynamic_output_shape_6()1884 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_6() {
1885 static std::vector<MixedTypedExample> examples_dynamic_output_shape_6 = {
1886 // Begin of an example
1887 {
1888 .operands = {
1889 //Input(s)
1890 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1891   // int -> Dimensions map
1892   .operandDimensions = {{0, {2, 3}}},
1893   // int -> FLOAT32 map
1894   .float32Operands = {},
1895   // int -> INT32 map
1896   .int32Operands = {{0, {1, 2, 3, 10251, 10250, 10249}}},
1897   // int -> QUANT8_ASYMM map
1898   .quant8AsymmOperands = {},
1899   // int -> QUANT16_SYMM map
1900   .quant16SymmOperands = {},
1901   // int -> FLOAT16 map
1902   .float16Operands = {},
1903   // int -> BOOL8 map
1904   .bool8Operands = {},
1905   // int -> QUANT8_SYMM_PER_CHANNEL map
1906   .quant8ChannelOperands = {},
1907   // int -> QUANT16_ASYMM map
1908   .quant16AsymmOperands = {},
1909   // int -> QUANT8_SYMM map
1910   .quant8SymmOperands = {},
1911 },
1912 //Output(s)
1913 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1914   // int -> Dimensions map
1915   .operandDimensions = {{0, {2, 2}}, {1, {2, 2}}},
1916   // int -> FLOAT32 map
1917   .float32Operands = {},
1918   // int -> INT32 map
1919   .int32Operands = {{0, {3, 2, 10251, 10250}}, {1, {2, 1, 0, 1}}},
1920   // int -> QUANT8_ASYMM map
1921   .quant8AsymmOperands = {},
1922   // int -> QUANT16_SYMM map
1923   .quant16SymmOperands = {},
1924   // int -> FLOAT16 map
1925   .float16Operands = {},
1926   // int -> BOOL8 map
1927   .bool8Operands = {},
1928   // int -> QUANT8_SYMM_PER_CHANNEL map
1929   .quant8ChannelOperands = {},
1930   // int -> QUANT16_ASYMM map
1931   .quant16AsymmOperands = {},
1932   // int -> QUANT8_SYMM map
1933   .quant8SymmOperands = {},
1934 }
1935 },
1936 }, // End of an example
1937 };
1938 return examples_dynamic_output_shape_6;
1939 };
1940 
get_examples_dynamic_output_shape_relaxed_6()1941 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_relaxed_6() {
1942 static std::vector<MixedTypedExample> examples_dynamic_output_shape_relaxed_6 = {
1943 // Begin of an example
1944 {
1945 .operands = {
1946 //Input(s)
1947 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1948   // int -> Dimensions map
1949   .operandDimensions = {{0, {2, 3}}},
1950   // int -> FLOAT32 map
1951   .float32Operands = {},
1952   // int -> INT32 map
1953   .int32Operands = {{0, {1, 2, 3, 10251, 10250, 10249}}},
1954   // int -> QUANT8_ASYMM map
1955   .quant8AsymmOperands = {},
1956   // int -> QUANT16_SYMM map
1957   .quant16SymmOperands = {},
1958   // int -> FLOAT16 map
1959   .float16Operands = {},
1960   // int -> BOOL8 map
1961   .bool8Operands = {},
1962   // int -> QUANT8_SYMM_PER_CHANNEL map
1963   .quant8ChannelOperands = {},
1964   // int -> QUANT16_ASYMM map
1965   .quant16AsymmOperands = {},
1966   // int -> QUANT8_SYMM map
1967   .quant8SymmOperands = {},
1968 },
1969 //Output(s)
1970 { // See tools/test_generator/include/TestHarness.h:MixedTyped
1971   // int -> Dimensions map
1972   .operandDimensions = {{0, {2, 2}}, {1, {2, 2}}},
1973   // int -> FLOAT32 map
1974   .float32Operands = {},
1975   // int -> INT32 map
1976   .int32Operands = {{0, {3, 2, 10251, 10250}}, {1, {2, 1, 0, 1}}},
1977   // int -> QUANT8_ASYMM map
1978   .quant8AsymmOperands = {},
1979   // int -> QUANT16_SYMM map
1980   .quant16SymmOperands = {},
1981   // int -> FLOAT16 map
1982   .float16Operands = {},
1983   // int -> BOOL8 map
1984   .bool8Operands = {},
1985   // int -> QUANT8_SYMM_PER_CHANNEL map
1986   .quant8ChannelOperands = {},
1987   // int -> QUANT16_ASYMM map
1988   .quant16AsymmOperands = {},
1989   // int -> QUANT8_SYMM map
1990   .quant8SymmOperands = {},
1991 }
1992 },
1993 }, // End of an example
1994 };
1995 return examples_dynamic_output_shape_relaxed_6;
1996 };
1997 
get_examples_dynamic_output_shape_float16_6()1998 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_float16_6() {
1999 static std::vector<MixedTypedExample> examples_dynamic_output_shape_float16_6 = {
2000 // Begin of an example
2001 {
2002 .operands = {
2003 //Input(s)
2004 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2005   // int -> Dimensions map
2006   .operandDimensions = {{0, {2, 3}}},
2007   // int -> FLOAT32 map
2008   .float32Operands = {},
2009   // int -> INT32 map
2010   .int32Operands = {{0, {1, 2, 3, 10251, 10250, 10249}}},
2011   // int -> QUANT8_ASYMM map
2012   .quant8AsymmOperands = {},
2013   // int -> QUANT16_SYMM map
2014   .quant16SymmOperands = {},
2015   // int -> FLOAT16 map
2016   .float16Operands = {},
2017   // int -> BOOL8 map
2018   .bool8Operands = {},
2019   // int -> QUANT8_SYMM_PER_CHANNEL map
2020   .quant8ChannelOperands = {},
2021   // int -> QUANT16_ASYMM map
2022   .quant16AsymmOperands = {},
2023   // int -> QUANT8_SYMM map
2024   .quant8SymmOperands = {},
2025 },
2026 //Output(s)
2027 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2028   // int -> Dimensions map
2029   .operandDimensions = {{0, {2, 2}}, {1, {2, 2}}},
2030   // int -> FLOAT32 map
2031   .float32Operands = {},
2032   // int -> INT32 map
2033   .int32Operands = {{0, {3, 2, 10251, 10250}}, {1, {2, 1, 0, 1}}},
2034   // int -> QUANT8_ASYMM map
2035   .quant8AsymmOperands = {},
2036   // int -> QUANT16_SYMM map
2037   .quant16SymmOperands = {},
2038   // int -> FLOAT16 map
2039   .float16Operands = {},
2040   // int -> BOOL8 map
2041   .bool8Operands = {},
2042   // int -> QUANT8_SYMM_PER_CHANNEL map
2043   .quant8ChannelOperands = {},
2044   // int -> QUANT16_ASYMM map
2045   .quant16AsymmOperands = {},
2046   // int -> QUANT8_SYMM map
2047   .quant8SymmOperands = {},
2048 }
2049 },
2050 }, // End of an example
2051 };
2052 return examples_dynamic_output_shape_float16_6;
2053 };
2054 
2055