1 // clang-format off
2 // Generated file (from: depthwise_conv2d_dilation.mod.py). Do not edit
get_examples_nhwc()3 std::vector<MixedTypedExample>& get_examples_nhwc() {
4 static std::vector<MixedTypedExample> examples_nhwc = {
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, 3, 3, 2}}},
12   // int -> FLOAT32 map
13   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.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, 4}}},
35   // int -> FLOAT32 map
36   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
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_nhwc;
58 };
59 
get_examples_nhwc_relaxed()60 std::vector<MixedTypedExample>& get_examples_nhwc_relaxed() {
61 static std::vector<MixedTypedExample> examples_nhwc_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, {1, 3, 3, 2}}},
69   // int -> FLOAT32 map
70   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.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, 4}}},
92   // int -> FLOAT32 map
93   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
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_nhwc_relaxed;
115 };
116 
get_examples_nhwc_float16()117 std::vector<MixedTypedExample>& get_examples_nhwc_float16() {
118 static std::vector<MixedTypedExample> examples_nhwc_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, {1, 3, 3, 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, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}},
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, 4}}},
149   // int -> FLOAT32 map
150   .float32Operands = {},
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 = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}},
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_nhwc_float16;
172 };
173 
get_examples_nhwc_quant8()174 std::vector<MixedTypedExample>& get_examples_nhwc_quant8() {
175 static std::vector<MixedTypedExample> examples_nhwc_quant8 = {
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, 3, 3, 2}}},
183   // int -> FLOAT32 map
184   .float32Operands = {},
185   // int -> INT32 map
186   .int32Operands = {},
187   // int -> QUANT8_ASYMM map
188   .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}},
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, 4}}},
206   // int -> FLOAT32 map
207   .float32Operands = {},
208   // int -> INT32 map
209   .int32Operands = {},
210   // int -> QUANT8_ASYMM map
211   .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}},
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_nhwc_quant8;
229 };
230 
get_examples_nhwc_weight_as_input()231 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input() {
232 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input = {
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, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
240   // int -> FLOAT32 map
241   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
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, {1, 2, 2, 4}}},
263   // int -> FLOAT32 map
264   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
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 = {},
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_nhwc_weight_as_input;
286 };
287 
get_examples_nhwc_weight_as_input_relaxed()288 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input_relaxed() {
289 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input_relaxed = {
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, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
297   // int -> FLOAT32 map
298   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
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 = {},
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, 4}}},
320   // int -> FLOAT32 map
321   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
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 = {},
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_nhwc_weight_as_input_relaxed;
343 };
344 
get_examples_nhwc_weight_as_input_float16()345 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input_float16() {
346 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input_float16 = {
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, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
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, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.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, 4}}},
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, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}},
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_nhwc_weight_as_input_float16;
400 };
401 
get_examples_nhwc_weight_as_input_quant8()402 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input_quant8() {
403 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input_quant8 = {
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, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
411   // int -> FLOAT32 map
412   .float32Operands = {},
413   // int -> INT32 map
414   .int32Operands = {{2, {200, 400, 600, 800}}},
415   // int -> QUANT8_ASYMM map
416   .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}},
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, {1, 2, 2, 4}}},
434   // int -> FLOAT32 map
435   .float32Operands = {},
436   // int -> INT32 map
437   .int32Operands = {},
438   // int -> QUANT8_ASYMM map
439   .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}},
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_nhwc_weight_as_input_quant8;
457 };
458 
get_examples_nchw()459 std::vector<MixedTypedExample>& get_examples_nchw() {
460 static std::vector<MixedTypedExample> examples_nchw = {
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, 3, 3}}},
468   // int -> FLOAT32 map
469   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.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, 4, 2, 2}}},
491   // int -> FLOAT32 map
492   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
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_nchw;
514 };
515 
get_examples_nchw_relaxed()516 std::vector<MixedTypedExample>& get_examples_nchw_relaxed() {
517 static std::vector<MixedTypedExample> examples_nchw_relaxed = {
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, 3, 3}}},
525   // int -> FLOAT32 map
526   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.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, 4, 2, 2}}},
548   // int -> FLOAT32 map
549   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
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_nchw_relaxed;
571 };
572 
get_examples_nchw_float16()573 std::vector<MixedTypedExample>& get_examples_nchw_float16() {
574 static std::vector<MixedTypedExample> examples_nchw_float16 = {
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, 3, 3}}},
582   // int -> FLOAT32 map
583   .float32Operands = {},
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 = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}},
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, 4, 2, 2}}},
605   // int -> FLOAT32 map
606   .float32Operands = {},
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 = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}},
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_nchw_float16;
628 };
629 
get_examples_nchw_quant8()630 std::vector<MixedTypedExample>& get_examples_nchw_quant8() {
631 static std::vector<MixedTypedExample> examples_nchw_quant8 = {
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, 3, 3}}},
639   // int -> FLOAT32 map
640   .float32Operands = {},
641   // int -> INT32 map
642   .int32Operands = {},
643   // int -> QUANT8_ASYMM map
644   .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}},
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, 4, 2, 2}}},
662   // int -> FLOAT32 map
663   .float32Operands = {},
664   // int -> INT32 map
665   .int32Operands = {},
666   // int -> QUANT8_ASYMM map
667   .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}},
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_nchw_quant8;
685 };
686 
get_examples_nchw_weight_as_input()687 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input() {
688 static std::vector<MixedTypedExample> examples_nchw_weight_as_input = {
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, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
696   // int -> FLOAT32 map
697   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
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, {1, 4, 2, 2}}},
719   // int -> FLOAT32 map
720   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
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 = {},
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_nchw_weight_as_input;
742 };
743 
get_examples_nchw_weight_as_input_relaxed()744 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input_relaxed() {
745 static std::vector<MixedTypedExample> examples_nchw_weight_as_input_relaxed = {
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, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
753   // int -> FLOAT32 map
754   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
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, {1, 4, 2, 2}}},
776   // int -> FLOAT32 map
777   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
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 = {},
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_nchw_weight_as_input_relaxed;
799 };
800 
get_examples_nchw_weight_as_input_float16()801 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input_float16() {
802 static std::vector<MixedTypedExample> examples_nchw_weight_as_input_float16 = {
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, 3, 3}}, {1, {1, 2, 2, 4}}, {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, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.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, 4, 2, 2}}},
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, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}},
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_nchw_weight_as_input_float16;
856 };
857 
get_examples_nchw_weight_as_input_quant8()858 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input_quant8() {
859 static std::vector<MixedTypedExample> examples_nchw_weight_as_input_quant8 = {
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, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
867   // int -> FLOAT32 map
868   .float32Operands = {},
869   // int -> INT32 map
870   .int32Operands = {{2, {200, 400, 600, 800}}},
871   // int -> QUANT8_ASYMM map
872   .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}},
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, {1, 4, 2, 2}}},
890   // int -> FLOAT32 map
891   .float32Operands = {},
892   // int -> INT32 map
893   .int32Operands = {},
894   // int -> QUANT8_ASYMM map
895   .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}},
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_nchw_weight_as_input_quant8;
913 };
914 
get_examples_dynamic_output_shape_nhwc()915 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc() {
916 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc = {
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, {1, 3, 3, 2}}},
924   // int -> FLOAT32 map
925   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}},
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, {1, 2, 2, 4}}},
947   // int -> FLOAT32 map
948   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
949   // int -> INT32 map
950   .int32Operands = {},
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_nhwc;
970 };
971 
get_examples_dynamic_output_shape_nhwc_relaxed()972 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_relaxed() {
973 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_relaxed = {
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, {1, 3, 3, 2}}},
981   // int -> FLOAT32 map
982   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}},
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 = {},
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, {1, 2, 2, 4}}},
1004   // int -> FLOAT32 map
1005   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
1006   // int -> INT32 map
1007   .int32Operands = {},
1008   // int -> QUANT8_ASYMM map
1009   .quant8AsymmOperands = {},
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_dynamic_output_shape_nhwc_relaxed;
1027 };
1028 
get_examples_dynamic_output_shape_nhwc_float16()1029 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_float16() {
1030 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_float16 = {
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, 3, 3, 2}}},
1038   // int -> FLOAT32 map
1039   .float32Operands = {},
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 = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}},
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, {1, 2, 2, 4}}},
1061   // int -> FLOAT32 map
1062   .float32Operands = {},
1063   // int -> INT32 map
1064   .int32Operands = {},
1065   // int -> QUANT8_ASYMM map
1066   .quant8AsymmOperands = {},
1067   // int -> QUANT16_SYMM map
1068   .quant16SymmOperands = {},
1069   // int -> FLOAT16 map
1070   .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}},
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_dynamic_output_shape_nhwc_float16;
1084 };
1085 
get_examples_dynamic_output_shape_nhwc_quant8()1086 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_quant8() {
1087 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_quant8 = {
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, 3, 3, 2}}},
1095   // int -> FLOAT32 map
1096   .float32Operands = {},
1097   // int -> INT32 map
1098   .int32Operands = {},
1099   // int -> QUANT8_ASYMM map
1100   .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}},
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, {1, 2, 2, 4}}},
1118   // int -> FLOAT32 map
1119   .float32Operands = {},
1120   // int -> INT32 map
1121   .int32Operands = {},
1122   // int -> QUANT8_ASYMM map
1123   .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}},
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_dynamic_output_shape_nhwc_quant8;
1141 };
1142 
get_examples_dynamic_output_shape_nhwc_weight_as_input()1143 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input() {
1144 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input = {
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, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
1152   // int -> FLOAT32 map
1153   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
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 = {},
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, {1, 2, 2, 4}}},
1175   // int -> FLOAT32 map
1176   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
1177   // int -> INT32 map
1178   .int32Operands = {},
1179   // int -> QUANT8_ASYMM map
1180   .quant8AsymmOperands = {},
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_dynamic_output_shape_nhwc_weight_as_input;
1198 };
1199 
get_examples_dynamic_output_shape_nhwc_weight_as_input_relaxed()1200 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input_relaxed() {
1201 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input_relaxed = {
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, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
1209   // int -> FLOAT32 map
1210   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
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, {1, 2, 2, 4}}},
1232   // int -> FLOAT32 map
1233   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
1234   // int -> INT32 map
1235   .int32Operands = {},
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_nhwc_weight_as_input_relaxed;
1255 };
1256 
get_examples_dynamic_output_shape_nhwc_weight_as_input_float16()1257 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input_float16() {
1258 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input_float16 = {
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, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
1266   // int -> FLOAT32 map
1267   .float32Operands = {},
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 = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
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, {1, 2, 2, 4}}},
1289   // int -> FLOAT32 map
1290   .float32Operands = {},
1291   // int -> INT32 map
1292   .int32Operands = {},
1293   // int -> QUANT8_ASYMM map
1294   .quant8AsymmOperands = {},
1295   // int -> QUANT16_SYMM map
1296   .quant16SymmOperands = {},
1297   // int -> FLOAT16 map
1298   .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}},
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_nhwc_weight_as_input_float16;
1312 };
1313 
get_examples_dynamic_output_shape_nhwc_weight_as_input_quant8()1314 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input_quant8() {
1315 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input_quant8 = {
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, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
1323   // int -> FLOAT32 map
1324   .float32Operands = {},
1325   // int -> INT32 map
1326   .int32Operands = {{2, {200, 400, 600, 800}}},
1327   // int -> QUANT8_ASYMM map
1328   .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}},
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, {1, 2, 2, 4}}},
1346   // int -> FLOAT32 map
1347   .float32Operands = {},
1348   // int -> INT32 map
1349   .int32Operands = {},
1350   // int -> QUANT8_ASYMM map
1351   .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}},
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_dynamic_output_shape_nhwc_weight_as_input_quant8;
1369 };
1370 
get_examples_dynamic_output_shape_nchw()1371 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw() {
1372 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw = {
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, 2, 3, 3}}},
1380   // int -> FLOAT32 map
1381   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}},
1382   // int -> INT32 map
1383   .int32Operands = {},
1384   // int -> QUANT8_ASYMM map
1385   .quant8AsymmOperands = {},
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, {1, 4, 2, 2}}},
1403   // int -> FLOAT32 map
1404   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
1405   // int -> INT32 map
1406   .int32Operands = {},
1407   // int -> QUANT8_ASYMM map
1408   .quant8AsymmOperands = {},
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_dynamic_output_shape_nchw;
1426 };
1427 
get_examples_dynamic_output_shape_nchw_relaxed()1428 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_relaxed() {
1429 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_relaxed = {
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, 2, 3, 3}}},
1437   // int -> FLOAT32 map
1438   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}},
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 = {},
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, {1, 4, 2, 2}}},
1460   // int -> FLOAT32 map
1461   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
1462   // int -> INT32 map
1463   .int32Operands = {},
1464   // int -> QUANT8_ASYMM map
1465   .quant8AsymmOperands = {},
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_dynamic_output_shape_nchw_relaxed;
1483 };
1484 
get_examples_dynamic_output_shape_nchw_float16()1485 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_float16() {
1486 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_float16 = {
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, {1, 2, 3, 3}}},
1494   // int -> FLOAT32 map
1495   .float32Operands = {},
1496   // int -> INT32 map
1497   .int32Operands = {},
1498   // int -> QUANT8_ASYMM map
1499   .quant8AsymmOperands = {},
1500   // int -> QUANT16_SYMM map
1501   .quant16SymmOperands = {},
1502   // int -> FLOAT16 map
1503   .float16Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}},
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, {1, 4, 2, 2}}},
1517   // int -> FLOAT32 map
1518   .float32Operands = {},
1519   // int -> INT32 map
1520   .int32Operands = {},
1521   // int -> QUANT8_ASYMM map
1522   .quant8AsymmOperands = {},
1523   // int -> QUANT16_SYMM map
1524   .quant16SymmOperands = {},
1525   // int -> FLOAT16 map
1526   .float16Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}},
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_dynamic_output_shape_nchw_float16;
1540 };
1541 
get_examples_dynamic_output_shape_nchw_quant8()1542 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_quant8() {
1543 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_quant8 = {
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, {1, 2, 3, 3}}},
1551   // int -> FLOAT32 map
1552   .float32Operands = {},
1553   // int -> INT32 map
1554   .int32Operands = {},
1555   // int -> QUANT8_ASYMM map
1556   .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}},
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, {1, 4, 2, 2}}},
1574   // int -> FLOAT32 map
1575   .float32Operands = {},
1576   // int -> INT32 map
1577   .int32Operands = {},
1578   // int -> QUANT8_ASYMM map
1579   .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}},
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_nchw_quant8;
1597 };
1598 
get_examples_dynamic_output_shape_nchw_weight_as_input()1599 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input() {
1600 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input = {
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, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
1608   // int -> FLOAT32 map
1609   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
1610   // int -> INT32 map
1611   .int32Operands = {},
1612   // int -> QUANT8_ASYMM map
1613   .quant8AsymmOperands = {},
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, {1, 4, 2, 2}}},
1631   // int -> FLOAT32 map
1632   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
1633   // int -> INT32 map
1634   .int32Operands = {},
1635   // int -> QUANT8_ASYMM map
1636   .quant8AsymmOperands = {},
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_nchw_weight_as_input;
1654 };
1655 
get_examples_dynamic_output_shape_nchw_weight_as_input_relaxed()1656 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input_relaxed() {
1657 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input_relaxed = {
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, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
1665   // int -> FLOAT32 map
1666   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
1667   // int -> INT32 map
1668   .int32Operands = {},
1669   // int -> QUANT8_ASYMM map
1670   .quant8AsymmOperands = {},
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, {1, 4, 2, 2}}},
1688   // int -> FLOAT32 map
1689   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
1690   // int -> INT32 map
1691   .int32Operands = {},
1692   // int -> QUANT8_ASYMM map
1693   .quant8AsymmOperands = {},
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_nchw_weight_as_input_relaxed;
1711 };
1712 
get_examples_dynamic_output_shape_nchw_weight_as_input_float16()1713 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input_float16() {
1714 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input_float16 = {
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, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
1722   // int -> FLOAT32 map
1723   .float32Operands = {},
1724   // int -> INT32 map
1725   .int32Operands = {},
1726   // int -> QUANT8_ASYMM map
1727   .quant8AsymmOperands = {},
1728   // int -> QUANT16_SYMM map
1729   .quant16SymmOperands = {},
1730   // int -> FLOAT16 map
1731   .float16Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
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, {1, 4, 2, 2}}},
1745   // int -> FLOAT32 map
1746   .float32Operands = {},
1747   // int -> INT32 map
1748   .int32Operands = {},
1749   // int -> QUANT8_ASYMM map
1750   .quant8AsymmOperands = {},
1751   // int -> QUANT16_SYMM map
1752   .quant16SymmOperands = {},
1753   // int -> FLOAT16 map
1754   .float16Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}},
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_dynamic_output_shape_nchw_weight_as_input_float16;
1768 };
1769 
get_examples_dynamic_output_shape_nchw_weight_as_input_quant8()1770 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input_quant8() {
1771 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input_quant8 = {
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, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
1779   // int -> FLOAT32 map
1780   .float32Operands = {},
1781   // int -> INT32 map
1782   .int32Operands = {{2, {200, 400, 600, 800}}},
1783   // int -> QUANT8_ASYMM map
1784   .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}},
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, {1, 4, 2, 2}}},
1802   // int -> FLOAT32 map
1803   .float32Operands = {},
1804   // int -> INT32 map
1805   .int32Operands = {},
1806   // int -> QUANT8_ASYMM map
1807   .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}},
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_dynamic_output_shape_nchw_weight_as_input_quant8;
1825 };
1826 
get_examples_nhwc_2()1827 std::vector<MixedTypedExample>& get_examples_nhwc_2() {
1828 static std::vector<MixedTypedExample> examples_nhwc_2 = {
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, {1, 4, 4, 2}}},
1836   // int -> FLOAT32 map
1837   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
1838   // int -> INT32 map
1839   .int32Operands = {},
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, {1, 2, 2, 4}}},
1859   // int -> FLOAT32 map
1860   .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}},
1861   // int -> INT32 map
1862   .int32Operands = {},
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_nhwc_2;
1882 };
1883 
get_examples_nhwc_weight_as_input_2()1884 std::vector<MixedTypedExample>& get_examples_nhwc_weight_as_input_2() {
1885 static std::vector<MixedTypedExample> examples_nhwc_weight_as_input_2 = {
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, {1, 4, 4, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
1893   // int -> FLOAT32 map
1894   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}},
1895   // int -> INT32 map
1896   .int32Operands = {},
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, {1, 2, 2, 4}}},
1916   // int -> FLOAT32 map
1917   .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}},
1918   // int -> INT32 map
1919   .int32Operands = {},
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_nhwc_weight_as_input_2;
1939 };
1940 
get_examples_nchw_2()1941 std::vector<MixedTypedExample>& get_examples_nchw_2() {
1942 static std::vector<MixedTypedExample> examples_nchw_2 = {
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, {1, 2, 4, 4}}},
1950   // int -> FLOAT32 map
1951   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
1952   // int -> INT32 map
1953   .int32Operands = {},
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, {1, 4, 2, 2}}},
1973   // int -> FLOAT32 map
1974   .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}},
1975   // int -> INT32 map
1976   .int32Operands = {},
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_nchw_2;
1996 };
1997 
get_examples_nchw_weight_as_input_2()1998 std::vector<MixedTypedExample>& get_examples_nchw_weight_as_input_2() {
1999 static std::vector<MixedTypedExample> examples_nchw_weight_as_input_2 = {
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, {1, 2, 4, 4}}, {1, {1, 2, 2, 4}}, {2, {4}}},
2007   // int -> FLOAT32 map
2008   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}},
2009   // int -> INT32 map
2010   .int32Operands = {},
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, {1, 4, 2, 2}}},
2030   // int -> FLOAT32 map
2031   .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}},
2032   // int -> INT32 map
2033   .int32Operands = {},
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_nchw_weight_as_input_2;
2053 };
2054 
get_examples_dynamic_output_shape_nhwc_2()2055 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_2() {
2056 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_2 = {
2057 // Begin of an example
2058 {
2059 .operands = {
2060 //Input(s)
2061 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2062   // int -> Dimensions map
2063   .operandDimensions = {{0, {1, 4, 4, 2}}},
2064   // int -> FLOAT32 map
2065   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
2066   // int -> INT32 map
2067   .int32Operands = {},
2068   // int -> QUANT8_ASYMM map
2069   .quant8AsymmOperands = {},
2070   // int -> QUANT16_SYMM map
2071   .quant16SymmOperands = {},
2072   // int -> FLOAT16 map
2073   .float16Operands = {},
2074   // int -> BOOL8 map
2075   .bool8Operands = {},
2076   // int -> QUANT8_SYMM_PER_CHANNEL map
2077   .quant8ChannelOperands = {},
2078   // int -> QUANT16_ASYMM map
2079   .quant16AsymmOperands = {},
2080   // int -> QUANT8_SYMM map
2081   .quant8SymmOperands = {},
2082 },
2083 //Output(s)
2084 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2085   // int -> Dimensions map
2086   .operandDimensions = {{0, {1, 2, 2, 4}}},
2087   // int -> FLOAT32 map
2088   .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}},
2089   // int -> INT32 map
2090   .int32Operands = {},
2091   // int -> QUANT8_ASYMM map
2092   .quant8AsymmOperands = {},
2093   // int -> QUANT16_SYMM map
2094   .quant16SymmOperands = {},
2095   // int -> FLOAT16 map
2096   .float16Operands = {},
2097   // int -> BOOL8 map
2098   .bool8Operands = {},
2099   // int -> QUANT8_SYMM_PER_CHANNEL map
2100   .quant8ChannelOperands = {},
2101   // int -> QUANT16_ASYMM map
2102   .quant16AsymmOperands = {},
2103   // int -> QUANT8_SYMM map
2104   .quant8SymmOperands = {},
2105 }
2106 },
2107 }, // End of an example
2108 };
2109 return examples_dynamic_output_shape_nhwc_2;
2110 };
2111 
get_examples_dynamic_output_shape_nhwc_weight_as_input_2()2112 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nhwc_weight_as_input_2() {
2113 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nhwc_weight_as_input_2 = {
2114 // Begin of an example
2115 {
2116 .operands = {
2117 //Input(s)
2118 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2119   // int -> Dimensions map
2120   .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
2121   // int -> FLOAT32 map
2122   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}},
2123   // int -> INT32 map
2124   .int32Operands = {},
2125   // int -> QUANT8_ASYMM map
2126   .quant8AsymmOperands = {},
2127   // int -> QUANT16_SYMM map
2128   .quant16SymmOperands = {},
2129   // int -> FLOAT16 map
2130   .float16Operands = {},
2131   // int -> BOOL8 map
2132   .bool8Operands = {},
2133   // int -> QUANT8_SYMM_PER_CHANNEL map
2134   .quant8ChannelOperands = {},
2135   // int -> QUANT16_ASYMM map
2136   .quant16AsymmOperands = {},
2137   // int -> QUANT8_SYMM map
2138   .quant8SymmOperands = {},
2139 },
2140 //Output(s)
2141 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2142   // int -> Dimensions map
2143   .operandDimensions = {{0, {1, 2, 2, 4}}},
2144   // int -> FLOAT32 map
2145   .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}},
2146   // int -> INT32 map
2147   .int32Operands = {},
2148   // int -> QUANT8_ASYMM map
2149   .quant8AsymmOperands = {},
2150   // int -> QUANT16_SYMM map
2151   .quant16SymmOperands = {},
2152   // int -> FLOAT16 map
2153   .float16Operands = {},
2154   // int -> BOOL8 map
2155   .bool8Operands = {},
2156   // int -> QUANT8_SYMM_PER_CHANNEL map
2157   .quant8ChannelOperands = {},
2158   // int -> QUANT16_ASYMM map
2159   .quant16AsymmOperands = {},
2160   // int -> QUANT8_SYMM map
2161   .quant8SymmOperands = {},
2162 }
2163 },
2164 }, // End of an example
2165 };
2166 return examples_dynamic_output_shape_nhwc_weight_as_input_2;
2167 };
2168 
get_examples_dynamic_output_shape_nchw_2()2169 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_2() {
2170 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_2 = {
2171 // Begin of an example
2172 {
2173 .operands = {
2174 //Input(s)
2175 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2176   // int -> Dimensions map
2177   .operandDimensions = {{0, {1, 2, 4, 4}}},
2178   // int -> FLOAT32 map
2179   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
2180   // int -> INT32 map
2181   .int32Operands = {},
2182   // int -> QUANT8_ASYMM map
2183   .quant8AsymmOperands = {},
2184   // int -> QUANT16_SYMM map
2185   .quant16SymmOperands = {},
2186   // int -> FLOAT16 map
2187   .float16Operands = {},
2188   // int -> BOOL8 map
2189   .bool8Operands = {},
2190   // int -> QUANT8_SYMM_PER_CHANNEL map
2191   .quant8ChannelOperands = {},
2192   // int -> QUANT16_ASYMM map
2193   .quant16AsymmOperands = {},
2194   // int -> QUANT8_SYMM map
2195   .quant8SymmOperands = {},
2196 },
2197 //Output(s)
2198 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2199   // int -> Dimensions map
2200   .operandDimensions = {{0, {1, 4, 2, 2}}},
2201   // int -> FLOAT32 map
2202   .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}},
2203   // int -> INT32 map
2204   .int32Operands = {},
2205   // int -> QUANT8_ASYMM map
2206   .quant8AsymmOperands = {},
2207   // int -> QUANT16_SYMM map
2208   .quant16SymmOperands = {},
2209   // int -> FLOAT16 map
2210   .float16Operands = {},
2211   // int -> BOOL8 map
2212   .bool8Operands = {},
2213   // int -> QUANT8_SYMM_PER_CHANNEL map
2214   .quant8ChannelOperands = {},
2215   // int -> QUANT16_ASYMM map
2216   .quant16AsymmOperands = {},
2217   // int -> QUANT8_SYMM map
2218   .quant8SymmOperands = {},
2219 }
2220 },
2221 }, // End of an example
2222 };
2223 return examples_dynamic_output_shape_nchw_2;
2224 };
2225 
get_examples_dynamic_output_shape_nchw_weight_as_input_2()2226 std::vector<MixedTypedExample>& get_examples_dynamic_output_shape_nchw_weight_as_input_2() {
2227 static std::vector<MixedTypedExample> examples_dynamic_output_shape_nchw_weight_as_input_2 = {
2228 // Begin of an example
2229 {
2230 .operands = {
2231 //Input(s)
2232 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2233   // int -> Dimensions map
2234   .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 2, 2, 4}}, {2, {4}}},
2235   // int -> FLOAT32 map
2236   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}},
2237   // int -> INT32 map
2238   .int32Operands = {},
2239   // int -> QUANT8_ASYMM map
2240   .quant8AsymmOperands = {},
2241   // int -> QUANT16_SYMM map
2242   .quant16SymmOperands = {},
2243   // int -> FLOAT16 map
2244   .float16Operands = {},
2245   // int -> BOOL8 map
2246   .bool8Operands = {},
2247   // int -> QUANT8_SYMM_PER_CHANNEL map
2248   .quant8ChannelOperands = {},
2249   // int -> QUANT16_ASYMM map
2250   .quant16AsymmOperands = {},
2251   // int -> QUANT8_SYMM map
2252   .quant8SymmOperands = {},
2253 },
2254 //Output(s)
2255 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2256   // int -> Dimensions map
2257   .operandDimensions = {{0, {1, 4, 2, 2}}},
2258   // int -> FLOAT32 map
2259   .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}},
2260   // int -> INT32 map
2261   .int32Operands = {},
2262   // int -> QUANT8_ASYMM map
2263   .quant8AsymmOperands = {},
2264   // int -> QUANT16_SYMM map
2265   .quant16SymmOperands = {},
2266   // int -> FLOAT16 map
2267   .float16Operands = {},
2268   // int -> BOOL8 map
2269   .bool8Operands = {},
2270   // int -> QUANT8_SYMM_PER_CHANNEL map
2271   .quant8ChannelOperands = {},
2272   // int -> QUANT16_ASYMM map
2273   .quant16AsymmOperands = {},
2274   // int -> QUANT8_SYMM map
2275   .quant8SymmOperands = {},
2276 }
2277 },
2278 }, // End of an example
2279 };
2280 return examples_dynamic_output_shape_nchw_weight_as_input_2;
2281 };
2282 
get_examples_valid_padding_nhwc()2283 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc() {
2284 static std::vector<MixedTypedExample> examples_valid_padding_nhwc = {
2285 // Begin of an example
2286 {
2287 .operands = {
2288 //Input(s)
2289 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2290   // int -> Dimensions map
2291   .operandDimensions = {{0, {1, 3, 3, 2}}},
2292   // int -> FLOAT32 map
2293   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}},
2294   // int -> INT32 map
2295   .int32Operands = {},
2296   // int -> QUANT8_ASYMM map
2297   .quant8AsymmOperands = {},
2298   // int -> QUANT16_SYMM map
2299   .quant16SymmOperands = {},
2300   // int -> FLOAT16 map
2301   .float16Operands = {},
2302   // int -> BOOL8 map
2303   .bool8Operands = {},
2304   // int -> QUANT8_SYMM_PER_CHANNEL map
2305   .quant8ChannelOperands = {},
2306   // int -> QUANT16_ASYMM map
2307   .quant16AsymmOperands = {},
2308   // int -> QUANT8_SYMM map
2309   .quant8SymmOperands = {},
2310 },
2311 //Output(s)
2312 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2313   // int -> Dimensions map
2314   .operandDimensions = {{0, {1, 2, 2, 4}}},
2315   // int -> FLOAT32 map
2316   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
2317   // int -> INT32 map
2318   .int32Operands = {},
2319   // int -> QUANT8_ASYMM map
2320   .quant8AsymmOperands = {},
2321   // int -> QUANT16_SYMM map
2322   .quant16SymmOperands = {},
2323   // int -> FLOAT16 map
2324   .float16Operands = {},
2325   // int -> BOOL8 map
2326   .bool8Operands = {},
2327   // int -> QUANT8_SYMM_PER_CHANNEL map
2328   .quant8ChannelOperands = {},
2329   // int -> QUANT16_ASYMM map
2330   .quant16AsymmOperands = {},
2331   // int -> QUANT8_SYMM map
2332   .quant8SymmOperands = {},
2333 }
2334 },
2335 }, // End of an example
2336 };
2337 return examples_valid_padding_nhwc;
2338 };
2339 
get_examples_valid_padding_nhwc_relaxed()2340 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_relaxed() {
2341 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_relaxed = {
2342 // Begin of an example
2343 {
2344 .operands = {
2345 //Input(s)
2346 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2347   // int -> Dimensions map
2348   .operandDimensions = {{0, {1, 3, 3, 2}}},
2349   // int -> FLOAT32 map
2350   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}},
2351   // int -> INT32 map
2352   .int32Operands = {},
2353   // int -> QUANT8_ASYMM map
2354   .quant8AsymmOperands = {},
2355   // int -> QUANT16_SYMM map
2356   .quant16SymmOperands = {},
2357   // int -> FLOAT16 map
2358   .float16Operands = {},
2359   // int -> BOOL8 map
2360   .bool8Operands = {},
2361   // int -> QUANT8_SYMM_PER_CHANNEL map
2362   .quant8ChannelOperands = {},
2363   // int -> QUANT16_ASYMM map
2364   .quant16AsymmOperands = {},
2365   // int -> QUANT8_SYMM map
2366   .quant8SymmOperands = {},
2367 },
2368 //Output(s)
2369 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2370   // int -> Dimensions map
2371   .operandDimensions = {{0, {1, 2, 2, 4}}},
2372   // int -> FLOAT32 map
2373   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
2374   // int -> INT32 map
2375   .int32Operands = {},
2376   // int -> QUANT8_ASYMM map
2377   .quant8AsymmOperands = {},
2378   // int -> QUANT16_SYMM map
2379   .quant16SymmOperands = {},
2380   // int -> FLOAT16 map
2381   .float16Operands = {},
2382   // int -> BOOL8 map
2383   .bool8Operands = {},
2384   // int -> QUANT8_SYMM_PER_CHANNEL map
2385   .quant8ChannelOperands = {},
2386   // int -> QUANT16_ASYMM map
2387   .quant16AsymmOperands = {},
2388   // int -> QUANT8_SYMM map
2389   .quant8SymmOperands = {},
2390 }
2391 },
2392 }, // End of an example
2393 };
2394 return examples_valid_padding_nhwc_relaxed;
2395 };
2396 
get_examples_valid_padding_nhwc_float16()2397 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_float16() {
2398 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_float16 = {
2399 // Begin of an example
2400 {
2401 .operands = {
2402 //Input(s)
2403 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2404   // int -> Dimensions map
2405   .operandDimensions = {{0, {1, 3, 3, 2}}},
2406   // int -> FLOAT32 map
2407   .float32Operands = {},
2408   // int -> INT32 map
2409   .int32Operands = {},
2410   // int -> QUANT8_ASYMM map
2411   .quant8AsymmOperands = {},
2412   // int -> QUANT16_SYMM map
2413   .quant16SymmOperands = {},
2414   // int -> FLOAT16 map
2415   .float16Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}},
2416   // int -> BOOL8 map
2417   .bool8Operands = {},
2418   // int -> QUANT8_SYMM_PER_CHANNEL map
2419   .quant8ChannelOperands = {},
2420   // int -> QUANT16_ASYMM map
2421   .quant16AsymmOperands = {},
2422   // int -> QUANT8_SYMM map
2423   .quant8SymmOperands = {},
2424 },
2425 //Output(s)
2426 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2427   // int -> Dimensions map
2428   .operandDimensions = {{0, {1, 2, 2, 4}}},
2429   // int -> FLOAT32 map
2430   .float32Operands = {},
2431   // int -> INT32 map
2432   .int32Operands = {},
2433   // int -> QUANT8_ASYMM map
2434   .quant8AsymmOperands = {},
2435   // int -> QUANT16_SYMM map
2436   .quant16SymmOperands = {},
2437   // int -> FLOAT16 map
2438   .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}},
2439   // int -> BOOL8 map
2440   .bool8Operands = {},
2441   // int -> QUANT8_SYMM_PER_CHANNEL map
2442   .quant8ChannelOperands = {},
2443   // int -> QUANT16_ASYMM map
2444   .quant16AsymmOperands = {},
2445   // int -> QUANT8_SYMM map
2446   .quant8SymmOperands = {},
2447 }
2448 },
2449 }, // End of an example
2450 };
2451 return examples_valid_padding_nhwc_float16;
2452 };
2453 
get_examples_valid_padding_nhwc_quant8()2454 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_quant8() {
2455 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_quant8 = {
2456 // Begin of an example
2457 {
2458 .operands = {
2459 //Input(s)
2460 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2461   // int -> Dimensions map
2462   .operandDimensions = {{0, {1, 3, 3, 2}}},
2463   // int -> FLOAT32 map
2464   .float32Operands = {},
2465   // int -> INT32 map
2466   .int32Operands = {},
2467   // int -> QUANT8_ASYMM map
2468   .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}},
2469   // int -> QUANT16_SYMM map
2470   .quant16SymmOperands = {},
2471   // int -> FLOAT16 map
2472   .float16Operands = {},
2473   // int -> BOOL8 map
2474   .bool8Operands = {},
2475   // int -> QUANT8_SYMM_PER_CHANNEL map
2476   .quant8ChannelOperands = {},
2477   // int -> QUANT16_ASYMM map
2478   .quant16AsymmOperands = {},
2479   // int -> QUANT8_SYMM map
2480   .quant8SymmOperands = {},
2481 },
2482 //Output(s)
2483 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2484   // int -> Dimensions map
2485   .operandDimensions = {{0, {1, 2, 2, 4}}},
2486   // int -> FLOAT32 map
2487   .float32Operands = {},
2488   // int -> INT32 map
2489   .int32Operands = {},
2490   // int -> QUANT8_ASYMM map
2491   .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}},
2492   // int -> QUANT16_SYMM map
2493   .quant16SymmOperands = {},
2494   // int -> FLOAT16 map
2495   .float16Operands = {},
2496   // int -> BOOL8 map
2497   .bool8Operands = {},
2498   // int -> QUANT8_SYMM_PER_CHANNEL map
2499   .quant8ChannelOperands = {},
2500   // int -> QUANT16_ASYMM map
2501   .quant16AsymmOperands = {},
2502   // int -> QUANT8_SYMM map
2503   .quant8SymmOperands = {},
2504 }
2505 },
2506 }, // End of an example
2507 };
2508 return examples_valid_padding_nhwc_quant8;
2509 };
2510 
get_examples_valid_padding_nhwc_weight_as_input()2511 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_weight_as_input() {
2512 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_weight_as_input = {
2513 // Begin of an example
2514 {
2515 .operands = {
2516 //Input(s)
2517 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2518   // int -> Dimensions map
2519   .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
2520   // int -> FLOAT32 map
2521   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
2522   // int -> INT32 map
2523   .int32Operands = {},
2524   // int -> QUANT8_ASYMM map
2525   .quant8AsymmOperands = {},
2526   // int -> QUANT16_SYMM map
2527   .quant16SymmOperands = {},
2528   // int -> FLOAT16 map
2529   .float16Operands = {},
2530   // int -> BOOL8 map
2531   .bool8Operands = {},
2532   // int -> QUANT8_SYMM_PER_CHANNEL map
2533   .quant8ChannelOperands = {},
2534   // int -> QUANT16_ASYMM map
2535   .quant16AsymmOperands = {},
2536   // int -> QUANT8_SYMM map
2537   .quant8SymmOperands = {},
2538 },
2539 //Output(s)
2540 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2541   // int -> Dimensions map
2542   .operandDimensions = {{0, {1, 2, 2, 4}}},
2543   // int -> FLOAT32 map
2544   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
2545   // int -> INT32 map
2546   .int32Operands = {},
2547   // int -> QUANT8_ASYMM map
2548   .quant8AsymmOperands = {},
2549   // int -> QUANT16_SYMM map
2550   .quant16SymmOperands = {},
2551   // int -> FLOAT16 map
2552   .float16Operands = {},
2553   // int -> BOOL8 map
2554   .bool8Operands = {},
2555   // int -> QUANT8_SYMM_PER_CHANNEL map
2556   .quant8ChannelOperands = {},
2557   // int -> QUANT16_ASYMM map
2558   .quant16AsymmOperands = {},
2559   // int -> QUANT8_SYMM map
2560   .quant8SymmOperands = {},
2561 }
2562 },
2563 }, // End of an example
2564 };
2565 return examples_valid_padding_nhwc_weight_as_input;
2566 };
2567 
get_examples_valid_padding_nhwc_weight_as_input_relaxed()2568 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_weight_as_input_relaxed() {
2569 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_weight_as_input_relaxed = {
2570 // Begin of an example
2571 {
2572 .operands = {
2573 //Input(s)
2574 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2575   // int -> Dimensions map
2576   .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
2577   // int -> FLOAT32 map
2578   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
2579   // int -> INT32 map
2580   .int32Operands = {},
2581   // int -> QUANT8_ASYMM map
2582   .quant8AsymmOperands = {},
2583   // int -> QUANT16_SYMM map
2584   .quant16SymmOperands = {},
2585   // int -> FLOAT16 map
2586   .float16Operands = {},
2587   // int -> BOOL8 map
2588   .bool8Operands = {},
2589   // int -> QUANT8_SYMM_PER_CHANNEL map
2590   .quant8ChannelOperands = {},
2591   // int -> QUANT16_ASYMM map
2592   .quant16AsymmOperands = {},
2593   // int -> QUANT8_SYMM map
2594   .quant8SymmOperands = {},
2595 },
2596 //Output(s)
2597 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2598   // int -> Dimensions map
2599   .operandDimensions = {{0, {1, 2, 2, 4}}},
2600   // int -> FLOAT32 map
2601   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
2602   // int -> INT32 map
2603   .int32Operands = {},
2604   // int -> QUANT8_ASYMM map
2605   .quant8AsymmOperands = {},
2606   // int -> QUANT16_SYMM map
2607   .quant16SymmOperands = {},
2608   // int -> FLOAT16 map
2609   .float16Operands = {},
2610   // int -> BOOL8 map
2611   .bool8Operands = {},
2612   // int -> QUANT8_SYMM_PER_CHANNEL map
2613   .quant8ChannelOperands = {},
2614   // int -> QUANT16_ASYMM map
2615   .quant16AsymmOperands = {},
2616   // int -> QUANT8_SYMM map
2617   .quant8SymmOperands = {},
2618 }
2619 },
2620 }, // End of an example
2621 };
2622 return examples_valid_padding_nhwc_weight_as_input_relaxed;
2623 };
2624 
get_examples_valid_padding_nhwc_weight_as_input_float16()2625 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_weight_as_input_float16() {
2626 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_weight_as_input_float16 = {
2627 // Begin of an example
2628 {
2629 .operands = {
2630 //Input(s)
2631 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2632   // int -> Dimensions map
2633   .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
2634   // int -> FLOAT32 map
2635   .float32Operands = {},
2636   // int -> INT32 map
2637   .int32Operands = {},
2638   // int -> QUANT8_ASYMM map
2639   .quant8AsymmOperands = {},
2640   // int -> QUANT16_SYMM map
2641   .quant16SymmOperands = {},
2642   // int -> FLOAT16 map
2643   .float16Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
2644   // int -> BOOL8 map
2645   .bool8Operands = {},
2646   // int -> QUANT8_SYMM_PER_CHANNEL map
2647   .quant8ChannelOperands = {},
2648   // int -> QUANT16_ASYMM map
2649   .quant16AsymmOperands = {},
2650   // int -> QUANT8_SYMM map
2651   .quant8SymmOperands = {},
2652 },
2653 //Output(s)
2654 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2655   // int -> Dimensions map
2656   .operandDimensions = {{0, {1, 2, 2, 4}}},
2657   // int -> FLOAT32 map
2658   .float32Operands = {},
2659   // int -> INT32 map
2660   .int32Operands = {},
2661   // int -> QUANT8_ASYMM map
2662   .quant8AsymmOperands = {},
2663   // int -> QUANT16_SYMM map
2664   .quant16SymmOperands = {},
2665   // int -> FLOAT16 map
2666   .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}},
2667   // int -> BOOL8 map
2668   .bool8Operands = {},
2669   // int -> QUANT8_SYMM_PER_CHANNEL map
2670   .quant8ChannelOperands = {},
2671   // int -> QUANT16_ASYMM map
2672   .quant16AsymmOperands = {},
2673   // int -> QUANT8_SYMM map
2674   .quant8SymmOperands = {},
2675 }
2676 },
2677 }, // End of an example
2678 };
2679 return examples_valid_padding_nhwc_weight_as_input_float16;
2680 };
2681 
get_examples_valid_padding_nhwc_weight_as_input_quant8()2682 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_weight_as_input_quant8() {
2683 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_weight_as_input_quant8 = {
2684 // Begin of an example
2685 {
2686 .operands = {
2687 //Input(s)
2688 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2689   // int -> Dimensions map
2690   .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
2691   // int -> FLOAT32 map
2692   .float32Operands = {},
2693   // int -> INT32 map
2694   .int32Operands = {{2, {200, 400, 600, 800}}},
2695   // int -> QUANT8_ASYMM map
2696   .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}},
2697   // int -> QUANT16_SYMM map
2698   .quant16SymmOperands = {},
2699   // int -> FLOAT16 map
2700   .float16Operands = {},
2701   // int -> BOOL8 map
2702   .bool8Operands = {},
2703   // int -> QUANT8_SYMM_PER_CHANNEL map
2704   .quant8ChannelOperands = {},
2705   // int -> QUANT16_ASYMM map
2706   .quant16AsymmOperands = {},
2707   // int -> QUANT8_SYMM map
2708   .quant8SymmOperands = {},
2709 },
2710 //Output(s)
2711 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2712   // int -> Dimensions map
2713   .operandDimensions = {{0, {1, 2, 2, 4}}},
2714   // int -> FLOAT32 map
2715   .float32Operands = {},
2716   // int -> INT32 map
2717   .int32Operands = {},
2718   // int -> QUANT8_ASYMM map
2719   .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}},
2720   // int -> QUANT16_SYMM map
2721   .quant16SymmOperands = {},
2722   // int -> FLOAT16 map
2723   .float16Operands = {},
2724   // int -> BOOL8 map
2725   .bool8Operands = {},
2726   // int -> QUANT8_SYMM_PER_CHANNEL map
2727   .quant8ChannelOperands = {},
2728   // int -> QUANT16_ASYMM map
2729   .quant16AsymmOperands = {},
2730   // int -> QUANT8_SYMM map
2731   .quant8SymmOperands = {},
2732 }
2733 },
2734 }, // End of an example
2735 };
2736 return examples_valid_padding_nhwc_weight_as_input_quant8;
2737 };
2738 
get_examples_valid_padding_nchw()2739 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw() {
2740 static std::vector<MixedTypedExample> examples_valid_padding_nchw = {
2741 // Begin of an example
2742 {
2743 .operands = {
2744 //Input(s)
2745 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2746   // int -> Dimensions map
2747   .operandDimensions = {{0, {1, 2, 3, 3}}},
2748   // int -> FLOAT32 map
2749   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}},
2750   // int -> INT32 map
2751   .int32Operands = {},
2752   // int -> QUANT8_ASYMM map
2753   .quant8AsymmOperands = {},
2754   // int -> QUANT16_SYMM map
2755   .quant16SymmOperands = {},
2756   // int -> FLOAT16 map
2757   .float16Operands = {},
2758   // int -> BOOL8 map
2759   .bool8Operands = {},
2760   // int -> QUANT8_SYMM_PER_CHANNEL map
2761   .quant8ChannelOperands = {},
2762   // int -> QUANT16_ASYMM map
2763   .quant16AsymmOperands = {},
2764   // int -> QUANT8_SYMM map
2765   .quant8SymmOperands = {},
2766 },
2767 //Output(s)
2768 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2769   // int -> Dimensions map
2770   .operandDimensions = {{0, {1, 4, 2, 2}}},
2771   // int -> FLOAT32 map
2772   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
2773   // int -> INT32 map
2774   .int32Operands = {},
2775   // int -> QUANT8_ASYMM map
2776   .quant8AsymmOperands = {},
2777   // int -> QUANT16_SYMM map
2778   .quant16SymmOperands = {},
2779   // int -> FLOAT16 map
2780   .float16Operands = {},
2781   // int -> BOOL8 map
2782   .bool8Operands = {},
2783   // int -> QUANT8_SYMM_PER_CHANNEL map
2784   .quant8ChannelOperands = {},
2785   // int -> QUANT16_ASYMM map
2786   .quant16AsymmOperands = {},
2787   // int -> QUANT8_SYMM map
2788   .quant8SymmOperands = {},
2789 }
2790 },
2791 }, // End of an example
2792 };
2793 return examples_valid_padding_nchw;
2794 };
2795 
get_examples_valid_padding_nchw_relaxed()2796 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_relaxed() {
2797 static std::vector<MixedTypedExample> examples_valid_padding_nchw_relaxed = {
2798 // Begin of an example
2799 {
2800 .operands = {
2801 //Input(s)
2802 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2803   // int -> Dimensions map
2804   .operandDimensions = {{0, {1, 2, 3, 3}}},
2805   // int -> FLOAT32 map
2806   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}},
2807   // int -> INT32 map
2808   .int32Operands = {},
2809   // int -> QUANT8_ASYMM map
2810   .quant8AsymmOperands = {},
2811   // int -> QUANT16_SYMM map
2812   .quant16SymmOperands = {},
2813   // int -> FLOAT16 map
2814   .float16Operands = {},
2815   // int -> BOOL8 map
2816   .bool8Operands = {},
2817   // int -> QUANT8_SYMM_PER_CHANNEL map
2818   .quant8ChannelOperands = {},
2819   // int -> QUANT16_ASYMM map
2820   .quant16AsymmOperands = {},
2821   // int -> QUANT8_SYMM map
2822   .quant8SymmOperands = {},
2823 },
2824 //Output(s)
2825 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2826   // int -> Dimensions map
2827   .operandDimensions = {{0, {1, 4, 2, 2}}},
2828   // int -> FLOAT32 map
2829   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
2830   // int -> INT32 map
2831   .int32Operands = {},
2832   // int -> QUANT8_ASYMM map
2833   .quant8AsymmOperands = {},
2834   // int -> QUANT16_SYMM map
2835   .quant16SymmOperands = {},
2836   // int -> FLOAT16 map
2837   .float16Operands = {},
2838   // int -> BOOL8 map
2839   .bool8Operands = {},
2840   // int -> QUANT8_SYMM_PER_CHANNEL map
2841   .quant8ChannelOperands = {},
2842   // int -> QUANT16_ASYMM map
2843   .quant16AsymmOperands = {},
2844   // int -> QUANT8_SYMM map
2845   .quant8SymmOperands = {},
2846 }
2847 },
2848 }, // End of an example
2849 };
2850 return examples_valid_padding_nchw_relaxed;
2851 };
2852 
get_examples_valid_padding_nchw_float16()2853 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_float16() {
2854 static std::vector<MixedTypedExample> examples_valid_padding_nchw_float16 = {
2855 // Begin of an example
2856 {
2857 .operands = {
2858 //Input(s)
2859 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2860   // int -> Dimensions map
2861   .operandDimensions = {{0, {1, 2, 3, 3}}},
2862   // int -> FLOAT32 map
2863   .float32Operands = {},
2864   // int -> INT32 map
2865   .int32Operands = {},
2866   // int -> QUANT8_ASYMM map
2867   .quant8AsymmOperands = {},
2868   // int -> QUANT16_SYMM map
2869   .quant16SymmOperands = {},
2870   // int -> FLOAT16 map
2871   .float16Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}},
2872   // int -> BOOL8 map
2873   .bool8Operands = {},
2874   // int -> QUANT8_SYMM_PER_CHANNEL map
2875   .quant8ChannelOperands = {},
2876   // int -> QUANT16_ASYMM map
2877   .quant16AsymmOperands = {},
2878   // int -> QUANT8_SYMM map
2879   .quant8SymmOperands = {},
2880 },
2881 //Output(s)
2882 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2883   // int -> Dimensions map
2884   .operandDimensions = {{0, {1, 4, 2, 2}}},
2885   // int -> FLOAT32 map
2886   .float32Operands = {},
2887   // int -> INT32 map
2888   .int32Operands = {},
2889   // int -> QUANT8_ASYMM map
2890   .quant8AsymmOperands = {},
2891   // int -> QUANT16_SYMM map
2892   .quant16SymmOperands = {},
2893   // int -> FLOAT16 map
2894   .float16Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}},
2895   // int -> BOOL8 map
2896   .bool8Operands = {},
2897   // int -> QUANT8_SYMM_PER_CHANNEL map
2898   .quant8ChannelOperands = {},
2899   // int -> QUANT16_ASYMM map
2900   .quant16AsymmOperands = {},
2901   // int -> QUANT8_SYMM map
2902   .quant8SymmOperands = {},
2903 }
2904 },
2905 }, // End of an example
2906 };
2907 return examples_valid_padding_nchw_float16;
2908 };
2909 
get_examples_valid_padding_nchw_quant8()2910 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_quant8() {
2911 static std::vector<MixedTypedExample> examples_valid_padding_nchw_quant8 = {
2912 // Begin of an example
2913 {
2914 .operands = {
2915 //Input(s)
2916 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2917   // int -> Dimensions map
2918   .operandDimensions = {{0, {1, 2, 3, 3}}},
2919   // int -> FLOAT32 map
2920   .float32Operands = {},
2921   // int -> INT32 map
2922   .int32Operands = {},
2923   // int -> QUANT8_ASYMM map
2924   .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}},
2925   // int -> QUANT16_SYMM map
2926   .quant16SymmOperands = {},
2927   // int -> FLOAT16 map
2928   .float16Operands = {},
2929   // int -> BOOL8 map
2930   .bool8Operands = {},
2931   // int -> QUANT8_SYMM_PER_CHANNEL map
2932   .quant8ChannelOperands = {},
2933   // int -> QUANT16_ASYMM map
2934   .quant16AsymmOperands = {},
2935   // int -> QUANT8_SYMM map
2936   .quant8SymmOperands = {},
2937 },
2938 //Output(s)
2939 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2940   // int -> Dimensions map
2941   .operandDimensions = {{0, {1, 4, 2, 2}}},
2942   // int -> FLOAT32 map
2943   .float32Operands = {},
2944   // int -> INT32 map
2945   .int32Operands = {},
2946   // int -> QUANT8_ASYMM map
2947   .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}},
2948   // int -> QUANT16_SYMM map
2949   .quant16SymmOperands = {},
2950   // int -> FLOAT16 map
2951   .float16Operands = {},
2952   // int -> BOOL8 map
2953   .bool8Operands = {},
2954   // int -> QUANT8_SYMM_PER_CHANNEL map
2955   .quant8ChannelOperands = {},
2956   // int -> QUANT16_ASYMM map
2957   .quant16AsymmOperands = {},
2958   // int -> QUANT8_SYMM map
2959   .quant8SymmOperands = {},
2960 }
2961 },
2962 }, // End of an example
2963 };
2964 return examples_valid_padding_nchw_quant8;
2965 };
2966 
get_examples_valid_padding_nchw_weight_as_input()2967 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_weight_as_input() {
2968 static std::vector<MixedTypedExample> examples_valid_padding_nchw_weight_as_input = {
2969 // Begin of an example
2970 {
2971 .operands = {
2972 //Input(s)
2973 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2974   // int -> Dimensions map
2975   .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
2976   // int -> FLOAT32 map
2977   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
2978   // int -> INT32 map
2979   .int32Operands = {},
2980   // int -> QUANT8_ASYMM map
2981   .quant8AsymmOperands = {},
2982   // int -> QUANT16_SYMM map
2983   .quant16SymmOperands = {},
2984   // int -> FLOAT16 map
2985   .float16Operands = {},
2986   // int -> BOOL8 map
2987   .bool8Operands = {},
2988   // int -> QUANT8_SYMM_PER_CHANNEL map
2989   .quant8ChannelOperands = {},
2990   // int -> QUANT16_ASYMM map
2991   .quant16AsymmOperands = {},
2992   // int -> QUANT8_SYMM map
2993   .quant8SymmOperands = {},
2994 },
2995 //Output(s)
2996 { // See tools/test_generator/include/TestHarness.h:MixedTyped
2997   // int -> Dimensions map
2998   .operandDimensions = {{0, {1, 4, 2, 2}}},
2999   // int -> FLOAT32 map
3000   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
3001   // int -> INT32 map
3002   .int32Operands = {},
3003   // int -> QUANT8_ASYMM map
3004   .quant8AsymmOperands = {},
3005   // int -> QUANT16_SYMM map
3006   .quant16SymmOperands = {},
3007   // int -> FLOAT16 map
3008   .float16Operands = {},
3009   // int -> BOOL8 map
3010   .bool8Operands = {},
3011   // int -> QUANT8_SYMM_PER_CHANNEL map
3012   .quant8ChannelOperands = {},
3013   // int -> QUANT16_ASYMM map
3014   .quant16AsymmOperands = {},
3015   // int -> QUANT8_SYMM map
3016   .quant8SymmOperands = {},
3017 }
3018 },
3019 }, // End of an example
3020 };
3021 return examples_valid_padding_nchw_weight_as_input;
3022 };
3023 
get_examples_valid_padding_nchw_weight_as_input_relaxed()3024 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_weight_as_input_relaxed() {
3025 static std::vector<MixedTypedExample> examples_valid_padding_nchw_weight_as_input_relaxed = {
3026 // Begin of an example
3027 {
3028 .operands = {
3029 //Input(s)
3030 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3031   // int -> Dimensions map
3032   .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
3033   // int -> FLOAT32 map
3034   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
3035   // int -> INT32 map
3036   .int32Operands = {},
3037   // int -> QUANT8_ASYMM map
3038   .quant8AsymmOperands = {},
3039   // int -> QUANT16_SYMM map
3040   .quant16SymmOperands = {},
3041   // int -> FLOAT16 map
3042   .float16Operands = {},
3043   // int -> BOOL8 map
3044   .bool8Operands = {},
3045   // int -> QUANT8_SYMM_PER_CHANNEL map
3046   .quant8ChannelOperands = {},
3047   // int -> QUANT16_ASYMM map
3048   .quant16AsymmOperands = {},
3049   // int -> QUANT8_SYMM map
3050   .quant8SymmOperands = {},
3051 },
3052 //Output(s)
3053 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3054   // int -> Dimensions map
3055   .operandDimensions = {{0, {1, 4, 2, 2}}},
3056   // int -> FLOAT32 map
3057   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
3058   // int -> INT32 map
3059   .int32Operands = {},
3060   // int -> QUANT8_ASYMM map
3061   .quant8AsymmOperands = {},
3062   // int -> QUANT16_SYMM map
3063   .quant16SymmOperands = {},
3064   // int -> FLOAT16 map
3065   .float16Operands = {},
3066   // int -> BOOL8 map
3067   .bool8Operands = {},
3068   // int -> QUANT8_SYMM_PER_CHANNEL map
3069   .quant8ChannelOperands = {},
3070   // int -> QUANT16_ASYMM map
3071   .quant16AsymmOperands = {},
3072   // int -> QUANT8_SYMM map
3073   .quant8SymmOperands = {},
3074 }
3075 },
3076 }, // End of an example
3077 };
3078 return examples_valid_padding_nchw_weight_as_input_relaxed;
3079 };
3080 
get_examples_valid_padding_nchw_weight_as_input_float16()3081 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_weight_as_input_float16() {
3082 static std::vector<MixedTypedExample> examples_valid_padding_nchw_weight_as_input_float16 = {
3083 // Begin of an example
3084 {
3085 .operands = {
3086 //Input(s)
3087 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3088   // int -> Dimensions map
3089   .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
3090   // int -> FLOAT32 map
3091   .float32Operands = {},
3092   // int -> INT32 map
3093   .int32Operands = {},
3094   // int -> QUANT8_ASYMM map
3095   .quant8AsymmOperands = {},
3096   // int -> QUANT16_SYMM map
3097   .quant16SymmOperands = {},
3098   // int -> FLOAT16 map
3099   .float16Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
3100   // int -> BOOL8 map
3101   .bool8Operands = {},
3102   // int -> QUANT8_SYMM_PER_CHANNEL map
3103   .quant8ChannelOperands = {},
3104   // int -> QUANT16_ASYMM map
3105   .quant16AsymmOperands = {},
3106   // int -> QUANT8_SYMM map
3107   .quant8SymmOperands = {},
3108 },
3109 //Output(s)
3110 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3111   // int -> Dimensions map
3112   .operandDimensions = {{0, {1, 4, 2, 2}}},
3113   // int -> FLOAT32 map
3114   .float32Operands = {},
3115   // int -> INT32 map
3116   .int32Operands = {},
3117   // int -> QUANT8_ASYMM map
3118   .quant8AsymmOperands = {},
3119   // int -> QUANT16_SYMM map
3120   .quant16SymmOperands = {},
3121   // int -> FLOAT16 map
3122   .float16Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}},
3123   // int -> BOOL8 map
3124   .bool8Operands = {},
3125   // int -> QUANT8_SYMM_PER_CHANNEL map
3126   .quant8ChannelOperands = {},
3127   // int -> QUANT16_ASYMM map
3128   .quant16AsymmOperands = {},
3129   // int -> QUANT8_SYMM map
3130   .quant8SymmOperands = {},
3131 }
3132 },
3133 }, // End of an example
3134 };
3135 return examples_valid_padding_nchw_weight_as_input_float16;
3136 };
3137 
get_examples_valid_padding_nchw_weight_as_input_quant8()3138 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_weight_as_input_quant8() {
3139 static std::vector<MixedTypedExample> examples_valid_padding_nchw_weight_as_input_quant8 = {
3140 // Begin of an example
3141 {
3142 .operands = {
3143 //Input(s)
3144 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3145   // int -> Dimensions map
3146   .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
3147   // int -> FLOAT32 map
3148   .float32Operands = {},
3149   // int -> INT32 map
3150   .int32Operands = {{2, {200, 400, 600, 800}}},
3151   // int -> QUANT8_ASYMM map
3152   .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}},
3153   // int -> QUANT16_SYMM map
3154   .quant16SymmOperands = {},
3155   // int -> FLOAT16 map
3156   .float16Operands = {},
3157   // int -> BOOL8 map
3158   .bool8Operands = {},
3159   // int -> QUANT8_SYMM_PER_CHANNEL map
3160   .quant8ChannelOperands = {},
3161   // int -> QUANT16_ASYMM map
3162   .quant16AsymmOperands = {},
3163   // int -> QUANT8_SYMM map
3164   .quant8SymmOperands = {},
3165 },
3166 //Output(s)
3167 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3168   // int -> Dimensions map
3169   .operandDimensions = {{0, {1, 4, 2, 2}}},
3170   // int -> FLOAT32 map
3171   .float32Operands = {},
3172   // int -> INT32 map
3173   .int32Operands = {},
3174   // int -> QUANT8_ASYMM map
3175   .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}},
3176   // int -> QUANT16_SYMM map
3177   .quant16SymmOperands = {},
3178   // int -> FLOAT16 map
3179   .float16Operands = {},
3180   // int -> BOOL8 map
3181   .bool8Operands = {},
3182   // int -> QUANT8_SYMM_PER_CHANNEL map
3183   .quant8ChannelOperands = {},
3184   // int -> QUANT16_ASYMM map
3185   .quant16AsymmOperands = {},
3186   // int -> QUANT8_SYMM map
3187   .quant8SymmOperands = {},
3188 }
3189 },
3190 }, // End of an example
3191 };
3192 return examples_valid_padding_nchw_weight_as_input_quant8;
3193 };
3194 
get_examples_valid_padding_dynamic_output_shape_nhwc()3195 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc() {
3196 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc = {
3197 // Begin of an example
3198 {
3199 .operands = {
3200 //Input(s)
3201 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3202   // int -> Dimensions map
3203   .operandDimensions = {{0, {1, 3, 3, 2}}},
3204   // int -> FLOAT32 map
3205   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}},
3206   // int -> INT32 map
3207   .int32Operands = {},
3208   // int -> QUANT8_ASYMM map
3209   .quant8AsymmOperands = {},
3210   // int -> QUANT16_SYMM map
3211   .quant16SymmOperands = {},
3212   // int -> FLOAT16 map
3213   .float16Operands = {},
3214   // int -> BOOL8 map
3215   .bool8Operands = {},
3216   // int -> QUANT8_SYMM_PER_CHANNEL map
3217   .quant8ChannelOperands = {},
3218   // int -> QUANT16_ASYMM map
3219   .quant16AsymmOperands = {},
3220   // int -> QUANT8_SYMM map
3221   .quant8SymmOperands = {},
3222 },
3223 //Output(s)
3224 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3225   // int -> Dimensions map
3226   .operandDimensions = {{0, {1, 2, 2, 4}}},
3227   // int -> FLOAT32 map
3228   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
3229   // int -> INT32 map
3230   .int32Operands = {},
3231   // int -> QUANT8_ASYMM map
3232   .quant8AsymmOperands = {},
3233   // int -> QUANT16_SYMM map
3234   .quant16SymmOperands = {},
3235   // int -> FLOAT16 map
3236   .float16Operands = {},
3237   // int -> BOOL8 map
3238   .bool8Operands = {},
3239   // int -> QUANT8_SYMM_PER_CHANNEL map
3240   .quant8ChannelOperands = {},
3241   // int -> QUANT16_ASYMM map
3242   .quant16AsymmOperands = {},
3243   // int -> QUANT8_SYMM map
3244   .quant8SymmOperands = {},
3245 }
3246 },
3247 }, // End of an example
3248 };
3249 return examples_valid_padding_dynamic_output_shape_nhwc;
3250 };
3251 
get_examples_valid_padding_dynamic_output_shape_nhwc_relaxed()3252 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_relaxed() {
3253 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_relaxed = {
3254 // Begin of an example
3255 {
3256 .operands = {
3257 //Input(s)
3258 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3259   // int -> Dimensions map
3260   .operandDimensions = {{0, {1, 3, 3, 2}}},
3261   // int -> FLOAT32 map
3262   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}},
3263   // int -> INT32 map
3264   .int32Operands = {},
3265   // int -> QUANT8_ASYMM map
3266   .quant8AsymmOperands = {},
3267   // int -> QUANT16_SYMM map
3268   .quant16SymmOperands = {},
3269   // int -> FLOAT16 map
3270   .float16Operands = {},
3271   // int -> BOOL8 map
3272   .bool8Operands = {},
3273   // int -> QUANT8_SYMM_PER_CHANNEL map
3274   .quant8ChannelOperands = {},
3275   // int -> QUANT16_ASYMM map
3276   .quant16AsymmOperands = {},
3277   // int -> QUANT8_SYMM map
3278   .quant8SymmOperands = {},
3279 },
3280 //Output(s)
3281 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3282   // int -> Dimensions map
3283   .operandDimensions = {{0, {1, 2, 2, 4}}},
3284   // int -> FLOAT32 map
3285   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
3286   // int -> INT32 map
3287   .int32Operands = {},
3288   // int -> QUANT8_ASYMM map
3289   .quant8AsymmOperands = {},
3290   // int -> QUANT16_SYMM map
3291   .quant16SymmOperands = {},
3292   // int -> FLOAT16 map
3293   .float16Operands = {},
3294   // int -> BOOL8 map
3295   .bool8Operands = {},
3296   // int -> QUANT8_SYMM_PER_CHANNEL map
3297   .quant8ChannelOperands = {},
3298   // int -> QUANT16_ASYMM map
3299   .quant16AsymmOperands = {},
3300   // int -> QUANT8_SYMM map
3301   .quant8SymmOperands = {},
3302 }
3303 },
3304 }, // End of an example
3305 };
3306 return examples_valid_padding_dynamic_output_shape_nhwc_relaxed;
3307 };
3308 
get_examples_valid_padding_dynamic_output_shape_nhwc_float16()3309 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_float16() {
3310 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_float16 = {
3311 // Begin of an example
3312 {
3313 .operands = {
3314 //Input(s)
3315 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3316   // int -> Dimensions map
3317   .operandDimensions = {{0, {1, 3, 3, 2}}},
3318   // int -> FLOAT32 map
3319   .float32Operands = {},
3320   // int -> INT32 map
3321   .int32Operands = {},
3322   // int -> QUANT8_ASYMM map
3323   .quant8AsymmOperands = {},
3324   // int -> QUANT16_SYMM map
3325   .quant16SymmOperands = {},
3326   // int -> FLOAT16 map
3327   .float16Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}},
3328   // int -> BOOL8 map
3329   .bool8Operands = {},
3330   // int -> QUANT8_SYMM_PER_CHANNEL map
3331   .quant8ChannelOperands = {},
3332   // int -> QUANT16_ASYMM map
3333   .quant16AsymmOperands = {},
3334   // int -> QUANT8_SYMM map
3335   .quant8SymmOperands = {},
3336 },
3337 //Output(s)
3338 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3339   // int -> Dimensions map
3340   .operandDimensions = {{0, {1, 2, 2, 4}}},
3341   // int -> FLOAT32 map
3342   .float32Operands = {},
3343   // int -> INT32 map
3344   .int32Operands = {},
3345   // int -> QUANT8_ASYMM map
3346   .quant8AsymmOperands = {},
3347   // int -> QUANT16_SYMM map
3348   .quant16SymmOperands = {},
3349   // int -> FLOAT16 map
3350   .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}},
3351   // int -> BOOL8 map
3352   .bool8Operands = {},
3353   // int -> QUANT8_SYMM_PER_CHANNEL map
3354   .quant8ChannelOperands = {},
3355   // int -> QUANT16_ASYMM map
3356   .quant16AsymmOperands = {},
3357   // int -> QUANT8_SYMM map
3358   .quant8SymmOperands = {},
3359 }
3360 },
3361 }, // End of an example
3362 };
3363 return examples_valid_padding_dynamic_output_shape_nhwc_float16;
3364 };
3365 
get_examples_valid_padding_dynamic_output_shape_nhwc_quant8()3366 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_quant8() {
3367 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_quant8 = {
3368 // Begin of an example
3369 {
3370 .operands = {
3371 //Input(s)
3372 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3373   // int -> Dimensions map
3374   .operandDimensions = {{0, {1, 3, 3, 2}}},
3375   // int -> FLOAT32 map
3376   .float32Operands = {},
3377   // int -> INT32 map
3378   .int32Operands = {},
3379   // int -> QUANT8_ASYMM map
3380   .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}},
3381   // int -> QUANT16_SYMM map
3382   .quant16SymmOperands = {},
3383   // int -> FLOAT16 map
3384   .float16Operands = {},
3385   // int -> BOOL8 map
3386   .bool8Operands = {},
3387   // int -> QUANT8_SYMM_PER_CHANNEL map
3388   .quant8ChannelOperands = {},
3389   // int -> QUANT16_ASYMM map
3390   .quant16AsymmOperands = {},
3391   // int -> QUANT8_SYMM map
3392   .quant8SymmOperands = {},
3393 },
3394 //Output(s)
3395 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3396   // int -> Dimensions map
3397   .operandDimensions = {{0, {1, 2, 2, 4}}},
3398   // int -> FLOAT32 map
3399   .float32Operands = {},
3400   // int -> INT32 map
3401   .int32Operands = {},
3402   // int -> QUANT8_ASYMM map
3403   .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}},
3404   // int -> QUANT16_SYMM map
3405   .quant16SymmOperands = {},
3406   // int -> FLOAT16 map
3407   .float16Operands = {},
3408   // int -> BOOL8 map
3409   .bool8Operands = {},
3410   // int -> QUANT8_SYMM_PER_CHANNEL map
3411   .quant8ChannelOperands = {},
3412   // int -> QUANT16_ASYMM map
3413   .quant16AsymmOperands = {},
3414   // int -> QUANT8_SYMM map
3415   .quant8SymmOperands = {},
3416 }
3417 },
3418 }, // End of an example
3419 };
3420 return examples_valid_padding_dynamic_output_shape_nhwc_quant8;
3421 };
3422 
get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input()3423 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input() {
3424 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input = {
3425 // Begin of an example
3426 {
3427 .operands = {
3428 //Input(s)
3429 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3430   // int -> Dimensions map
3431   .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
3432   // int -> FLOAT32 map
3433   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
3434   // int -> INT32 map
3435   .int32Operands = {},
3436   // int -> QUANT8_ASYMM map
3437   .quant8AsymmOperands = {},
3438   // int -> QUANT16_SYMM map
3439   .quant16SymmOperands = {},
3440   // int -> FLOAT16 map
3441   .float16Operands = {},
3442   // int -> BOOL8 map
3443   .bool8Operands = {},
3444   // int -> QUANT8_SYMM_PER_CHANNEL map
3445   .quant8ChannelOperands = {},
3446   // int -> QUANT16_ASYMM map
3447   .quant16AsymmOperands = {},
3448   // int -> QUANT8_SYMM map
3449   .quant8SymmOperands = {},
3450 },
3451 //Output(s)
3452 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3453   // int -> Dimensions map
3454   .operandDimensions = {{0, {1, 2, 2, 4}}},
3455   // int -> FLOAT32 map
3456   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
3457   // int -> INT32 map
3458   .int32Operands = {},
3459   // int -> QUANT8_ASYMM map
3460   .quant8AsymmOperands = {},
3461   // int -> QUANT16_SYMM map
3462   .quant16SymmOperands = {},
3463   // int -> FLOAT16 map
3464   .float16Operands = {},
3465   // int -> BOOL8 map
3466   .bool8Operands = {},
3467   // int -> QUANT8_SYMM_PER_CHANNEL map
3468   .quant8ChannelOperands = {},
3469   // int -> QUANT16_ASYMM map
3470   .quant16AsymmOperands = {},
3471   // int -> QUANT8_SYMM map
3472   .quant8SymmOperands = {},
3473 }
3474 },
3475 }, // End of an example
3476 };
3477 return examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input;
3478 };
3479 
get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_relaxed()3480 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_relaxed() {
3481 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_relaxed = {
3482 // Begin of an example
3483 {
3484 .operands = {
3485 //Input(s)
3486 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3487   // int -> Dimensions map
3488   .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
3489   // int -> FLOAT32 map
3490   .float32Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
3491   // int -> INT32 map
3492   .int32Operands = {},
3493   // int -> QUANT8_ASYMM map
3494   .quant8AsymmOperands = {},
3495   // int -> QUANT16_SYMM map
3496   .quant16SymmOperands = {},
3497   // int -> FLOAT16 map
3498   .float16Operands = {},
3499   // int -> BOOL8 map
3500   .bool8Operands = {},
3501   // int -> QUANT8_SYMM_PER_CHANNEL map
3502   .quant8ChannelOperands = {},
3503   // int -> QUANT16_ASYMM map
3504   .quant16AsymmOperands = {},
3505   // int -> QUANT8_SYMM map
3506   .quant8SymmOperands = {},
3507 },
3508 //Output(s)
3509 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3510   // int -> Dimensions map
3511   .operandDimensions = {{0, {1, 2, 2, 4}}},
3512   // int -> FLOAT32 map
3513   .float32Operands = {{0, {11.0f, 3.0f, 7.2f, 10.6f, 11.0f, 3.0f, 7.4f, 10.9f, 11.0f, 3.0f, 7.8f, 11.5f, 11.0f, 3.0f, 8.0f, 11.8f}}},
3514   // int -> INT32 map
3515   .int32Operands = {},
3516   // int -> QUANT8_ASYMM map
3517   .quant8AsymmOperands = {},
3518   // int -> QUANT16_SYMM map
3519   .quant16SymmOperands = {},
3520   // int -> FLOAT16 map
3521   .float16Operands = {},
3522   // int -> BOOL8 map
3523   .bool8Operands = {},
3524   // int -> QUANT8_SYMM_PER_CHANNEL map
3525   .quant8ChannelOperands = {},
3526   // int -> QUANT16_ASYMM map
3527   .quant16AsymmOperands = {},
3528   // int -> QUANT8_SYMM map
3529   .quant8SymmOperands = {},
3530 }
3531 },
3532 }, // End of an example
3533 };
3534 return examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_relaxed;
3535 };
3536 
get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_float16()3537 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_float16() {
3538 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_float16 = {
3539 // Begin of an example
3540 {
3541 .operands = {
3542 //Input(s)
3543 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3544   // int -> Dimensions map
3545   .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
3546   // int -> FLOAT32 map
3547   .float32Operands = {},
3548   // int -> INT32 map
3549   .int32Operands = {},
3550   // int -> QUANT8_ASYMM map
3551   .quant8AsymmOperands = {},
3552   // int -> QUANT16_SYMM map
3553   .quant16SymmOperands = {},
3554   // int -> FLOAT16 map
3555   .float16Operands = {{0, {10.0f, 21.0f, 10.0f, 22.0f, 10.0f, 23.0f, 10.0f, 24.0f, 10.0f, 25.0f, 10.0f, 26.0f, 10.0f, 27.0f, 10.0f, 28.0f, 10.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
3556   // int -> BOOL8 map
3557   .bool8Operands = {},
3558   // int -> QUANT8_SYMM_PER_CHANNEL map
3559   .quant8ChannelOperands = {},
3560   // int -> QUANT16_ASYMM map
3561   .quant16AsymmOperands = {},
3562   // int -> QUANT8_SYMM map
3563   .quant8SymmOperands = {},
3564 },
3565 //Output(s)
3566 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3567   // int -> Dimensions map
3568   .operandDimensions = {{0, {1, 2, 2, 4}}},
3569   // int -> FLOAT32 map
3570   .float32Operands = {},
3571   // int -> INT32 map
3572   .int32Operands = {},
3573   // int -> QUANT8_ASYMM map
3574   .quant8AsymmOperands = {},
3575   // int -> QUANT16_SYMM map
3576   .quant16SymmOperands = {},
3577   // int -> FLOAT16 map
3578   .float16Operands = {{0, {11.0f, 3.0f, 7.199999809265137f, 10.600000381469727f, 11.0f, 3.0f, 7.400000095367432f, 10.899999618530273f, 11.0f, 3.0f, 7.800000190734863f, 11.5f, 11.0f, 3.0f, 8.0f, 11.800000190734863f}}},
3579   // int -> BOOL8 map
3580   .bool8Operands = {},
3581   // int -> QUANT8_SYMM_PER_CHANNEL map
3582   .quant8ChannelOperands = {},
3583   // int -> QUANT16_ASYMM map
3584   .quant16AsymmOperands = {},
3585   // int -> QUANT8_SYMM map
3586   .quant8SymmOperands = {},
3587 }
3588 },
3589 }, // End of an example
3590 };
3591 return examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_float16;
3592 };
3593 
get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_quant8()3594 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_quant8() {
3595 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_quant8 = {
3596 // Begin of an example
3597 {
3598 .operands = {
3599 //Input(s)
3600 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3601   // int -> Dimensions map
3602   .operandDimensions = {{0, {1, 3, 3, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
3603   // int -> FLOAT32 map
3604   .float32Operands = {},
3605   // int -> INT32 map
3606   .int32Operands = {{2, {200, 400, 600, 800}}},
3607   // int -> QUANT8_ASYMM map
3608   .quant8AsymmOperands = {{0, {20, 42, 20, 44, 20, 46, 20, 48, 20, 50, 20, 52, 20, 54, 20, 56, 20, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}},
3609   // int -> QUANT16_SYMM map
3610   .quant16SymmOperands = {},
3611   // int -> FLOAT16 map
3612   .float16Operands = {},
3613   // int -> BOOL8 map
3614   .bool8Operands = {},
3615   // int -> QUANT8_SYMM_PER_CHANNEL map
3616   .quant8ChannelOperands = {},
3617   // int -> QUANT16_ASYMM map
3618   .quant16AsymmOperands = {},
3619   // int -> QUANT8_SYMM map
3620   .quant8SymmOperands = {},
3621 },
3622 //Output(s)
3623 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3624   // int -> Dimensions map
3625   .operandDimensions = {{0, {1, 2, 2, 4}}},
3626   // int -> FLOAT32 map
3627   .float32Operands = {},
3628   // int -> INT32 map
3629   .int32Operands = {},
3630   // int -> QUANT8_ASYMM map
3631   .quant8AsymmOperands = {{0, {110, 30, 72, 106, 110, 30, 74, 109, 110, 30, 78, 115, 110, 30, 80, 118}}},
3632   // int -> QUANT16_SYMM map
3633   .quant16SymmOperands = {},
3634   // int -> FLOAT16 map
3635   .float16Operands = {},
3636   // int -> BOOL8 map
3637   .bool8Operands = {},
3638   // int -> QUANT8_SYMM_PER_CHANNEL map
3639   .quant8ChannelOperands = {},
3640   // int -> QUANT16_ASYMM map
3641   .quant16AsymmOperands = {},
3642   // int -> QUANT8_SYMM map
3643   .quant8SymmOperands = {},
3644 }
3645 },
3646 }, // End of an example
3647 };
3648 return examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_quant8;
3649 };
3650 
get_examples_valid_padding_dynamic_output_shape_nchw()3651 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw() {
3652 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw = {
3653 // Begin of an example
3654 {
3655 .operands = {
3656 //Input(s)
3657 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3658   // int -> Dimensions map
3659   .operandDimensions = {{0, {1, 2, 3, 3}}},
3660   // int -> FLOAT32 map
3661   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}},
3662   // int -> INT32 map
3663   .int32Operands = {},
3664   // int -> QUANT8_ASYMM map
3665   .quant8AsymmOperands = {},
3666   // int -> QUANT16_SYMM map
3667   .quant16SymmOperands = {},
3668   // int -> FLOAT16 map
3669   .float16Operands = {},
3670   // int -> BOOL8 map
3671   .bool8Operands = {},
3672   // int -> QUANT8_SYMM_PER_CHANNEL map
3673   .quant8ChannelOperands = {},
3674   // int -> QUANT16_ASYMM map
3675   .quant16AsymmOperands = {},
3676   // int -> QUANT8_SYMM map
3677   .quant8SymmOperands = {},
3678 },
3679 //Output(s)
3680 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3681   // int -> Dimensions map
3682   .operandDimensions = {{0, {1, 4, 2, 2}}},
3683   // int -> FLOAT32 map
3684   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
3685   // int -> INT32 map
3686   .int32Operands = {},
3687   // int -> QUANT8_ASYMM map
3688   .quant8AsymmOperands = {},
3689   // int -> QUANT16_SYMM map
3690   .quant16SymmOperands = {},
3691   // int -> FLOAT16 map
3692   .float16Operands = {},
3693   // int -> BOOL8 map
3694   .bool8Operands = {},
3695   // int -> QUANT8_SYMM_PER_CHANNEL map
3696   .quant8ChannelOperands = {},
3697   // int -> QUANT16_ASYMM map
3698   .quant16AsymmOperands = {},
3699   // int -> QUANT8_SYMM map
3700   .quant8SymmOperands = {},
3701 }
3702 },
3703 }, // End of an example
3704 };
3705 return examples_valid_padding_dynamic_output_shape_nchw;
3706 };
3707 
get_examples_valid_padding_dynamic_output_shape_nchw_relaxed()3708 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_relaxed() {
3709 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_relaxed = {
3710 // Begin of an example
3711 {
3712 .operands = {
3713 //Input(s)
3714 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3715   // int -> Dimensions map
3716   .operandDimensions = {{0, {1, 2, 3, 3}}},
3717   // int -> FLOAT32 map
3718   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}},
3719   // int -> INT32 map
3720   .int32Operands = {},
3721   // int -> QUANT8_ASYMM map
3722   .quant8AsymmOperands = {},
3723   // int -> QUANT16_SYMM map
3724   .quant16SymmOperands = {},
3725   // int -> FLOAT16 map
3726   .float16Operands = {},
3727   // int -> BOOL8 map
3728   .bool8Operands = {},
3729   // int -> QUANT8_SYMM_PER_CHANNEL map
3730   .quant8ChannelOperands = {},
3731   // int -> QUANT16_ASYMM map
3732   .quant16AsymmOperands = {},
3733   // int -> QUANT8_SYMM map
3734   .quant8SymmOperands = {},
3735 },
3736 //Output(s)
3737 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3738   // int -> Dimensions map
3739   .operandDimensions = {{0, {1, 4, 2, 2}}},
3740   // int -> FLOAT32 map
3741   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
3742   // int -> INT32 map
3743   .int32Operands = {},
3744   // int -> QUANT8_ASYMM map
3745   .quant8AsymmOperands = {},
3746   // int -> QUANT16_SYMM map
3747   .quant16SymmOperands = {},
3748   // int -> FLOAT16 map
3749   .float16Operands = {},
3750   // int -> BOOL8 map
3751   .bool8Operands = {},
3752   // int -> QUANT8_SYMM_PER_CHANNEL map
3753   .quant8ChannelOperands = {},
3754   // int -> QUANT16_ASYMM map
3755   .quant16AsymmOperands = {},
3756   // int -> QUANT8_SYMM map
3757   .quant8SymmOperands = {},
3758 }
3759 },
3760 }, // End of an example
3761 };
3762 return examples_valid_padding_dynamic_output_shape_nchw_relaxed;
3763 };
3764 
get_examples_valid_padding_dynamic_output_shape_nchw_float16()3765 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_float16() {
3766 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_float16 = {
3767 // Begin of an example
3768 {
3769 .operands = {
3770 //Input(s)
3771 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3772   // int -> Dimensions map
3773   .operandDimensions = {{0, {1, 2, 3, 3}}},
3774   // int -> FLOAT32 map
3775   .float32Operands = {},
3776   // int -> INT32 map
3777   .int32Operands = {},
3778   // int -> QUANT8_ASYMM map
3779   .quant8AsymmOperands = {},
3780   // int -> QUANT16_SYMM map
3781   .quant16SymmOperands = {},
3782   // int -> FLOAT16 map
3783   .float16Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}},
3784   // int -> BOOL8 map
3785   .bool8Operands = {},
3786   // int -> QUANT8_SYMM_PER_CHANNEL map
3787   .quant8ChannelOperands = {},
3788   // int -> QUANT16_ASYMM map
3789   .quant16AsymmOperands = {},
3790   // int -> QUANT8_SYMM map
3791   .quant8SymmOperands = {},
3792 },
3793 //Output(s)
3794 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3795   // int -> Dimensions map
3796   .operandDimensions = {{0, {1, 4, 2, 2}}},
3797   // int -> FLOAT32 map
3798   .float32Operands = {},
3799   // int -> INT32 map
3800   .int32Operands = {},
3801   // int -> QUANT8_ASYMM map
3802   .quant8AsymmOperands = {},
3803   // int -> QUANT16_SYMM map
3804   .quant16SymmOperands = {},
3805   // int -> FLOAT16 map
3806   .float16Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}},
3807   // int -> BOOL8 map
3808   .bool8Operands = {},
3809   // int -> QUANT8_SYMM_PER_CHANNEL map
3810   .quant8ChannelOperands = {},
3811   // int -> QUANT16_ASYMM map
3812   .quant16AsymmOperands = {},
3813   // int -> QUANT8_SYMM map
3814   .quant8SymmOperands = {},
3815 }
3816 },
3817 }, // End of an example
3818 };
3819 return examples_valid_padding_dynamic_output_shape_nchw_float16;
3820 };
3821 
get_examples_valid_padding_dynamic_output_shape_nchw_quant8()3822 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_quant8() {
3823 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_quant8 = {
3824 // Begin of an example
3825 {
3826 .operands = {
3827 //Input(s)
3828 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3829   // int -> Dimensions map
3830   .operandDimensions = {{0, {1, 2, 3, 3}}},
3831   // int -> FLOAT32 map
3832   .float32Operands = {},
3833   // int -> INT32 map
3834   .int32Operands = {},
3835   // int -> QUANT8_ASYMM map
3836   .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}},
3837   // int -> QUANT16_SYMM map
3838   .quant16SymmOperands = {},
3839   // int -> FLOAT16 map
3840   .float16Operands = {},
3841   // int -> BOOL8 map
3842   .bool8Operands = {},
3843   // int -> QUANT8_SYMM_PER_CHANNEL map
3844   .quant8ChannelOperands = {},
3845   // int -> QUANT16_ASYMM map
3846   .quant16AsymmOperands = {},
3847   // int -> QUANT8_SYMM map
3848   .quant8SymmOperands = {},
3849 },
3850 //Output(s)
3851 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3852   // int -> Dimensions map
3853   .operandDimensions = {{0, {1, 4, 2, 2}}},
3854   // int -> FLOAT32 map
3855   .float32Operands = {},
3856   // int -> INT32 map
3857   .int32Operands = {},
3858   // int -> QUANT8_ASYMM map
3859   .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}},
3860   // int -> QUANT16_SYMM map
3861   .quant16SymmOperands = {},
3862   // int -> FLOAT16 map
3863   .float16Operands = {},
3864   // int -> BOOL8 map
3865   .bool8Operands = {},
3866   // int -> QUANT8_SYMM_PER_CHANNEL map
3867   .quant8ChannelOperands = {},
3868   // int -> QUANT16_ASYMM map
3869   .quant16AsymmOperands = {},
3870   // int -> QUANT8_SYMM map
3871   .quant8SymmOperands = {},
3872 }
3873 },
3874 }, // End of an example
3875 };
3876 return examples_valid_padding_dynamic_output_shape_nchw_quant8;
3877 };
3878 
get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input()3879 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input() {
3880 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_weight_as_input = {
3881 // Begin of an example
3882 {
3883 .operands = {
3884 //Input(s)
3885 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3886   // int -> Dimensions map
3887   .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
3888   // int -> FLOAT32 map
3889   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
3890   // int -> INT32 map
3891   .int32Operands = {},
3892   // int -> QUANT8_ASYMM map
3893   .quant8AsymmOperands = {},
3894   // int -> QUANT16_SYMM map
3895   .quant16SymmOperands = {},
3896   // int -> FLOAT16 map
3897   .float16Operands = {},
3898   // int -> BOOL8 map
3899   .bool8Operands = {},
3900   // int -> QUANT8_SYMM_PER_CHANNEL map
3901   .quant8ChannelOperands = {},
3902   // int -> QUANT16_ASYMM map
3903   .quant16AsymmOperands = {},
3904   // int -> QUANT8_SYMM map
3905   .quant8SymmOperands = {},
3906 },
3907 //Output(s)
3908 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3909   // int -> Dimensions map
3910   .operandDimensions = {{0, {1, 4, 2, 2}}},
3911   // int -> FLOAT32 map
3912   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
3913   // int -> INT32 map
3914   .int32Operands = {},
3915   // int -> QUANT8_ASYMM map
3916   .quant8AsymmOperands = {},
3917   // int -> QUANT16_SYMM map
3918   .quant16SymmOperands = {},
3919   // int -> FLOAT16 map
3920   .float16Operands = {},
3921   // int -> BOOL8 map
3922   .bool8Operands = {},
3923   // int -> QUANT8_SYMM_PER_CHANNEL map
3924   .quant8ChannelOperands = {},
3925   // int -> QUANT16_ASYMM map
3926   .quant16AsymmOperands = {},
3927   // int -> QUANT8_SYMM map
3928   .quant8SymmOperands = {},
3929 }
3930 },
3931 }, // End of an example
3932 };
3933 return examples_valid_padding_dynamic_output_shape_nchw_weight_as_input;
3934 };
3935 
get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_relaxed()3936 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_relaxed() {
3937 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_relaxed = {
3938 // Begin of an example
3939 {
3940 .operands = {
3941 //Input(s)
3942 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3943   // int -> Dimensions map
3944   .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
3945   // int -> FLOAT32 map
3946   .float32Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.2f, 0.0f, 0.25f, 0.0f, 0.0f, 0.3f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.1f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
3947   // int -> INT32 map
3948   .int32Operands = {},
3949   // int -> QUANT8_ASYMM map
3950   .quant8AsymmOperands = {},
3951   // int -> QUANT16_SYMM map
3952   .quant16SymmOperands = {},
3953   // int -> FLOAT16 map
3954   .float16Operands = {},
3955   // int -> BOOL8 map
3956   .bool8Operands = {},
3957   // int -> QUANT8_SYMM_PER_CHANNEL map
3958   .quant8ChannelOperands = {},
3959   // int -> QUANT16_ASYMM map
3960   .quant16AsymmOperands = {},
3961   // int -> QUANT8_SYMM map
3962   .quant8SymmOperands = {},
3963 },
3964 //Output(s)
3965 { // See tools/test_generator/include/TestHarness.h:MixedTyped
3966   // int -> Dimensions map
3967   .operandDimensions = {{0, {1, 4, 2, 2}}},
3968   // int -> FLOAT32 map
3969   .float32Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.2f, 7.4f, 7.8f, 8.0f, 10.6f, 10.9f, 11.5f, 11.8f}}},
3970   // int -> INT32 map
3971   .int32Operands = {},
3972   // int -> QUANT8_ASYMM map
3973   .quant8AsymmOperands = {},
3974   // int -> QUANT16_SYMM map
3975   .quant16SymmOperands = {},
3976   // int -> FLOAT16 map
3977   .float16Operands = {},
3978   // int -> BOOL8 map
3979   .bool8Operands = {},
3980   // int -> QUANT8_SYMM_PER_CHANNEL map
3981   .quant8ChannelOperands = {},
3982   // int -> QUANT16_ASYMM map
3983   .quant16AsymmOperands = {},
3984   // int -> QUANT8_SYMM map
3985   .quant8SymmOperands = {},
3986 }
3987 },
3988 }, // End of an example
3989 };
3990 return examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_relaxed;
3991 };
3992 
get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_float16()3993 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_float16() {
3994 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_float16 = {
3995 // Begin of an example
3996 {
3997 .operands = {
3998 //Input(s)
3999 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4000   // int -> Dimensions map
4001   .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
4002   // int -> FLOAT32 map
4003   .float32Operands = {},
4004   // int -> INT32 map
4005   .int32Operands = {},
4006   // int -> QUANT8_ASYMM map
4007   .quant8AsymmOperands = {},
4008   // int -> QUANT16_SYMM map
4009   .quant16SymmOperands = {},
4010   // int -> FLOAT16 map
4011   .float16Operands = {{0, {10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 10.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f}}, {1, {0.25f, 0.0f, 0.20000000298023224f, 0.0f, 0.25f, 0.0f, 0.0f, 0.30000001192092896f, 0.25f, 0.0f, 0.0f, 0.0f, 0.25f, 0.10000000149011612f, 0.0f, 0.0f}}, {2, {1.0f, 2.0f, 3.0f, 4.0f}}},
4012   // int -> BOOL8 map
4013   .bool8Operands = {},
4014   // int -> QUANT8_SYMM_PER_CHANNEL map
4015   .quant8ChannelOperands = {},
4016   // int -> QUANT16_ASYMM map
4017   .quant16AsymmOperands = {},
4018   // int -> QUANT8_SYMM map
4019   .quant8SymmOperands = {},
4020 },
4021 //Output(s)
4022 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4023   // int -> Dimensions map
4024   .operandDimensions = {{0, {1, 4, 2, 2}}},
4025   // int -> FLOAT32 map
4026   .float32Operands = {},
4027   // int -> INT32 map
4028   .int32Operands = {},
4029   // int -> QUANT8_ASYMM map
4030   .quant8AsymmOperands = {},
4031   // int -> QUANT16_SYMM map
4032   .quant16SymmOperands = {},
4033   // int -> FLOAT16 map
4034   .float16Operands = {{0, {11.0f, 11.0f, 11.0f, 11.0f, 3.0f, 3.0f, 3.0f, 3.0f, 7.199999809265137f, 7.400000095367432f, 7.800000190734863f, 8.0f, 10.600000381469727f, 10.899999618530273f, 11.5f, 11.800000190734863f}}},
4035   // int -> BOOL8 map
4036   .bool8Operands = {},
4037   // int -> QUANT8_SYMM_PER_CHANNEL map
4038   .quant8ChannelOperands = {},
4039   // int -> QUANT16_ASYMM map
4040   .quant16AsymmOperands = {},
4041   // int -> QUANT8_SYMM map
4042   .quant8SymmOperands = {},
4043 }
4044 },
4045 }, // End of an example
4046 };
4047 return examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_float16;
4048 };
4049 
get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_quant8()4050 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_quant8() {
4051 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_quant8 = {
4052 // Begin of an example
4053 {
4054 .operands = {
4055 //Input(s)
4056 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4057   // int -> Dimensions map
4058   .operandDimensions = {{0, {1, 2, 3, 3}}, {1, {1, 2, 2, 4}}, {2, {4}}},
4059   // int -> FLOAT32 map
4060   .float32Operands = {},
4061   // int -> INT32 map
4062   .int32Operands = {{2, {200, 400, 600, 800}}},
4063   // int -> QUANT8_ASYMM map
4064   .quant8AsymmOperands = {{0, {20, 20, 20, 20, 20, 20, 20, 20, 20, 42, 44, 46, 48, 50, 52, 54, 56, 58}}, {1, {25, 0, 20, 0, 25, 0, 0, 30, 25, 0, 0, 0, 25, 10, 0, 0}}},
4065   // int -> QUANT16_SYMM map
4066   .quant16SymmOperands = {},
4067   // int -> FLOAT16 map
4068   .float16Operands = {},
4069   // int -> BOOL8 map
4070   .bool8Operands = {},
4071   // int -> QUANT8_SYMM_PER_CHANNEL map
4072   .quant8ChannelOperands = {},
4073   // int -> QUANT16_ASYMM map
4074   .quant16AsymmOperands = {},
4075   // int -> QUANT8_SYMM map
4076   .quant8SymmOperands = {},
4077 },
4078 //Output(s)
4079 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4080   // int -> Dimensions map
4081   .operandDimensions = {{0, {1, 4, 2, 2}}},
4082   // int -> FLOAT32 map
4083   .float32Operands = {},
4084   // int -> INT32 map
4085   .int32Operands = {},
4086   // int -> QUANT8_ASYMM map
4087   .quant8AsymmOperands = {{0, {110, 110, 110, 110, 30, 30, 30, 30, 72, 74, 78, 80, 106, 109, 115, 118}}},
4088   // int -> QUANT16_SYMM map
4089   .quant16SymmOperands = {},
4090   // int -> FLOAT16 map
4091   .float16Operands = {},
4092   // int -> BOOL8 map
4093   .bool8Operands = {},
4094   // int -> QUANT8_SYMM_PER_CHANNEL map
4095   .quant8ChannelOperands = {},
4096   // int -> QUANT16_ASYMM map
4097   .quant16AsymmOperands = {},
4098   // int -> QUANT8_SYMM map
4099   .quant8SymmOperands = {},
4100 }
4101 },
4102 }, // End of an example
4103 };
4104 return examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_quant8;
4105 };
4106 
get_examples_valid_padding_nhwc_2()4107 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_2() {
4108 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_2 = {
4109 // Begin of an example
4110 {
4111 .operands = {
4112 //Input(s)
4113 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4114   // int -> Dimensions map
4115   .operandDimensions = {{0, {1, 4, 4, 2}}},
4116   // int -> FLOAT32 map
4117   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
4118   // int -> INT32 map
4119   .int32Operands = {},
4120   // int -> QUANT8_ASYMM map
4121   .quant8AsymmOperands = {},
4122   // int -> QUANT16_SYMM map
4123   .quant16SymmOperands = {},
4124   // int -> FLOAT16 map
4125   .float16Operands = {},
4126   // int -> BOOL8 map
4127   .bool8Operands = {},
4128   // int -> QUANT8_SYMM_PER_CHANNEL map
4129   .quant8ChannelOperands = {},
4130   // int -> QUANT16_ASYMM map
4131   .quant16AsymmOperands = {},
4132   // int -> QUANT8_SYMM map
4133   .quant8SymmOperands = {},
4134 },
4135 //Output(s)
4136 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4137   // int -> Dimensions map
4138   .operandDimensions = {{0, {1, 2, 2, 4}}},
4139   // int -> FLOAT32 map
4140   .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}},
4141   // int -> INT32 map
4142   .int32Operands = {},
4143   // int -> QUANT8_ASYMM map
4144   .quant8AsymmOperands = {},
4145   // int -> QUANT16_SYMM map
4146   .quant16SymmOperands = {},
4147   // int -> FLOAT16 map
4148   .float16Operands = {},
4149   // int -> BOOL8 map
4150   .bool8Operands = {},
4151   // int -> QUANT8_SYMM_PER_CHANNEL map
4152   .quant8ChannelOperands = {},
4153   // int -> QUANT16_ASYMM map
4154   .quant16AsymmOperands = {},
4155   // int -> QUANT8_SYMM map
4156   .quant8SymmOperands = {},
4157 }
4158 },
4159 }, // End of an example
4160 };
4161 return examples_valid_padding_nhwc_2;
4162 };
4163 
get_examples_valid_padding_nhwc_weight_as_input_2()4164 std::vector<MixedTypedExample>& get_examples_valid_padding_nhwc_weight_as_input_2() {
4165 static std::vector<MixedTypedExample> examples_valid_padding_nhwc_weight_as_input_2 = {
4166 // Begin of an example
4167 {
4168 .operands = {
4169 //Input(s)
4170 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4171   // int -> Dimensions map
4172   .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
4173   // int -> FLOAT32 map
4174   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}},
4175   // int -> INT32 map
4176   .int32Operands = {},
4177   // int -> QUANT8_ASYMM map
4178   .quant8AsymmOperands = {},
4179   // int -> QUANT16_SYMM map
4180   .quant16SymmOperands = {},
4181   // int -> FLOAT16 map
4182   .float16Operands = {},
4183   // int -> BOOL8 map
4184   .bool8Operands = {},
4185   // int -> QUANT8_SYMM_PER_CHANNEL map
4186   .quant8ChannelOperands = {},
4187   // int -> QUANT16_ASYMM map
4188   .quant16AsymmOperands = {},
4189   // int -> QUANT8_SYMM map
4190   .quant8SymmOperands = {},
4191 },
4192 //Output(s)
4193 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4194   // int -> Dimensions map
4195   .operandDimensions = {{0, {1, 2, 2, 4}}},
4196   // int -> FLOAT32 map
4197   .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}},
4198   // int -> INT32 map
4199   .int32Operands = {},
4200   // int -> QUANT8_ASYMM map
4201   .quant8AsymmOperands = {},
4202   // int -> QUANT16_SYMM map
4203   .quant16SymmOperands = {},
4204   // int -> FLOAT16 map
4205   .float16Operands = {},
4206   // int -> BOOL8 map
4207   .bool8Operands = {},
4208   // int -> QUANT8_SYMM_PER_CHANNEL map
4209   .quant8ChannelOperands = {},
4210   // int -> QUANT16_ASYMM map
4211   .quant16AsymmOperands = {},
4212   // int -> QUANT8_SYMM map
4213   .quant8SymmOperands = {},
4214 }
4215 },
4216 }, // End of an example
4217 };
4218 return examples_valid_padding_nhwc_weight_as_input_2;
4219 };
4220 
get_examples_valid_padding_nchw_2()4221 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_2() {
4222 static std::vector<MixedTypedExample> examples_valid_padding_nchw_2 = {
4223 // Begin of an example
4224 {
4225 .operands = {
4226 //Input(s)
4227 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4228   // int -> Dimensions map
4229   .operandDimensions = {{0, {1, 2, 4, 4}}},
4230   // int -> FLOAT32 map
4231   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
4232   // int -> INT32 map
4233   .int32Operands = {},
4234   // int -> QUANT8_ASYMM map
4235   .quant8AsymmOperands = {},
4236   // int -> QUANT16_SYMM map
4237   .quant16SymmOperands = {},
4238   // int -> FLOAT16 map
4239   .float16Operands = {},
4240   // int -> BOOL8 map
4241   .bool8Operands = {},
4242   // int -> QUANT8_SYMM_PER_CHANNEL map
4243   .quant8ChannelOperands = {},
4244   // int -> QUANT16_ASYMM map
4245   .quant16AsymmOperands = {},
4246   // int -> QUANT8_SYMM map
4247   .quant8SymmOperands = {},
4248 },
4249 //Output(s)
4250 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4251   // int -> Dimensions map
4252   .operandDimensions = {{0, {1, 4, 2, 2}}},
4253   // int -> FLOAT32 map
4254   .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}},
4255   // int -> INT32 map
4256   .int32Operands = {},
4257   // int -> QUANT8_ASYMM map
4258   .quant8AsymmOperands = {},
4259   // int -> QUANT16_SYMM map
4260   .quant16SymmOperands = {},
4261   // int -> FLOAT16 map
4262   .float16Operands = {},
4263   // int -> BOOL8 map
4264   .bool8Operands = {},
4265   // int -> QUANT8_SYMM_PER_CHANNEL map
4266   .quant8ChannelOperands = {},
4267   // int -> QUANT16_ASYMM map
4268   .quant16AsymmOperands = {},
4269   // int -> QUANT8_SYMM map
4270   .quant8SymmOperands = {},
4271 }
4272 },
4273 }, // End of an example
4274 };
4275 return examples_valid_padding_nchw_2;
4276 };
4277 
get_examples_valid_padding_nchw_weight_as_input_2()4278 std::vector<MixedTypedExample>& get_examples_valid_padding_nchw_weight_as_input_2() {
4279 static std::vector<MixedTypedExample> examples_valid_padding_nchw_weight_as_input_2 = {
4280 // Begin of an example
4281 {
4282 .operands = {
4283 //Input(s)
4284 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4285   // int -> Dimensions map
4286   .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 2, 2, 4}}, {2, {4}}},
4287   // int -> FLOAT32 map
4288   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}},
4289   // int -> INT32 map
4290   .int32Operands = {},
4291   // int -> QUANT8_ASYMM map
4292   .quant8AsymmOperands = {},
4293   // int -> QUANT16_SYMM map
4294   .quant16SymmOperands = {},
4295   // int -> FLOAT16 map
4296   .float16Operands = {},
4297   // int -> BOOL8 map
4298   .bool8Operands = {},
4299   // int -> QUANT8_SYMM_PER_CHANNEL map
4300   .quant8ChannelOperands = {},
4301   // int -> QUANT16_ASYMM map
4302   .quant16AsymmOperands = {},
4303   // int -> QUANT8_SYMM map
4304   .quant8SymmOperands = {},
4305 },
4306 //Output(s)
4307 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4308   // int -> Dimensions map
4309   .operandDimensions = {{0, {1, 4, 2, 2}}},
4310   // int -> FLOAT32 map
4311   .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}},
4312   // int -> INT32 map
4313   .int32Operands = {},
4314   // int -> QUANT8_ASYMM map
4315   .quant8AsymmOperands = {},
4316   // int -> QUANT16_SYMM map
4317   .quant16SymmOperands = {},
4318   // int -> FLOAT16 map
4319   .float16Operands = {},
4320   // int -> BOOL8 map
4321   .bool8Operands = {},
4322   // int -> QUANT8_SYMM_PER_CHANNEL map
4323   .quant8ChannelOperands = {},
4324   // int -> QUANT16_ASYMM map
4325   .quant16AsymmOperands = {},
4326   // int -> QUANT8_SYMM map
4327   .quant8SymmOperands = {},
4328 }
4329 },
4330 }, // End of an example
4331 };
4332 return examples_valid_padding_nchw_weight_as_input_2;
4333 };
4334 
get_examples_valid_padding_dynamic_output_shape_nhwc_2()4335 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_2() {
4336 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_2 = {
4337 // Begin of an example
4338 {
4339 .operands = {
4340 //Input(s)
4341 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4342   // int -> Dimensions map
4343   .operandDimensions = {{0, {1, 4, 4, 2}}},
4344   // int -> FLOAT32 map
4345   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
4346   // int -> INT32 map
4347   .int32Operands = {},
4348   // int -> QUANT8_ASYMM map
4349   .quant8AsymmOperands = {},
4350   // int -> QUANT16_SYMM map
4351   .quant16SymmOperands = {},
4352   // int -> FLOAT16 map
4353   .float16Operands = {},
4354   // int -> BOOL8 map
4355   .bool8Operands = {},
4356   // int -> QUANT8_SYMM_PER_CHANNEL map
4357   .quant8ChannelOperands = {},
4358   // int -> QUANT16_ASYMM map
4359   .quant16AsymmOperands = {},
4360   // int -> QUANT8_SYMM map
4361   .quant8SymmOperands = {},
4362 },
4363 //Output(s)
4364 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4365   // int -> Dimensions map
4366   .operandDimensions = {{0, {1, 2, 2, 4}}},
4367   // int -> FLOAT32 map
4368   .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}},
4369   // int -> INT32 map
4370   .int32Operands = {},
4371   // int -> QUANT8_ASYMM map
4372   .quant8AsymmOperands = {},
4373   // int -> QUANT16_SYMM map
4374   .quant16SymmOperands = {},
4375   // int -> FLOAT16 map
4376   .float16Operands = {},
4377   // int -> BOOL8 map
4378   .bool8Operands = {},
4379   // int -> QUANT8_SYMM_PER_CHANNEL map
4380   .quant8ChannelOperands = {},
4381   // int -> QUANT16_ASYMM map
4382   .quant16AsymmOperands = {},
4383   // int -> QUANT8_SYMM map
4384   .quant8SymmOperands = {},
4385 }
4386 },
4387 }, // End of an example
4388 };
4389 return examples_valid_padding_dynamic_output_shape_nhwc_2;
4390 };
4391 
get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_2()4392 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_2() {
4393 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_2 = {
4394 // Begin of an example
4395 {
4396 .operands = {
4397 //Input(s)
4398 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4399   // int -> Dimensions map
4400   .operandDimensions = {{0, {1, 4, 4, 2}}, {1, {1, 2, 2, 4}}, {2, {4}}},
4401   // int -> FLOAT32 map
4402   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}},
4403   // int -> INT32 map
4404   .int32Operands = {},
4405   // int -> QUANT8_ASYMM map
4406   .quant8AsymmOperands = {},
4407   // int -> QUANT16_SYMM map
4408   .quant16SymmOperands = {},
4409   // int -> FLOAT16 map
4410   .float16Operands = {},
4411   // int -> BOOL8 map
4412   .bool8Operands = {},
4413   // int -> QUANT8_SYMM_PER_CHANNEL map
4414   .quant8ChannelOperands = {},
4415   // int -> QUANT16_ASYMM map
4416   .quant16AsymmOperands = {},
4417   // int -> QUANT8_SYMM map
4418   .quant8SymmOperands = {},
4419 },
4420 //Output(s)
4421 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4422   // int -> Dimensions map
4423   .operandDimensions = {{0, {1, 2, 2, 4}}},
4424   // int -> FLOAT32 map
4425   .float32Operands = {{0, {13.0f, 14.0f, 0.0f, 0.0f, 0.0f, 0.0f, 11.0f, 12.0f, 5.0f, 6.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 4.0f}}},
4426   // int -> INT32 map
4427   .int32Operands = {},
4428   // int -> QUANT8_ASYMM map
4429   .quant8AsymmOperands = {},
4430   // int -> QUANT16_SYMM map
4431   .quant16SymmOperands = {},
4432   // int -> FLOAT16 map
4433   .float16Operands = {},
4434   // int -> BOOL8 map
4435   .bool8Operands = {},
4436   // int -> QUANT8_SYMM_PER_CHANNEL map
4437   .quant8ChannelOperands = {},
4438   // int -> QUANT16_ASYMM map
4439   .quant16AsymmOperands = {},
4440   // int -> QUANT8_SYMM map
4441   .quant8SymmOperands = {},
4442 }
4443 },
4444 }, // End of an example
4445 };
4446 return examples_valid_padding_dynamic_output_shape_nhwc_weight_as_input_2;
4447 };
4448 
get_examples_valid_padding_dynamic_output_shape_nchw_2()4449 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_2() {
4450 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_2 = {
4451 // Begin of an example
4452 {
4453 .operands = {
4454 //Input(s)
4455 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4456   // int -> Dimensions map
4457   .operandDimensions = {{0, {1, 2, 4, 4}}},
4458   // int -> FLOAT32 map
4459   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
4460   // int -> INT32 map
4461   .int32Operands = {},
4462   // int -> QUANT8_ASYMM map
4463   .quant8AsymmOperands = {},
4464   // int -> QUANT16_SYMM map
4465   .quant16SymmOperands = {},
4466   // int -> FLOAT16 map
4467   .float16Operands = {},
4468   // int -> BOOL8 map
4469   .bool8Operands = {},
4470   // int -> QUANT8_SYMM_PER_CHANNEL map
4471   .quant8ChannelOperands = {},
4472   // int -> QUANT16_ASYMM map
4473   .quant16AsymmOperands = {},
4474   // int -> QUANT8_SYMM map
4475   .quant8SymmOperands = {},
4476 },
4477 //Output(s)
4478 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4479   // int -> Dimensions map
4480   .operandDimensions = {{0, {1, 4, 2, 2}}},
4481   // int -> FLOAT32 map
4482   .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}},
4483   // int -> INT32 map
4484   .int32Operands = {},
4485   // int -> QUANT8_ASYMM map
4486   .quant8AsymmOperands = {},
4487   // int -> QUANT16_SYMM map
4488   .quant16SymmOperands = {},
4489   // int -> FLOAT16 map
4490   .float16Operands = {},
4491   // int -> BOOL8 map
4492   .bool8Operands = {},
4493   // int -> QUANT8_SYMM_PER_CHANNEL map
4494   .quant8ChannelOperands = {},
4495   // int -> QUANT16_ASYMM map
4496   .quant16AsymmOperands = {},
4497   // int -> QUANT8_SYMM map
4498   .quant8SymmOperands = {},
4499 }
4500 },
4501 }, // End of an example
4502 };
4503 return examples_valid_padding_dynamic_output_shape_nchw_2;
4504 };
4505 
get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_2()4506 std::vector<MixedTypedExample>& get_examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_2() {
4507 static std::vector<MixedTypedExample> examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_2 = {
4508 // Begin of an example
4509 {
4510 .operands = {
4511 //Input(s)
4512 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4513   // int -> Dimensions map
4514   .operandDimensions = {{0, {1, 2, 4, 4}}, {1, {1, 2, 2, 4}}, {2, {4}}},
4515   // int -> FLOAT32 map
4516   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}}, {2, {0.0f, 0.0f, 0.0f, 0.0f}}},
4517   // int -> INT32 map
4518   .int32Operands = {},
4519   // int -> QUANT8_ASYMM map
4520   .quant8AsymmOperands = {},
4521   // int -> QUANT16_SYMM map
4522   .quant16SymmOperands = {},
4523   // int -> FLOAT16 map
4524   .float16Operands = {},
4525   // int -> BOOL8 map
4526   .bool8Operands = {},
4527   // int -> QUANT8_SYMM_PER_CHANNEL map
4528   .quant8ChannelOperands = {},
4529   // int -> QUANT16_ASYMM map
4530   .quant16AsymmOperands = {},
4531   // int -> QUANT8_SYMM map
4532   .quant8SymmOperands = {},
4533 },
4534 //Output(s)
4535 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4536   // int -> Dimensions map
4537   .operandDimensions = {{0, {1, 4, 2, 2}}},
4538   // int -> FLOAT32 map
4539   .float32Operands = {{0, {13.0f, 0.0f, 5.0f, 0.0f, 14.0f, 0.0f, 6.0f, 0.0f, 0.0f, 11.0f, 0.0f, 3.0f, 0.0f, 12.0f, 0.0f, 4.0f}}},
4540   // int -> INT32 map
4541   .int32Operands = {},
4542   // int -> QUANT8_ASYMM map
4543   .quant8AsymmOperands = {},
4544   // int -> QUANT16_SYMM map
4545   .quant16SymmOperands = {},
4546   // int -> FLOAT16 map
4547   .float16Operands = {},
4548   // int -> BOOL8 map
4549   .bool8Operands = {},
4550   // int -> QUANT8_SYMM_PER_CHANNEL map
4551   .quant8ChannelOperands = {},
4552   // int -> QUANT16_ASYMM map
4553   .quant16AsymmOperands = {},
4554   // int -> QUANT8_SYMM map
4555   .quant8SymmOperands = {},
4556 }
4557 },
4558 }, // End of an example
4559 };
4560 return examples_valid_padding_dynamic_output_shape_nchw_weight_as_input_2;
4561 };
4562 
get_examples_same_padding_stride_2_nhwc()4563 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc() {
4564 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc = {
4565 // Begin of an example
4566 {
4567 .operands = {
4568 //Input(s)
4569 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4570   // int -> Dimensions map
4571   .operandDimensions = {{0, {1, 6, 6, 1}}},
4572   // int -> FLOAT32 map
4573   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
4574   // int -> INT32 map
4575   .int32Operands = {},
4576   // int -> QUANT8_ASYMM map
4577   .quant8AsymmOperands = {},
4578   // int -> QUANT16_SYMM map
4579   .quant16SymmOperands = {},
4580   // int -> FLOAT16 map
4581   .float16Operands = {},
4582   // int -> BOOL8 map
4583   .bool8Operands = {},
4584   // int -> QUANT8_SYMM_PER_CHANNEL map
4585   .quant8ChannelOperands = {},
4586   // int -> QUANT16_ASYMM map
4587   .quant16AsymmOperands = {},
4588   // int -> QUANT8_SYMM map
4589   .quant8SymmOperands = {},
4590 },
4591 //Output(s)
4592 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4593   // int -> Dimensions map
4594   .operandDimensions = {{0, {1, 3, 3, 1}}},
4595   // int -> FLOAT32 map
4596   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
4597   // int -> INT32 map
4598   .int32Operands = {},
4599   // int -> QUANT8_ASYMM map
4600   .quant8AsymmOperands = {},
4601   // int -> QUANT16_SYMM map
4602   .quant16SymmOperands = {},
4603   // int -> FLOAT16 map
4604   .float16Operands = {},
4605   // int -> BOOL8 map
4606   .bool8Operands = {},
4607   // int -> QUANT8_SYMM_PER_CHANNEL map
4608   .quant8ChannelOperands = {},
4609   // int -> QUANT16_ASYMM map
4610   .quant16AsymmOperands = {},
4611   // int -> QUANT8_SYMM map
4612   .quant8SymmOperands = {},
4613 }
4614 },
4615 }, // End of an example
4616 };
4617 return examples_same_padding_stride_2_nhwc;
4618 };
4619 
get_examples_same_padding_stride_2_nhwc_relaxed()4620 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_relaxed() {
4621 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_relaxed = {
4622 // Begin of an example
4623 {
4624 .operands = {
4625 //Input(s)
4626 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4627   // int -> Dimensions map
4628   .operandDimensions = {{0, {1, 6, 6, 1}}},
4629   // int -> FLOAT32 map
4630   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
4631   // int -> INT32 map
4632   .int32Operands = {},
4633   // int -> QUANT8_ASYMM map
4634   .quant8AsymmOperands = {},
4635   // int -> QUANT16_SYMM map
4636   .quant16SymmOperands = {},
4637   // int -> FLOAT16 map
4638   .float16Operands = {},
4639   // int -> BOOL8 map
4640   .bool8Operands = {},
4641   // int -> QUANT8_SYMM_PER_CHANNEL map
4642   .quant8ChannelOperands = {},
4643   // int -> QUANT16_ASYMM map
4644   .quant16AsymmOperands = {},
4645   // int -> QUANT8_SYMM map
4646   .quant8SymmOperands = {},
4647 },
4648 //Output(s)
4649 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4650   // int -> Dimensions map
4651   .operandDimensions = {{0, {1, 3, 3, 1}}},
4652   // int -> FLOAT32 map
4653   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
4654   // int -> INT32 map
4655   .int32Operands = {},
4656   // int -> QUANT8_ASYMM map
4657   .quant8AsymmOperands = {},
4658   // int -> QUANT16_SYMM map
4659   .quant16SymmOperands = {},
4660   // int -> FLOAT16 map
4661   .float16Operands = {},
4662   // int -> BOOL8 map
4663   .bool8Operands = {},
4664   // int -> QUANT8_SYMM_PER_CHANNEL map
4665   .quant8ChannelOperands = {},
4666   // int -> QUANT16_ASYMM map
4667   .quant16AsymmOperands = {},
4668   // int -> QUANT8_SYMM map
4669   .quant8SymmOperands = {},
4670 }
4671 },
4672 }, // End of an example
4673 };
4674 return examples_same_padding_stride_2_nhwc_relaxed;
4675 };
4676 
get_examples_same_padding_stride_2_nhwc_quant8()4677 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_quant8() {
4678 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_quant8 = {
4679 // Begin of an example
4680 {
4681 .operands = {
4682 //Input(s)
4683 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4684   // int -> Dimensions map
4685   .operandDimensions = {{0, {1, 6, 6, 1}}},
4686   // int -> FLOAT32 map
4687   .float32Operands = {},
4688   // int -> INT32 map
4689   .int32Operands = {},
4690   // int -> QUANT8_ASYMM map
4691   .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}},
4692   // int -> QUANT16_SYMM map
4693   .quant16SymmOperands = {},
4694   // int -> FLOAT16 map
4695   .float16Operands = {},
4696   // int -> BOOL8 map
4697   .bool8Operands = {},
4698   // int -> QUANT8_SYMM_PER_CHANNEL map
4699   .quant8ChannelOperands = {},
4700   // int -> QUANT16_ASYMM map
4701   .quant16AsymmOperands = {},
4702   // int -> QUANT8_SYMM map
4703   .quant8SymmOperands = {},
4704 },
4705 //Output(s)
4706 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4707   // int -> Dimensions map
4708   .operandDimensions = {{0, {1, 3, 3, 1}}},
4709   // int -> FLOAT32 map
4710   .float32Operands = {},
4711   // int -> INT32 map
4712   .int32Operands = {},
4713   // int -> QUANT8_ASYMM map
4714   .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}},
4715   // int -> QUANT16_SYMM map
4716   .quant16SymmOperands = {},
4717   // int -> FLOAT16 map
4718   .float16Operands = {},
4719   // int -> BOOL8 map
4720   .bool8Operands = {},
4721   // int -> QUANT8_SYMM_PER_CHANNEL map
4722   .quant8ChannelOperands = {},
4723   // int -> QUANT16_ASYMM map
4724   .quant16AsymmOperands = {},
4725   // int -> QUANT8_SYMM map
4726   .quant8SymmOperands = {},
4727 }
4728 },
4729 }, // End of an example
4730 };
4731 return examples_same_padding_stride_2_nhwc_quant8;
4732 };
4733 
get_examples_same_padding_stride_2_nhwc_float16()4734 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_float16() {
4735 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_float16 = {
4736 // Begin of an example
4737 {
4738 .operands = {
4739 //Input(s)
4740 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4741   // int -> Dimensions map
4742   .operandDimensions = {{0, {1, 6, 6, 1}}},
4743   // int -> FLOAT32 map
4744   .float32Operands = {},
4745   // int -> INT32 map
4746   .int32Operands = {},
4747   // int -> QUANT8_ASYMM map
4748   .quant8AsymmOperands = {},
4749   // int -> QUANT16_SYMM map
4750   .quant16SymmOperands = {},
4751   // int -> FLOAT16 map
4752   .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
4753   // int -> BOOL8 map
4754   .bool8Operands = {},
4755   // int -> QUANT8_SYMM_PER_CHANNEL map
4756   .quant8ChannelOperands = {},
4757   // int -> QUANT16_ASYMM map
4758   .quant16AsymmOperands = {},
4759   // int -> QUANT8_SYMM map
4760   .quant8SymmOperands = {},
4761 },
4762 //Output(s)
4763 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4764   // int -> Dimensions map
4765   .operandDimensions = {{0, {1, 3, 3, 1}}},
4766   // int -> FLOAT32 map
4767   .float32Operands = {},
4768   // int -> INT32 map
4769   .int32Operands = {},
4770   // int -> QUANT8_ASYMM map
4771   .quant8AsymmOperands = {},
4772   // int -> QUANT16_SYMM map
4773   .quant16SymmOperands = {},
4774   // int -> FLOAT16 map
4775   .float16Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
4776   // int -> BOOL8 map
4777   .bool8Operands = {},
4778   // int -> QUANT8_SYMM_PER_CHANNEL map
4779   .quant8ChannelOperands = {},
4780   // int -> QUANT16_ASYMM map
4781   .quant16AsymmOperands = {},
4782   // int -> QUANT8_SYMM map
4783   .quant8SymmOperands = {},
4784 }
4785 },
4786 }, // End of an example
4787 };
4788 return examples_same_padding_stride_2_nhwc_float16;
4789 };
4790 
get_examples_same_padding_stride_2_nhwc_weight_as_input()4791 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_weight_as_input() {
4792 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_weight_as_input = {
4793 // Begin of an example
4794 {
4795 .operands = {
4796 //Input(s)
4797 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4798   // int -> Dimensions map
4799   .operandDimensions = {{0, {1, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}},
4800   // int -> FLOAT32 map
4801   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}},
4802   // int -> INT32 map
4803   .int32Operands = {},
4804   // int -> QUANT8_ASYMM map
4805   .quant8AsymmOperands = {},
4806   // int -> QUANT16_SYMM map
4807   .quant16SymmOperands = {},
4808   // int -> FLOAT16 map
4809   .float16Operands = {},
4810   // int -> BOOL8 map
4811   .bool8Operands = {},
4812   // int -> QUANT8_SYMM_PER_CHANNEL map
4813   .quant8ChannelOperands = {},
4814   // int -> QUANT16_ASYMM map
4815   .quant16AsymmOperands = {},
4816   // int -> QUANT8_SYMM map
4817   .quant8SymmOperands = {},
4818 },
4819 //Output(s)
4820 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4821   // int -> Dimensions map
4822   .operandDimensions = {{0, {1, 3, 3, 1}}},
4823   // int -> FLOAT32 map
4824   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
4825   // int -> INT32 map
4826   .int32Operands = {},
4827   // int -> QUANT8_ASYMM map
4828   .quant8AsymmOperands = {},
4829   // int -> QUANT16_SYMM map
4830   .quant16SymmOperands = {},
4831   // int -> FLOAT16 map
4832   .float16Operands = {},
4833   // int -> BOOL8 map
4834   .bool8Operands = {},
4835   // int -> QUANT8_SYMM_PER_CHANNEL map
4836   .quant8ChannelOperands = {},
4837   // int -> QUANT16_ASYMM map
4838   .quant16AsymmOperands = {},
4839   // int -> QUANT8_SYMM map
4840   .quant8SymmOperands = {},
4841 }
4842 },
4843 }, // End of an example
4844 };
4845 return examples_same_padding_stride_2_nhwc_weight_as_input;
4846 };
4847 
get_examples_same_padding_stride_2_nhwc_weight_as_input_relaxed()4848 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_weight_as_input_relaxed() {
4849 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_weight_as_input_relaxed = {
4850 // Begin of an example
4851 {
4852 .operands = {
4853 //Input(s)
4854 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4855   // int -> Dimensions map
4856   .operandDimensions = {{0, {1, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}},
4857   // int -> FLOAT32 map
4858   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}},
4859   // int -> INT32 map
4860   .int32Operands = {},
4861   // int -> QUANT8_ASYMM map
4862   .quant8AsymmOperands = {},
4863   // int -> QUANT16_SYMM map
4864   .quant16SymmOperands = {},
4865   // int -> FLOAT16 map
4866   .float16Operands = {},
4867   // int -> BOOL8 map
4868   .bool8Operands = {},
4869   // int -> QUANT8_SYMM_PER_CHANNEL map
4870   .quant8ChannelOperands = {},
4871   // int -> QUANT16_ASYMM map
4872   .quant16AsymmOperands = {},
4873   // int -> QUANT8_SYMM map
4874   .quant8SymmOperands = {},
4875 },
4876 //Output(s)
4877 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4878   // int -> Dimensions map
4879   .operandDimensions = {{0, {1, 3, 3, 1}}},
4880   // int -> FLOAT32 map
4881   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
4882   // int -> INT32 map
4883   .int32Operands = {},
4884   // int -> QUANT8_ASYMM map
4885   .quant8AsymmOperands = {},
4886   // int -> QUANT16_SYMM map
4887   .quant16SymmOperands = {},
4888   // int -> FLOAT16 map
4889   .float16Operands = {},
4890   // int -> BOOL8 map
4891   .bool8Operands = {},
4892   // int -> QUANT8_SYMM_PER_CHANNEL map
4893   .quant8ChannelOperands = {},
4894   // int -> QUANT16_ASYMM map
4895   .quant16AsymmOperands = {},
4896   // int -> QUANT8_SYMM map
4897   .quant8SymmOperands = {},
4898 }
4899 },
4900 }, // End of an example
4901 };
4902 return examples_same_padding_stride_2_nhwc_weight_as_input_relaxed;
4903 };
4904 
get_examples_same_padding_stride_2_nhwc_weight_as_input_quant8()4905 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_weight_as_input_quant8() {
4906 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_weight_as_input_quant8 = {
4907 // Begin of an example
4908 {
4909 .operands = {
4910 //Input(s)
4911 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4912   // int -> Dimensions map
4913   .operandDimensions = {{0, {1, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}},
4914   // int -> FLOAT32 map
4915   .float32Operands = {},
4916   // int -> INT32 map
4917   .int32Operands = {{2, {0}}},
4918   // int -> QUANT8_ASYMM map
4919   .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, {1, {8, 16, 24, 32}}},
4920   // int -> QUANT16_SYMM map
4921   .quant16SymmOperands = {},
4922   // int -> FLOAT16 map
4923   .float16Operands = {},
4924   // int -> BOOL8 map
4925   .bool8Operands = {},
4926   // int -> QUANT8_SYMM_PER_CHANNEL map
4927   .quant8ChannelOperands = {},
4928   // int -> QUANT16_ASYMM map
4929   .quant16AsymmOperands = {},
4930   // int -> QUANT8_SYMM map
4931   .quant8SymmOperands = {},
4932 },
4933 //Output(s)
4934 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4935   // int -> Dimensions map
4936   .operandDimensions = {{0, {1, 3, 3, 1}}},
4937   // int -> FLOAT32 map
4938   .float32Operands = {},
4939   // int -> INT32 map
4940   .int32Operands = {},
4941   // int -> QUANT8_ASYMM map
4942   .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}},
4943   // int -> QUANT16_SYMM map
4944   .quant16SymmOperands = {},
4945   // int -> FLOAT16 map
4946   .float16Operands = {},
4947   // int -> BOOL8 map
4948   .bool8Operands = {},
4949   // int -> QUANT8_SYMM_PER_CHANNEL map
4950   .quant8ChannelOperands = {},
4951   // int -> QUANT16_ASYMM map
4952   .quant16AsymmOperands = {},
4953   // int -> QUANT8_SYMM map
4954   .quant8SymmOperands = {},
4955 }
4956 },
4957 }, // End of an example
4958 };
4959 return examples_same_padding_stride_2_nhwc_weight_as_input_quant8;
4960 };
4961 
get_examples_same_padding_stride_2_nhwc_weight_as_input_float16()4962 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nhwc_weight_as_input_float16() {
4963 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nhwc_weight_as_input_float16 = {
4964 // Begin of an example
4965 {
4966 .operands = {
4967 //Input(s)
4968 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4969   // int -> Dimensions map
4970   .operandDimensions = {{0, {1, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}},
4971   // int -> FLOAT32 map
4972   .float32Operands = {},
4973   // int -> INT32 map
4974   .int32Operands = {},
4975   // int -> QUANT8_ASYMM map
4976   .quant8AsymmOperands = {},
4977   // int -> QUANT16_SYMM map
4978   .quant16SymmOperands = {},
4979   // int -> FLOAT16 map
4980   .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}},
4981   // int -> BOOL8 map
4982   .bool8Operands = {},
4983   // int -> QUANT8_SYMM_PER_CHANNEL map
4984   .quant8ChannelOperands = {},
4985   // int -> QUANT16_ASYMM map
4986   .quant16AsymmOperands = {},
4987   // int -> QUANT8_SYMM map
4988   .quant8SymmOperands = {},
4989 },
4990 //Output(s)
4991 { // See tools/test_generator/include/TestHarness.h:MixedTyped
4992   // int -> Dimensions map
4993   .operandDimensions = {{0, {1, 3, 3, 1}}},
4994   // int -> FLOAT32 map
4995   .float32Operands = {},
4996   // int -> INT32 map
4997   .int32Operands = {},
4998   // int -> QUANT8_ASYMM map
4999   .quant8AsymmOperands = {},
5000   // int -> QUANT16_SYMM map
5001   .quant16SymmOperands = {},
5002   // int -> FLOAT16 map
5003   .float16Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5004   // int -> BOOL8 map
5005   .bool8Operands = {},
5006   // int -> QUANT8_SYMM_PER_CHANNEL map
5007   .quant8ChannelOperands = {},
5008   // int -> QUANT16_ASYMM map
5009   .quant16AsymmOperands = {},
5010   // int -> QUANT8_SYMM map
5011   .quant8SymmOperands = {},
5012 }
5013 },
5014 }, // End of an example
5015 };
5016 return examples_same_padding_stride_2_nhwc_weight_as_input_float16;
5017 };
5018 
get_examples_same_padding_stride_2_nchw()5019 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw() {
5020 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw = {
5021 // Begin of an example
5022 {
5023 .operands = {
5024 //Input(s)
5025 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5026   // int -> Dimensions map
5027   .operandDimensions = {{0, {1, 1, 6, 6}}},
5028   // int -> FLOAT32 map
5029   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
5030   // int -> INT32 map
5031   .int32Operands = {},
5032   // int -> QUANT8_ASYMM map
5033   .quant8AsymmOperands = {},
5034   // int -> QUANT16_SYMM map
5035   .quant16SymmOperands = {},
5036   // int -> FLOAT16 map
5037   .float16Operands = {},
5038   // int -> BOOL8 map
5039   .bool8Operands = {},
5040   // int -> QUANT8_SYMM_PER_CHANNEL map
5041   .quant8ChannelOperands = {},
5042   // int -> QUANT16_ASYMM map
5043   .quant16AsymmOperands = {},
5044   // int -> QUANT8_SYMM map
5045   .quant8SymmOperands = {},
5046 },
5047 //Output(s)
5048 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5049   // int -> Dimensions map
5050   .operandDimensions = {{0, {1, 1, 3, 3}}},
5051   // int -> FLOAT32 map
5052   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5053   // int -> INT32 map
5054   .int32Operands = {},
5055   // int -> QUANT8_ASYMM map
5056   .quant8AsymmOperands = {},
5057   // int -> QUANT16_SYMM map
5058   .quant16SymmOperands = {},
5059   // int -> FLOAT16 map
5060   .float16Operands = {},
5061   // int -> BOOL8 map
5062   .bool8Operands = {},
5063   // int -> QUANT8_SYMM_PER_CHANNEL map
5064   .quant8ChannelOperands = {},
5065   // int -> QUANT16_ASYMM map
5066   .quant16AsymmOperands = {},
5067   // int -> QUANT8_SYMM map
5068   .quant8SymmOperands = {},
5069 }
5070 },
5071 }, // End of an example
5072 };
5073 return examples_same_padding_stride_2_nchw;
5074 };
5075 
get_examples_same_padding_stride_2_nchw_relaxed()5076 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_relaxed() {
5077 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_relaxed = {
5078 // Begin of an example
5079 {
5080 .operands = {
5081 //Input(s)
5082 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5083   // int -> Dimensions map
5084   .operandDimensions = {{0, {1, 1, 6, 6}}},
5085   // int -> FLOAT32 map
5086   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
5087   // int -> INT32 map
5088   .int32Operands = {},
5089   // int -> QUANT8_ASYMM map
5090   .quant8AsymmOperands = {},
5091   // int -> QUANT16_SYMM map
5092   .quant16SymmOperands = {},
5093   // int -> FLOAT16 map
5094   .float16Operands = {},
5095   // int -> BOOL8 map
5096   .bool8Operands = {},
5097   // int -> QUANT8_SYMM_PER_CHANNEL map
5098   .quant8ChannelOperands = {},
5099   // int -> QUANT16_ASYMM map
5100   .quant16AsymmOperands = {},
5101   // int -> QUANT8_SYMM map
5102   .quant8SymmOperands = {},
5103 },
5104 //Output(s)
5105 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5106   // int -> Dimensions map
5107   .operandDimensions = {{0, {1, 1, 3, 3}}},
5108   // int -> FLOAT32 map
5109   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5110   // int -> INT32 map
5111   .int32Operands = {},
5112   // int -> QUANT8_ASYMM map
5113   .quant8AsymmOperands = {},
5114   // int -> QUANT16_SYMM map
5115   .quant16SymmOperands = {},
5116   // int -> FLOAT16 map
5117   .float16Operands = {},
5118   // int -> BOOL8 map
5119   .bool8Operands = {},
5120   // int -> QUANT8_SYMM_PER_CHANNEL map
5121   .quant8ChannelOperands = {},
5122   // int -> QUANT16_ASYMM map
5123   .quant16AsymmOperands = {},
5124   // int -> QUANT8_SYMM map
5125   .quant8SymmOperands = {},
5126 }
5127 },
5128 }, // End of an example
5129 };
5130 return examples_same_padding_stride_2_nchw_relaxed;
5131 };
5132 
get_examples_same_padding_stride_2_nchw_quant8()5133 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_quant8() {
5134 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_quant8 = {
5135 // Begin of an example
5136 {
5137 .operands = {
5138 //Input(s)
5139 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5140   // int -> Dimensions map
5141   .operandDimensions = {{0, {1, 1, 6, 6}}},
5142   // int -> FLOAT32 map
5143   .float32Operands = {},
5144   // int -> INT32 map
5145   .int32Operands = {},
5146   // int -> QUANT8_ASYMM map
5147   .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}},
5148   // int -> QUANT16_SYMM map
5149   .quant16SymmOperands = {},
5150   // int -> FLOAT16 map
5151   .float16Operands = {},
5152   // int -> BOOL8 map
5153   .bool8Operands = {},
5154   // int -> QUANT8_SYMM_PER_CHANNEL map
5155   .quant8ChannelOperands = {},
5156   // int -> QUANT16_ASYMM map
5157   .quant16AsymmOperands = {},
5158   // int -> QUANT8_SYMM map
5159   .quant8SymmOperands = {},
5160 },
5161 //Output(s)
5162 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5163   // int -> Dimensions map
5164   .operandDimensions = {{0, {1, 1, 3, 3}}},
5165   // int -> FLOAT32 map
5166   .float32Operands = {},
5167   // int -> INT32 map
5168   .int32Operands = {},
5169   // int -> QUANT8_ASYMM map
5170   .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}},
5171   // int -> QUANT16_SYMM map
5172   .quant16SymmOperands = {},
5173   // int -> FLOAT16 map
5174   .float16Operands = {},
5175   // int -> BOOL8 map
5176   .bool8Operands = {},
5177   // int -> QUANT8_SYMM_PER_CHANNEL map
5178   .quant8ChannelOperands = {},
5179   // int -> QUANT16_ASYMM map
5180   .quant16AsymmOperands = {},
5181   // int -> QUANT8_SYMM map
5182   .quant8SymmOperands = {},
5183 }
5184 },
5185 }, // End of an example
5186 };
5187 return examples_same_padding_stride_2_nchw_quant8;
5188 };
5189 
get_examples_same_padding_stride_2_nchw_float16()5190 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_float16() {
5191 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_float16 = {
5192 // Begin of an example
5193 {
5194 .operands = {
5195 //Input(s)
5196 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5197   // int -> Dimensions map
5198   .operandDimensions = {{0, {1, 1, 6, 6}}},
5199   // int -> FLOAT32 map
5200   .float32Operands = {},
5201   // int -> INT32 map
5202   .int32Operands = {},
5203   // int -> QUANT8_ASYMM map
5204   .quant8AsymmOperands = {},
5205   // int -> QUANT16_SYMM map
5206   .quant16SymmOperands = {},
5207   // int -> FLOAT16 map
5208   .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
5209   // int -> BOOL8 map
5210   .bool8Operands = {},
5211   // int -> QUANT8_SYMM_PER_CHANNEL map
5212   .quant8ChannelOperands = {},
5213   // int -> QUANT16_ASYMM map
5214   .quant16AsymmOperands = {},
5215   // int -> QUANT8_SYMM map
5216   .quant8SymmOperands = {},
5217 },
5218 //Output(s)
5219 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5220   // int -> Dimensions map
5221   .operandDimensions = {{0, {1, 1, 3, 3}}},
5222   // int -> FLOAT32 map
5223   .float32Operands = {},
5224   // int -> INT32 map
5225   .int32Operands = {},
5226   // int -> QUANT8_ASYMM map
5227   .quant8AsymmOperands = {},
5228   // int -> QUANT16_SYMM map
5229   .quant16SymmOperands = {},
5230   // int -> FLOAT16 map
5231   .float16Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5232   // int -> BOOL8 map
5233   .bool8Operands = {},
5234   // int -> QUANT8_SYMM_PER_CHANNEL map
5235   .quant8ChannelOperands = {},
5236   // int -> QUANT16_ASYMM map
5237   .quant16AsymmOperands = {},
5238   // int -> QUANT8_SYMM map
5239   .quant8SymmOperands = {},
5240 }
5241 },
5242 }, // End of an example
5243 };
5244 return examples_same_padding_stride_2_nchw_float16;
5245 };
5246 
get_examples_same_padding_stride_2_nchw_weight_as_input()5247 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_weight_as_input() {
5248 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_weight_as_input = {
5249 // Begin of an example
5250 {
5251 .operands = {
5252 //Input(s)
5253 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5254   // int -> Dimensions map
5255   .operandDimensions = {{0, {1, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}},
5256   // int -> FLOAT32 map
5257   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}},
5258   // int -> INT32 map
5259   .int32Operands = {},
5260   // int -> QUANT8_ASYMM map
5261   .quant8AsymmOperands = {},
5262   // int -> QUANT16_SYMM map
5263   .quant16SymmOperands = {},
5264   // int -> FLOAT16 map
5265   .float16Operands = {},
5266   // int -> BOOL8 map
5267   .bool8Operands = {},
5268   // int -> QUANT8_SYMM_PER_CHANNEL map
5269   .quant8ChannelOperands = {},
5270   // int -> QUANT16_ASYMM map
5271   .quant16AsymmOperands = {},
5272   // int -> QUANT8_SYMM map
5273   .quant8SymmOperands = {},
5274 },
5275 //Output(s)
5276 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5277   // int -> Dimensions map
5278   .operandDimensions = {{0, {1, 1, 3, 3}}},
5279   // int -> FLOAT32 map
5280   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5281   // int -> INT32 map
5282   .int32Operands = {},
5283   // int -> QUANT8_ASYMM map
5284   .quant8AsymmOperands = {},
5285   // int -> QUANT16_SYMM map
5286   .quant16SymmOperands = {},
5287   // int -> FLOAT16 map
5288   .float16Operands = {},
5289   // int -> BOOL8 map
5290   .bool8Operands = {},
5291   // int -> QUANT8_SYMM_PER_CHANNEL map
5292   .quant8ChannelOperands = {},
5293   // int -> QUANT16_ASYMM map
5294   .quant16AsymmOperands = {},
5295   // int -> QUANT8_SYMM map
5296   .quant8SymmOperands = {},
5297 }
5298 },
5299 }, // End of an example
5300 };
5301 return examples_same_padding_stride_2_nchw_weight_as_input;
5302 };
5303 
get_examples_same_padding_stride_2_nchw_weight_as_input_relaxed()5304 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_weight_as_input_relaxed() {
5305 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_weight_as_input_relaxed = {
5306 // Begin of an example
5307 {
5308 .operands = {
5309 //Input(s)
5310 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5311   // int -> Dimensions map
5312   .operandDimensions = {{0, {1, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}},
5313   // int -> FLOAT32 map
5314   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}},
5315   // int -> INT32 map
5316   .int32Operands = {},
5317   // int -> QUANT8_ASYMM map
5318   .quant8AsymmOperands = {},
5319   // int -> QUANT16_SYMM map
5320   .quant16SymmOperands = {},
5321   // int -> FLOAT16 map
5322   .float16Operands = {},
5323   // int -> BOOL8 map
5324   .bool8Operands = {},
5325   // int -> QUANT8_SYMM_PER_CHANNEL map
5326   .quant8ChannelOperands = {},
5327   // int -> QUANT16_ASYMM map
5328   .quant16AsymmOperands = {},
5329   // int -> QUANT8_SYMM map
5330   .quant8SymmOperands = {},
5331 },
5332 //Output(s)
5333 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5334   // int -> Dimensions map
5335   .operandDimensions = {{0, {1, 1, 3, 3}}},
5336   // int -> FLOAT32 map
5337   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5338   // int -> INT32 map
5339   .int32Operands = {},
5340   // int -> QUANT8_ASYMM map
5341   .quant8AsymmOperands = {},
5342   // int -> QUANT16_SYMM map
5343   .quant16SymmOperands = {},
5344   // int -> FLOAT16 map
5345   .float16Operands = {},
5346   // int -> BOOL8 map
5347   .bool8Operands = {},
5348   // int -> QUANT8_SYMM_PER_CHANNEL map
5349   .quant8ChannelOperands = {},
5350   // int -> QUANT16_ASYMM map
5351   .quant16AsymmOperands = {},
5352   // int -> QUANT8_SYMM map
5353   .quant8SymmOperands = {},
5354 }
5355 },
5356 }, // End of an example
5357 };
5358 return examples_same_padding_stride_2_nchw_weight_as_input_relaxed;
5359 };
5360 
get_examples_same_padding_stride_2_nchw_weight_as_input_quant8()5361 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_weight_as_input_quant8() {
5362 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_weight_as_input_quant8 = {
5363 // Begin of an example
5364 {
5365 .operands = {
5366 //Input(s)
5367 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5368   // int -> Dimensions map
5369   .operandDimensions = {{0, {1, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}},
5370   // int -> FLOAT32 map
5371   .float32Operands = {},
5372   // int -> INT32 map
5373   .int32Operands = {{2, {0}}},
5374   // int -> QUANT8_ASYMM map
5375   .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, {1, {8, 16, 24, 32}}},
5376   // int -> QUANT16_SYMM map
5377   .quant16SymmOperands = {},
5378   // int -> FLOAT16 map
5379   .float16Operands = {},
5380   // int -> BOOL8 map
5381   .bool8Operands = {},
5382   // int -> QUANT8_SYMM_PER_CHANNEL map
5383   .quant8ChannelOperands = {},
5384   // int -> QUANT16_ASYMM map
5385   .quant16AsymmOperands = {},
5386   // int -> QUANT8_SYMM map
5387   .quant8SymmOperands = {},
5388 },
5389 //Output(s)
5390 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5391   // int -> Dimensions map
5392   .operandDimensions = {{0, {1, 1, 3, 3}}},
5393   // int -> FLOAT32 map
5394   .float32Operands = {},
5395   // int -> INT32 map
5396   .int32Operands = {},
5397   // int -> QUANT8_ASYMM map
5398   .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}},
5399   // int -> QUANT16_SYMM map
5400   .quant16SymmOperands = {},
5401   // int -> FLOAT16 map
5402   .float16Operands = {},
5403   // int -> BOOL8 map
5404   .bool8Operands = {},
5405   // int -> QUANT8_SYMM_PER_CHANNEL map
5406   .quant8ChannelOperands = {},
5407   // int -> QUANT16_ASYMM map
5408   .quant16AsymmOperands = {},
5409   // int -> QUANT8_SYMM map
5410   .quant8SymmOperands = {},
5411 }
5412 },
5413 }, // End of an example
5414 };
5415 return examples_same_padding_stride_2_nchw_weight_as_input_quant8;
5416 };
5417 
get_examples_same_padding_stride_2_nchw_weight_as_input_float16()5418 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_nchw_weight_as_input_float16() {
5419 static std::vector<MixedTypedExample> examples_same_padding_stride_2_nchw_weight_as_input_float16 = {
5420 // Begin of an example
5421 {
5422 .operands = {
5423 //Input(s)
5424 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5425   // int -> Dimensions map
5426   .operandDimensions = {{0, {1, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}},
5427   // int -> FLOAT32 map
5428   .float32Operands = {},
5429   // int -> INT32 map
5430   .int32Operands = {},
5431   // int -> QUANT8_ASYMM map
5432   .quant8AsymmOperands = {},
5433   // int -> QUANT16_SYMM map
5434   .quant16SymmOperands = {},
5435   // int -> FLOAT16 map
5436   .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}},
5437   // int -> BOOL8 map
5438   .bool8Operands = {},
5439   // int -> QUANT8_SYMM_PER_CHANNEL map
5440   .quant8ChannelOperands = {},
5441   // int -> QUANT16_ASYMM map
5442   .quant16AsymmOperands = {},
5443   // int -> QUANT8_SYMM map
5444   .quant8SymmOperands = {},
5445 },
5446 //Output(s)
5447 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5448   // int -> Dimensions map
5449   .operandDimensions = {{0, {1, 1, 3, 3}}},
5450   // int -> FLOAT32 map
5451   .float32Operands = {},
5452   // int -> INT32 map
5453   .int32Operands = {},
5454   // int -> QUANT8_ASYMM map
5455   .quant8AsymmOperands = {},
5456   // int -> QUANT16_SYMM map
5457   .quant16SymmOperands = {},
5458   // int -> FLOAT16 map
5459   .float16Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5460   // int -> BOOL8 map
5461   .bool8Operands = {},
5462   // int -> QUANT8_SYMM_PER_CHANNEL map
5463   .quant8ChannelOperands = {},
5464   // int -> QUANT16_ASYMM map
5465   .quant16AsymmOperands = {},
5466   // int -> QUANT8_SYMM map
5467   .quant8SymmOperands = {},
5468 }
5469 },
5470 }, // End of an example
5471 };
5472 return examples_same_padding_stride_2_nchw_weight_as_input_float16;
5473 };
5474 
get_examples_same_padding_stride_2_dynamic_output_shape_nhwc()5475 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc() {
5476 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc = {
5477 // Begin of an example
5478 {
5479 .operands = {
5480 //Input(s)
5481 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5482   // int -> Dimensions map
5483   .operandDimensions = {{0, {1, 6, 6, 1}}},
5484   // int -> FLOAT32 map
5485   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
5486   // int -> INT32 map
5487   .int32Operands = {},
5488   // int -> QUANT8_ASYMM map
5489   .quant8AsymmOperands = {},
5490   // int -> QUANT16_SYMM map
5491   .quant16SymmOperands = {},
5492   // int -> FLOAT16 map
5493   .float16Operands = {},
5494   // int -> BOOL8 map
5495   .bool8Operands = {},
5496   // int -> QUANT8_SYMM_PER_CHANNEL map
5497   .quant8ChannelOperands = {},
5498   // int -> QUANT16_ASYMM map
5499   .quant16AsymmOperands = {},
5500   // int -> QUANT8_SYMM map
5501   .quant8SymmOperands = {},
5502 },
5503 //Output(s)
5504 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5505   // int -> Dimensions map
5506   .operandDimensions = {{0, {1, 3, 3, 1}}},
5507   // int -> FLOAT32 map
5508   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5509   // int -> INT32 map
5510   .int32Operands = {},
5511   // int -> QUANT8_ASYMM map
5512   .quant8AsymmOperands = {},
5513   // int -> QUANT16_SYMM map
5514   .quant16SymmOperands = {},
5515   // int -> FLOAT16 map
5516   .float16Operands = {},
5517   // int -> BOOL8 map
5518   .bool8Operands = {},
5519   // int -> QUANT8_SYMM_PER_CHANNEL map
5520   .quant8ChannelOperands = {},
5521   // int -> QUANT16_ASYMM map
5522   .quant16AsymmOperands = {},
5523   // int -> QUANT8_SYMM map
5524   .quant8SymmOperands = {},
5525 }
5526 },
5527 }, // End of an example
5528 };
5529 return examples_same_padding_stride_2_dynamic_output_shape_nhwc;
5530 };
5531 
get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_relaxed()5532 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_relaxed() {
5533 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_relaxed = {
5534 // Begin of an example
5535 {
5536 .operands = {
5537 //Input(s)
5538 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5539   // int -> Dimensions map
5540   .operandDimensions = {{0, {1, 6, 6, 1}}},
5541   // int -> FLOAT32 map
5542   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
5543   // int -> INT32 map
5544   .int32Operands = {},
5545   // int -> QUANT8_ASYMM map
5546   .quant8AsymmOperands = {},
5547   // int -> QUANT16_SYMM map
5548   .quant16SymmOperands = {},
5549   // int -> FLOAT16 map
5550   .float16Operands = {},
5551   // int -> BOOL8 map
5552   .bool8Operands = {},
5553   // int -> QUANT8_SYMM_PER_CHANNEL map
5554   .quant8ChannelOperands = {},
5555   // int -> QUANT16_ASYMM map
5556   .quant16AsymmOperands = {},
5557   // int -> QUANT8_SYMM map
5558   .quant8SymmOperands = {},
5559 },
5560 //Output(s)
5561 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5562   // int -> Dimensions map
5563   .operandDimensions = {{0, {1, 3, 3, 1}}},
5564   // int -> FLOAT32 map
5565   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5566   // int -> INT32 map
5567   .int32Operands = {},
5568   // int -> QUANT8_ASYMM map
5569   .quant8AsymmOperands = {},
5570   // int -> QUANT16_SYMM map
5571   .quant16SymmOperands = {},
5572   // int -> FLOAT16 map
5573   .float16Operands = {},
5574   // int -> BOOL8 map
5575   .bool8Operands = {},
5576   // int -> QUANT8_SYMM_PER_CHANNEL map
5577   .quant8ChannelOperands = {},
5578   // int -> QUANT16_ASYMM map
5579   .quant16AsymmOperands = {},
5580   // int -> QUANT8_SYMM map
5581   .quant8SymmOperands = {},
5582 }
5583 },
5584 }, // End of an example
5585 };
5586 return examples_same_padding_stride_2_dynamic_output_shape_nhwc_relaxed;
5587 };
5588 
get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_quant8()5589 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_quant8() {
5590 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_quant8 = {
5591 // Begin of an example
5592 {
5593 .operands = {
5594 //Input(s)
5595 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5596   // int -> Dimensions map
5597   .operandDimensions = {{0, {1, 6, 6, 1}}},
5598   // int -> FLOAT32 map
5599   .float32Operands = {},
5600   // int -> INT32 map
5601   .int32Operands = {},
5602   // int -> QUANT8_ASYMM map
5603   .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}},
5604   // int -> QUANT16_SYMM map
5605   .quant16SymmOperands = {},
5606   // int -> FLOAT16 map
5607   .float16Operands = {},
5608   // int -> BOOL8 map
5609   .bool8Operands = {},
5610   // int -> QUANT8_SYMM_PER_CHANNEL map
5611   .quant8ChannelOperands = {},
5612   // int -> QUANT16_ASYMM map
5613   .quant16AsymmOperands = {},
5614   // int -> QUANT8_SYMM map
5615   .quant8SymmOperands = {},
5616 },
5617 //Output(s)
5618 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5619   // int -> Dimensions map
5620   .operandDimensions = {{0, {1, 3, 3, 1}}},
5621   // int -> FLOAT32 map
5622   .float32Operands = {},
5623   // int -> INT32 map
5624   .int32Operands = {},
5625   // int -> QUANT8_ASYMM map
5626   .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}},
5627   // int -> QUANT16_SYMM map
5628   .quant16SymmOperands = {},
5629   // int -> FLOAT16 map
5630   .float16Operands = {},
5631   // int -> BOOL8 map
5632   .bool8Operands = {},
5633   // int -> QUANT8_SYMM_PER_CHANNEL map
5634   .quant8ChannelOperands = {},
5635   // int -> QUANT16_ASYMM map
5636   .quant16AsymmOperands = {},
5637   // int -> QUANT8_SYMM map
5638   .quant8SymmOperands = {},
5639 }
5640 },
5641 }, // End of an example
5642 };
5643 return examples_same_padding_stride_2_dynamic_output_shape_nhwc_quant8;
5644 };
5645 
get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_float16()5646 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_float16() {
5647 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_float16 = {
5648 // Begin of an example
5649 {
5650 .operands = {
5651 //Input(s)
5652 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5653   // int -> Dimensions map
5654   .operandDimensions = {{0, {1, 6, 6, 1}}},
5655   // int -> FLOAT32 map
5656   .float32Operands = {},
5657   // int -> INT32 map
5658   .int32Operands = {},
5659   // int -> QUANT8_ASYMM map
5660   .quant8AsymmOperands = {},
5661   // int -> QUANT16_SYMM map
5662   .quant16SymmOperands = {},
5663   // int -> FLOAT16 map
5664   .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
5665   // int -> BOOL8 map
5666   .bool8Operands = {},
5667   // int -> QUANT8_SYMM_PER_CHANNEL map
5668   .quant8ChannelOperands = {},
5669   // int -> QUANT16_ASYMM map
5670   .quant16AsymmOperands = {},
5671   // int -> QUANT8_SYMM map
5672   .quant8SymmOperands = {},
5673 },
5674 //Output(s)
5675 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5676   // int -> Dimensions map
5677   .operandDimensions = {{0, {1, 3, 3, 1}}},
5678   // int -> FLOAT32 map
5679   .float32Operands = {},
5680   // int -> INT32 map
5681   .int32Operands = {},
5682   // int -> QUANT8_ASYMM map
5683   .quant8AsymmOperands = {},
5684   // int -> QUANT16_SYMM map
5685   .quant16SymmOperands = {},
5686   // int -> FLOAT16 map
5687   .float16Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5688   // int -> BOOL8 map
5689   .bool8Operands = {},
5690   // int -> QUANT8_SYMM_PER_CHANNEL map
5691   .quant8ChannelOperands = {},
5692   // int -> QUANT16_ASYMM map
5693   .quant16AsymmOperands = {},
5694   // int -> QUANT8_SYMM map
5695   .quant8SymmOperands = {},
5696 }
5697 },
5698 }, // End of an example
5699 };
5700 return examples_same_padding_stride_2_dynamic_output_shape_nhwc_float16;
5701 };
5702 
get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input()5703 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input() {
5704 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input = {
5705 // Begin of an example
5706 {
5707 .operands = {
5708 //Input(s)
5709 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5710   // int -> Dimensions map
5711   .operandDimensions = {{0, {1, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}},
5712   // int -> FLOAT32 map
5713   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}},
5714   // int -> INT32 map
5715   .int32Operands = {},
5716   // int -> QUANT8_ASYMM map
5717   .quant8AsymmOperands = {},
5718   // int -> QUANT16_SYMM map
5719   .quant16SymmOperands = {},
5720   // int -> FLOAT16 map
5721   .float16Operands = {},
5722   // int -> BOOL8 map
5723   .bool8Operands = {},
5724   // int -> QUANT8_SYMM_PER_CHANNEL map
5725   .quant8ChannelOperands = {},
5726   // int -> QUANT16_ASYMM map
5727   .quant16AsymmOperands = {},
5728   // int -> QUANT8_SYMM map
5729   .quant8SymmOperands = {},
5730 },
5731 //Output(s)
5732 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5733   // int -> Dimensions map
5734   .operandDimensions = {{0, {1, 3, 3, 1}}},
5735   // int -> FLOAT32 map
5736   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5737   // int -> INT32 map
5738   .int32Operands = {},
5739   // int -> QUANT8_ASYMM map
5740   .quant8AsymmOperands = {},
5741   // int -> QUANT16_SYMM map
5742   .quant16SymmOperands = {},
5743   // int -> FLOAT16 map
5744   .float16Operands = {},
5745   // int -> BOOL8 map
5746   .bool8Operands = {},
5747   // int -> QUANT8_SYMM_PER_CHANNEL map
5748   .quant8ChannelOperands = {},
5749   // int -> QUANT16_ASYMM map
5750   .quant16AsymmOperands = {},
5751   // int -> QUANT8_SYMM map
5752   .quant8SymmOperands = {},
5753 }
5754 },
5755 }, // End of an example
5756 };
5757 return examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input;
5758 };
5759 
get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_relaxed()5760 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_relaxed() {
5761 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_relaxed = {
5762 // Begin of an example
5763 {
5764 .operands = {
5765 //Input(s)
5766 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5767   // int -> Dimensions map
5768   .operandDimensions = {{0, {1, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}},
5769   // int -> FLOAT32 map
5770   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}},
5771   // int -> INT32 map
5772   .int32Operands = {},
5773   // int -> QUANT8_ASYMM map
5774   .quant8AsymmOperands = {},
5775   // int -> QUANT16_SYMM map
5776   .quant16SymmOperands = {},
5777   // int -> FLOAT16 map
5778   .float16Operands = {},
5779   // int -> BOOL8 map
5780   .bool8Operands = {},
5781   // int -> QUANT8_SYMM_PER_CHANNEL map
5782   .quant8ChannelOperands = {},
5783   // int -> QUANT16_ASYMM map
5784   .quant16AsymmOperands = {},
5785   // int -> QUANT8_SYMM map
5786   .quant8SymmOperands = {},
5787 },
5788 //Output(s)
5789 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5790   // int -> Dimensions map
5791   .operandDimensions = {{0, {1, 3, 3, 1}}},
5792   // int -> FLOAT32 map
5793   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5794   // int -> INT32 map
5795   .int32Operands = {},
5796   // int -> QUANT8_ASYMM map
5797   .quant8AsymmOperands = {},
5798   // int -> QUANT16_SYMM map
5799   .quant16SymmOperands = {},
5800   // int -> FLOAT16 map
5801   .float16Operands = {},
5802   // int -> BOOL8 map
5803   .bool8Operands = {},
5804   // int -> QUANT8_SYMM_PER_CHANNEL map
5805   .quant8ChannelOperands = {},
5806   // int -> QUANT16_ASYMM map
5807   .quant16AsymmOperands = {},
5808   // int -> QUANT8_SYMM map
5809   .quant8SymmOperands = {},
5810 }
5811 },
5812 }, // End of an example
5813 };
5814 return examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_relaxed;
5815 };
5816 
get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_quant8()5817 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_quant8() {
5818 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_quant8 = {
5819 // Begin of an example
5820 {
5821 .operands = {
5822 //Input(s)
5823 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5824   // int -> Dimensions map
5825   .operandDimensions = {{0, {1, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}},
5826   // int -> FLOAT32 map
5827   .float32Operands = {},
5828   // int -> INT32 map
5829   .int32Operands = {{2, {0}}},
5830   // int -> QUANT8_ASYMM map
5831   .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, {1, {8, 16, 24, 32}}},
5832   // int -> QUANT16_SYMM map
5833   .quant16SymmOperands = {},
5834   // int -> FLOAT16 map
5835   .float16Operands = {},
5836   // int -> BOOL8 map
5837   .bool8Operands = {},
5838   // int -> QUANT8_SYMM_PER_CHANNEL map
5839   .quant8ChannelOperands = {},
5840   // int -> QUANT16_ASYMM map
5841   .quant16AsymmOperands = {},
5842   // int -> QUANT8_SYMM map
5843   .quant8SymmOperands = {},
5844 },
5845 //Output(s)
5846 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5847   // int -> Dimensions map
5848   .operandDimensions = {{0, {1, 3, 3, 1}}},
5849   // int -> FLOAT32 map
5850   .float32Operands = {},
5851   // int -> INT32 map
5852   .int32Operands = {},
5853   // int -> QUANT8_ASYMM map
5854   .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}},
5855   // int -> QUANT16_SYMM map
5856   .quant16SymmOperands = {},
5857   // int -> FLOAT16 map
5858   .float16Operands = {},
5859   // int -> BOOL8 map
5860   .bool8Operands = {},
5861   // int -> QUANT8_SYMM_PER_CHANNEL map
5862   .quant8ChannelOperands = {},
5863   // int -> QUANT16_ASYMM map
5864   .quant16AsymmOperands = {},
5865   // int -> QUANT8_SYMM map
5866   .quant8SymmOperands = {},
5867 }
5868 },
5869 }, // End of an example
5870 };
5871 return examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_quant8;
5872 };
5873 
get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_float16()5874 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_float16() {
5875 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_float16 = {
5876 // Begin of an example
5877 {
5878 .operands = {
5879 //Input(s)
5880 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5881   // int -> Dimensions map
5882   .operandDimensions = {{0, {1, 6, 6, 1}}, {1, {1, 2, 2, 1}}, {2, {1}}},
5883   // int -> FLOAT32 map
5884   .float32Operands = {},
5885   // int -> INT32 map
5886   .int32Operands = {},
5887   // int -> QUANT8_ASYMM map
5888   .quant8AsymmOperands = {},
5889   // int -> QUANT16_SYMM map
5890   .quant16SymmOperands = {},
5891   // int -> FLOAT16 map
5892   .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}},
5893   // int -> BOOL8 map
5894   .bool8Operands = {},
5895   // int -> QUANT8_SYMM_PER_CHANNEL map
5896   .quant8ChannelOperands = {},
5897   // int -> QUANT16_ASYMM map
5898   .quant16AsymmOperands = {},
5899   // int -> QUANT8_SYMM map
5900   .quant8SymmOperands = {},
5901 },
5902 //Output(s)
5903 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5904   // int -> Dimensions map
5905   .operandDimensions = {{0, {1, 3, 3, 1}}},
5906   // int -> FLOAT32 map
5907   .float32Operands = {},
5908   // int -> INT32 map
5909   .int32Operands = {},
5910   // int -> QUANT8_ASYMM map
5911   .quant8AsymmOperands = {},
5912   // int -> QUANT16_SYMM map
5913   .quant16SymmOperands = {},
5914   // int -> FLOAT16 map
5915   .float16Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5916   // int -> BOOL8 map
5917   .bool8Operands = {},
5918   // int -> QUANT8_SYMM_PER_CHANNEL map
5919   .quant8ChannelOperands = {},
5920   // int -> QUANT16_ASYMM map
5921   .quant16AsymmOperands = {},
5922   // int -> QUANT8_SYMM map
5923   .quant8SymmOperands = {},
5924 }
5925 },
5926 }, // End of an example
5927 };
5928 return examples_same_padding_stride_2_dynamic_output_shape_nhwc_weight_as_input_float16;
5929 };
5930 
get_examples_same_padding_stride_2_dynamic_output_shape_nchw()5931 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw() {
5932 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw = {
5933 // Begin of an example
5934 {
5935 .operands = {
5936 //Input(s)
5937 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5938   // int -> Dimensions map
5939   .operandDimensions = {{0, {1, 1, 6, 6}}},
5940   // int -> FLOAT32 map
5941   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
5942   // int -> INT32 map
5943   .int32Operands = {},
5944   // int -> QUANT8_ASYMM map
5945   .quant8AsymmOperands = {},
5946   // int -> QUANT16_SYMM map
5947   .quant16SymmOperands = {},
5948   // int -> FLOAT16 map
5949   .float16Operands = {},
5950   // int -> BOOL8 map
5951   .bool8Operands = {},
5952   // int -> QUANT8_SYMM_PER_CHANNEL map
5953   .quant8ChannelOperands = {},
5954   // int -> QUANT16_ASYMM map
5955   .quant16AsymmOperands = {},
5956   // int -> QUANT8_SYMM map
5957   .quant8SymmOperands = {},
5958 },
5959 //Output(s)
5960 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5961   // int -> Dimensions map
5962   .operandDimensions = {{0, {1, 1, 3, 3}}},
5963   // int -> FLOAT32 map
5964   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
5965   // int -> INT32 map
5966   .int32Operands = {},
5967   // int -> QUANT8_ASYMM map
5968   .quant8AsymmOperands = {},
5969   // int -> QUANT16_SYMM map
5970   .quant16SymmOperands = {},
5971   // int -> FLOAT16 map
5972   .float16Operands = {},
5973   // int -> BOOL8 map
5974   .bool8Operands = {},
5975   // int -> QUANT8_SYMM_PER_CHANNEL map
5976   .quant8ChannelOperands = {},
5977   // int -> QUANT16_ASYMM map
5978   .quant16AsymmOperands = {},
5979   // int -> QUANT8_SYMM map
5980   .quant8SymmOperands = {},
5981 }
5982 },
5983 }, // End of an example
5984 };
5985 return examples_same_padding_stride_2_dynamic_output_shape_nchw;
5986 };
5987 
get_examples_same_padding_stride_2_dynamic_output_shape_nchw_relaxed()5988 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_relaxed() {
5989 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_relaxed = {
5990 // Begin of an example
5991 {
5992 .operands = {
5993 //Input(s)
5994 { // See tools/test_generator/include/TestHarness.h:MixedTyped
5995   // int -> Dimensions map
5996   .operandDimensions = {{0, {1, 1, 6, 6}}},
5997   // int -> FLOAT32 map
5998   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
5999   // int -> INT32 map
6000   .int32Operands = {},
6001   // int -> QUANT8_ASYMM map
6002   .quant8AsymmOperands = {},
6003   // int -> QUANT16_SYMM map
6004   .quant16SymmOperands = {},
6005   // int -> FLOAT16 map
6006   .float16Operands = {},
6007   // int -> BOOL8 map
6008   .bool8Operands = {},
6009   // int -> QUANT8_SYMM_PER_CHANNEL map
6010   .quant8ChannelOperands = {},
6011   // int -> QUANT16_ASYMM map
6012   .quant16AsymmOperands = {},
6013   // int -> QUANT8_SYMM map
6014   .quant8SymmOperands = {},
6015 },
6016 //Output(s)
6017 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6018   // int -> Dimensions map
6019   .operandDimensions = {{0, {1, 1, 3, 3}}},
6020   // int -> FLOAT32 map
6021   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
6022   // int -> INT32 map
6023   .int32Operands = {},
6024   // int -> QUANT8_ASYMM map
6025   .quant8AsymmOperands = {},
6026   // int -> QUANT16_SYMM map
6027   .quant16SymmOperands = {},
6028   // int -> FLOAT16 map
6029   .float16Operands = {},
6030   // int -> BOOL8 map
6031   .bool8Operands = {},
6032   // int -> QUANT8_SYMM_PER_CHANNEL map
6033   .quant8ChannelOperands = {},
6034   // int -> QUANT16_ASYMM map
6035   .quant16AsymmOperands = {},
6036   // int -> QUANT8_SYMM map
6037   .quant8SymmOperands = {},
6038 }
6039 },
6040 }, // End of an example
6041 };
6042 return examples_same_padding_stride_2_dynamic_output_shape_nchw_relaxed;
6043 };
6044 
get_examples_same_padding_stride_2_dynamic_output_shape_nchw_quant8()6045 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_quant8() {
6046 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_quant8 = {
6047 // Begin of an example
6048 {
6049 .operands = {
6050 //Input(s)
6051 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6052   // int -> Dimensions map
6053   .operandDimensions = {{0, {1, 1, 6, 6}}},
6054   // int -> FLOAT32 map
6055   .float32Operands = {},
6056   // int -> INT32 map
6057   .int32Operands = {},
6058   // int -> QUANT8_ASYMM map
6059   .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}},
6060   // int -> QUANT16_SYMM map
6061   .quant16SymmOperands = {},
6062   // int -> FLOAT16 map
6063   .float16Operands = {},
6064   // int -> BOOL8 map
6065   .bool8Operands = {},
6066   // int -> QUANT8_SYMM_PER_CHANNEL map
6067   .quant8ChannelOperands = {},
6068   // int -> QUANT16_ASYMM map
6069   .quant16AsymmOperands = {},
6070   // int -> QUANT8_SYMM map
6071   .quant8SymmOperands = {},
6072 },
6073 //Output(s)
6074 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6075   // int -> Dimensions map
6076   .operandDimensions = {{0, {1, 1, 3, 3}}},
6077   // int -> FLOAT32 map
6078   .float32Operands = {},
6079   // int -> INT32 map
6080   .int32Operands = {},
6081   // int -> QUANT8_ASYMM map
6082   .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}},
6083   // int -> QUANT16_SYMM map
6084   .quant16SymmOperands = {},
6085   // int -> FLOAT16 map
6086   .float16Operands = {},
6087   // int -> BOOL8 map
6088   .bool8Operands = {},
6089   // int -> QUANT8_SYMM_PER_CHANNEL map
6090   .quant8ChannelOperands = {},
6091   // int -> QUANT16_ASYMM map
6092   .quant16AsymmOperands = {},
6093   // int -> QUANT8_SYMM map
6094   .quant8SymmOperands = {},
6095 }
6096 },
6097 }, // End of an example
6098 };
6099 return examples_same_padding_stride_2_dynamic_output_shape_nchw_quant8;
6100 };
6101 
get_examples_same_padding_stride_2_dynamic_output_shape_nchw_float16()6102 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_float16() {
6103 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_float16 = {
6104 // Begin of an example
6105 {
6106 .operands = {
6107 //Input(s)
6108 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6109   // int -> Dimensions map
6110   .operandDimensions = {{0, {1, 1, 6, 6}}},
6111   // int -> FLOAT32 map
6112   .float32Operands = {},
6113   // int -> INT32 map
6114   .int32Operands = {},
6115   // int -> QUANT8_ASYMM map
6116   .quant8AsymmOperands = {},
6117   // int -> QUANT16_SYMM map
6118   .quant16SymmOperands = {},
6119   // int -> FLOAT16 map
6120   .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}},
6121   // int -> BOOL8 map
6122   .bool8Operands = {},
6123   // int -> QUANT8_SYMM_PER_CHANNEL map
6124   .quant8ChannelOperands = {},
6125   // int -> QUANT16_ASYMM map
6126   .quant16AsymmOperands = {},
6127   // int -> QUANT8_SYMM map
6128   .quant8SymmOperands = {},
6129 },
6130 //Output(s)
6131 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6132   // int -> Dimensions map
6133   .operandDimensions = {{0, {1, 1, 3, 3}}},
6134   // int -> FLOAT32 map
6135   .float32Operands = {},
6136   // int -> INT32 map
6137   .int32Operands = {},
6138   // int -> QUANT8_ASYMM map
6139   .quant8AsymmOperands = {},
6140   // int -> QUANT16_SYMM map
6141   .quant16SymmOperands = {},
6142   // int -> FLOAT16 map
6143   .float16Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
6144   // int -> BOOL8 map
6145   .bool8Operands = {},
6146   // int -> QUANT8_SYMM_PER_CHANNEL map
6147   .quant8ChannelOperands = {},
6148   // int -> QUANT16_ASYMM map
6149   .quant16AsymmOperands = {},
6150   // int -> QUANT8_SYMM map
6151   .quant8SymmOperands = {},
6152 }
6153 },
6154 }, // End of an example
6155 };
6156 return examples_same_padding_stride_2_dynamic_output_shape_nchw_float16;
6157 };
6158 
get_examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input()6159 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input() {
6160 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input = {
6161 // Begin of an example
6162 {
6163 .operands = {
6164 //Input(s)
6165 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6166   // int -> Dimensions map
6167   .operandDimensions = {{0, {1, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}},
6168   // int -> FLOAT32 map
6169   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}},
6170   // int -> INT32 map
6171   .int32Operands = {},
6172   // int -> QUANT8_ASYMM map
6173   .quant8AsymmOperands = {},
6174   // int -> QUANT16_SYMM map
6175   .quant16SymmOperands = {},
6176   // int -> FLOAT16 map
6177   .float16Operands = {},
6178   // int -> BOOL8 map
6179   .bool8Operands = {},
6180   // int -> QUANT8_SYMM_PER_CHANNEL map
6181   .quant8ChannelOperands = {},
6182   // int -> QUANT16_ASYMM map
6183   .quant16AsymmOperands = {},
6184   // int -> QUANT8_SYMM map
6185   .quant8SymmOperands = {},
6186 },
6187 //Output(s)
6188 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6189   // int -> Dimensions map
6190   .operandDimensions = {{0, {1, 1, 3, 3}}},
6191   // int -> FLOAT32 map
6192   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
6193   // int -> INT32 map
6194   .int32Operands = {},
6195   // int -> QUANT8_ASYMM map
6196   .quant8AsymmOperands = {},
6197   // int -> QUANT16_SYMM map
6198   .quant16SymmOperands = {},
6199   // int -> FLOAT16 map
6200   .float16Operands = {},
6201   // int -> BOOL8 map
6202   .bool8Operands = {},
6203   // int -> QUANT8_SYMM_PER_CHANNEL map
6204   .quant8ChannelOperands = {},
6205   // int -> QUANT16_ASYMM map
6206   .quant16AsymmOperands = {},
6207   // int -> QUANT8_SYMM map
6208   .quant8SymmOperands = {},
6209 }
6210 },
6211 }, // End of an example
6212 };
6213 return examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input;
6214 };
6215 
get_examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_relaxed()6216 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_relaxed() {
6217 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_relaxed = {
6218 // Begin of an example
6219 {
6220 .operands = {
6221 //Input(s)
6222 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6223   // int -> Dimensions map
6224   .operandDimensions = {{0, {1, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}},
6225   // int -> FLOAT32 map
6226   .float32Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}},
6227   // int -> INT32 map
6228   .int32Operands = {},
6229   // int -> QUANT8_ASYMM map
6230   .quant8AsymmOperands = {},
6231   // int -> QUANT16_SYMM map
6232   .quant16SymmOperands = {},
6233   // int -> FLOAT16 map
6234   .float16Operands = {},
6235   // int -> BOOL8 map
6236   .bool8Operands = {},
6237   // int -> QUANT8_SYMM_PER_CHANNEL map
6238   .quant8ChannelOperands = {},
6239   // int -> QUANT16_ASYMM map
6240   .quant16AsymmOperands = {},
6241   // int -> QUANT8_SYMM map
6242   .quant8SymmOperands = {},
6243 },
6244 //Output(s)
6245 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6246   // int -> Dimensions map
6247   .operandDimensions = {{0, {1, 1, 3, 3}}},
6248   // int -> FLOAT32 map
6249   .float32Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
6250   // int -> INT32 map
6251   .int32Operands = {},
6252   // int -> QUANT8_ASYMM map
6253   .quant8AsymmOperands = {},
6254   // int -> QUANT16_SYMM map
6255   .quant16SymmOperands = {},
6256   // int -> FLOAT16 map
6257   .float16Operands = {},
6258   // int -> BOOL8 map
6259   .bool8Operands = {},
6260   // int -> QUANT8_SYMM_PER_CHANNEL map
6261   .quant8ChannelOperands = {},
6262   // int -> QUANT16_ASYMM map
6263   .quant16AsymmOperands = {},
6264   // int -> QUANT8_SYMM map
6265   .quant8SymmOperands = {},
6266 }
6267 },
6268 }, // End of an example
6269 };
6270 return examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_relaxed;
6271 };
6272 
get_examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_quant8()6273 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_quant8() {
6274 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_quant8 = {
6275 // Begin of an example
6276 {
6277 .operands = {
6278 //Input(s)
6279 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6280   // int -> Dimensions map
6281   .operandDimensions = {{0, {1, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}},
6282   // int -> FLOAT32 map
6283   .float32Operands = {},
6284   // int -> INT32 map
6285   .int32Operands = {{2, {0}}},
6286   // int -> QUANT8_ASYMM map
6287   .quant8AsymmOperands = {{0, {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, {1, {8, 16, 24, 32}}},
6288   // int -> QUANT16_SYMM map
6289   .quant16SymmOperands = {},
6290   // int -> FLOAT16 map
6291   .float16Operands = {},
6292   // int -> BOOL8 map
6293   .bool8Operands = {},
6294   // int -> QUANT8_SYMM_PER_CHANNEL map
6295   .quant8ChannelOperands = {},
6296   // int -> QUANT16_ASYMM map
6297   .quant16AsymmOperands = {},
6298   // int -> QUANT8_SYMM map
6299   .quant8SymmOperands = {},
6300 },
6301 //Output(s)
6302 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6303   // int -> Dimensions map
6304   .operandDimensions = {{0, {1, 1, 3, 3}}},
6305   // int -> FLOAT32 map
6306   .float32Operands = {},
6307   // int -> INT32 map
6308   .int32Operands = {},
6309   // int -> QUANT8_ASYMM map
6310   .quant8AsymmOperands = {{0, {32, 0, 24, 0, 0, 0, 16, 0, 8}}},
6311   // int -> QUANT16_SYMM map
6312   .quant16SymmOperands = {},
6313   // int -> FLOAT16 map
6314   .float16Operands = {},
6315   // int -> BOOL8 map
6316   .bool8Operands = {},
6317   // int -> QUANT8_SYMM_PER_CHANNEL map
6318   .quant8ChannelOperands = {},
6319   // int -> QUANT16_ASYMM map
6320   .quant16AsymmOperands = {},
6321   // int -> QUANT8_SYMM map
6322   .quant8SymmOperands = {},
6323 }
6324 },
6325 }, // End of an example
6326 };
6327 return examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_quant8;
6328 };
6329 
get_examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_float16()6330 std::vector<MixedTypedExample>& get_examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_float16() {
6331 static std::vector<MixedTypedExample> examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_float16 = {
6332 // Begin of an example
6333 {
6334 .operands = {
6335 //Input(s)
6336 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6337   // int -> Dimensions map
6338   .operandDimensions = {{0, {1, 1, 6, 6}}, {1, {1, 2, 2, 1}}, {2, {1}}},
6339   // int -> FLOAT32 map
6340   .float32Operands = {},
6341   // int -> INT32 map
6342   .int32Operands = {},
6343   // int -> QUANT8_ASYMM map
6344   .quant8AsymmOperands = {},
6345   // int -> QUANT16_SYMM map
6346   .quant16SymmOperands = {},
6347   // int -> FLOAT16 map
6348   .float16Operands = {{0, {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f}}, {1, {1.0f, 2.0f, 3.0f, 4.0f}}, {2, {0.0f}}},
6349   // int -> BOOL8 map
6350   .bool8Operands = {},
6351   // int -> QUANT8_SYMM_PER_CHANNEL map
6352   .quant8ChannelOperands = {},
6353   // int -> QUANT16_ASYMM map
6354   .quant16AsymmOperands = {},
6355   // int -> QUANT8_SYMM map
6356   .quant8SymmOperands = {},
6357 },
6358 //Output(s)
6359 { // See tools/test_generator/include/TestHarness.h:MixedTyped
6360   // int -> Dimensions map
6361   .operandDimensions = {{0, {1, 1, 3, 3}}},
6362   // int -> FLOAT32 map
6363   .float32Operands = {},
6364   // int -> INT32 map
6365   .int32Operands = {},
6366   // int -> QUANT8_ASYMM map
6367   .quant8AsymmOperands = {},
6368   // int -> QUANT16_SYMM map
6369   .quant16SymmOperands = {},
6370   // int -> FLOAT16 map
6371   .float16Operands = {{0, {4.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 2.0f, 0.0f, 1.0f}}},
6372   // int -> BOOL8 map
6373   .bool8Operands = {},
6374   // int -> QUANT8_SYMM_PER_CHANNEL map
6375   .quant8ChannelOperands = {},
6376   // int -> QUANT16_ASYMM map
6377   .quant16AsymmOperands = {},
6378   // int -> QUANT8_SYMM map
6379   .quant8SymmOperands = {},
6380 }
6381 },
6382 }, // End of an example
6383 };
6384 return examples_same_padding_stride_2_dynamic_output_shape_nchw_weight_as_input_float16;
6385 };
6386 
6387