1 // clang-format off
2 // Generated file (from: cast.mod.py). Do not edit
CreateModel(Model * model)3 void CreateModel(Model *model) {
4   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
5   // Phase 1, operands
6   auto input0 = model->addOperand(&type0);
7   auto output0 = model->addOperand(&type0);
8   // Phase 2, operations
9   model->addOperation(ANEURALNETWORKS_CAST, {input0}, {output0});
10   // Phase 3, inputs and outputs
11   model->identifyInputsAndOutputs(
12     {input0},
13     {output0});
14   assert(model->isValid());
15 }
16 
is_ignored(int i)17 inline bool is_ignored(int i) {
18   static std::set<int> ignore = {};
19   return ignore.find(i) != ignore.end();
20 }
21 
CreateModel_dynamic_output_shape(Model * model)22 void CreateModel_dynamic_output_shape(Model *model) {
23   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
24   OperandType type8(Type::TENSOR_FLOAT16, {0, 0});
25   // Phase 1, operands
26   auto input0 = model->addOperand(&type0);
27   auto output0 = model->addOperand(&type8);
28   // Phase 2, operations
29   model->addOperation(ANEURALNETWORKS_CAST, {input0}, {output0});
30   // Phase 3, inputs and outputs
31   model->identifyInputsAndOutputs(
32     {input0},
33     {output0});
34   assert(model->isValid());
35 }
36 
is_ignored_dynamic_output_shape(int i)37 inline bool is_ignored_dynamic_output_shape(int i) {
38   static std::set<int> ignore = {};
39   return ignore.find(i) != ignore.end();
40 }
41 
CreateModel_2(Model * model)42 void CreateModel_2(Model *model) {
43   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
44   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
45   // Phase 1, operands
46   auto input0 = model->addOperand(&type0);
47   auto output01 = model->addOperand(&type1);
48   // Phase 2, operations
49   model->addOperation(ANEURALNETWORKS_CAST, {input0}, {output01});
50   // Phase 3, inputs and outputs
51   model->identifyInputsAndOutputs(
52     {input0},
53     {output01});
54   assert(model->isValid());
55 }
56 
is_ignored_2(int i)57 inline bool is_ignored_2(int i) {
58   static std::set<int> ignore = {};
59   return ignore.find(i) != ignore.end();
60 }
61 
CreateModel_relaxed(Model * model)62 void CreateModel_relaxed(Model *model) {
63   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
64   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
65   // Phase 1, operands
66   auto input0 = model->addOperand(&type0);
67   auto output01 = model->addOperand(&type1);
68   // Phase 2, operations
69   model->addOperation(ANEURALNETWORKS_CAST, {input0}, {output01});
70   // Phase 3, inputs and outputs
71   model->identifyInputsAndOutputs(
72     {input0},
73     {output01});
74   // Phase 4: set relaxed execution
75   model->relaxComputationFloat32toFloat16(true);
76   assert(model->isValid());
77 }
78 
is_ignored_relaxed(int i)79 inline bool is_ignored_relaxed(int i) {
80   static std::set<int> ignore = {};
81   return ignore.find(i) != ignore.end();
82 }
83 
CreateModel_dynamic_output_shape_2(Model * model)84 void CreateModel_dynamic_output_shape_2(Model *model) {
85   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
86   OperandType type9(Type::TENSOR_FLOAT32, {0, 0});
87   // Phase 1, operands
88   auto input0 = model->addOperand(&type0);
89   auto output01 = model->addOperand(&type9);
90   // Phase 2, operations
91   model->addOperation(ANEURALNETWORKS_CAST, {input0}, {output01});
92   // Phase 3, inputs and outputs
93   model->identifyInputsAndOutputs(
94     {input0},
95     {output01});
96   assert(model->isValid());
97 }
98 
is_ignored_dynamic_output_shape_2(int i)99 inline bool is_ignored_dynamic_output_shape_2(int i) {
100   static std::set<int> ignore = {};
101   return ignore.find(i) != ignore.end();
102 }
103 
CreateModel_dynamic_output_shape_relaxed(Model * model)104 void CreateModel_dynamic_output_shape_relaxed(Model *model) {
105   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
106   OperandType type9(Type::TENSOR_FLOAT32, {0, 0});
107   // Phase 1, operands
108   auto input0 = model->addOperand(&type0);
109   auto output01 = model->addOperand(&type9);
110   // Phase 2, operations
111   model->addOperation(ANEURALNETWORKS_CAST, {input0}, {output01});
112   // Phase 3, inputs and outputs
113   model->identifyInputsAndOutputs(
114     {input0},
115     {output01});
116   // Phase 4: set relaxed execution
117   model->relaxComputationFloat32toFloat16(true);
118   assert(model->isValid());
119 }
120 
is_ignored_dynamic_output_shape_relaxed(int i)121 inline bool is_ignored_dynamic_output_shape_relaxed(int i) {
122   static std::set<int> ignore = {};
123   return ignore.find(i) != ignore.end();
124 }
125 
CreateModel_3(Model * model)126 void CreateModel_3(Model *model) {
127   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
128   OperandType type2(Type::TENSOR_INT32, {2, 3});
129   // Phase 1, operands
130   auto input0 = model->addOperand(&type0);
131   auto output02 = model->addOperand(&type2);
132   // Phase 2, operations
133   model->addOperation(ANEURALNETWORKS_CAST, {input0}, {output02});
134   // Phase 3, inputs and outputs
135   model->identifyInputsAndOutputs(
136     {input0},
137     {output02});
138   assert(model->isValid());
139 }
140 
is_ignored_3(int i)141 inline bool is_ignored_3(int i) {
142   static std::set<int> ignore = {};
143   return ignore.find(i) != ignore.end();
144 }
145 
CreateModel_dynamic_output_shape_3(Model * model)146 void CreateModel_dynamic_output_shape_3(Model *model) {
147   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
148   OperandType type10(Type::TENSOR_INT32, {0, 0});
149   // Phase 1, operands
150   auto input0 = model->addOperand(&type0);
151   auto output02 = model->addOperand(&type10);
152   // Phase 2, operations
153   model->addOperation(ANEURALNETWORKS_CAST, {input0}, {output02});
154   // Phase 3, inputs and outputs
155   model->identifyInputsAndOutputs(
156     {input0},
157     {output02});
158   assert(model->isValid());
159 }
160 
is_ignored_dynamic_output_shape_3(int i)161 inline bool is_ignored_dynamic_output_shape_3(int i) {
162   static std::set<int> ignore = {};
163   return ignore.find(i) != ignore.end();
164 }
165 
CreateModel_4(Model * model)166 void CreateModel_4(Model *model) {
167   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
168   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
169   // Phase 1, operands
170   auto input0 = model->addOperand(&type0);
171   auto output03 = model->addOperand(&type3);
172   // Phase 2, operations
173   model->addOperation(ANEURALNETWORKS_CAST, {input0}, {output03});
174   // Phase 3, inputs and outputs
175   model->identifyInputsAndOutputs(
176     {input0},
177     {output03});
178   assert(model->isValid());
179 }
180 
is_ignored_4(int i)181 inline bool is_ignored_4(int i) {
182   static std::set<int> ignore = {};
183   return ignore.find(i) != ignore.end();
184 }
185 
CreateModel_dynamic_output_shape_4(Model * model)186 void CreateModel_dynamic_output_shape_4(Model *model) {
187   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
188   OperandType type11(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 4.0f, 100);
189   // Phase 1, operands
190   auto input0 = model->addOperand(&type0);
191   auto output03 = model->addOperand(&type11);
192   // Phase 2, operations
193   model->addOperation(ANEURALNETWORKS_CAST, {input0}, {output03});
194   // Phase 3, inputs and outputs
195   model->identifyInputsAndOutputs(
196     {input0},
197     {output03});
198   assert(model->isValid());
199 }
200 
is_ignored_dynamic_output_shape_4(int i)201 inline bool is_ignored_dynamic_output_shape_4(int i) {
202   static std::set<int> ignore = {};
203   return ignore.find(i) != ignore.end();
204 }
205 
CreateModel_5(Model * model)206 void CreateModel_5(Model *model) {
207   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
208   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
209   // Phase 1, operands
210   auto input01 = model->addOperand(&type1);
211   auto output0 = model->addOperand(&type0);
212   // Phase 2, operations
213   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output0});
214   // Phase 3, inputs and outputs
215   model->identifyInputsAndOutputs(
216     {input01},
217     {output0});
218   assert(model->isValid());
219 }
220 
is_ignored_5(int i)221 inline bool is_ignored_5(int i) {
222   static std::set<int> ignore = {};
223   return ignore.find(i) != ignore.end();
224 }
225 
CreateModel_relaxed_2(Model * model)226 void CreateModel_relaxed_2(Model *model) {
227   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
228   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
229   // Phase 1, operands
230   auto input01 = model->addOperand(&type1);
231   auto output0 = model->addOperand(&type0);
232   // Phase 2, operations
233   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output0});
234   // Phase 3, inputs and outputs
235   model->identifyInputsAndOutputs(
236     {input01},
237     {output0});
238   // Phase 4: set relaxed execution
239   model->relaxComputationFloat32toFloat16(true);
240   assert(model->isValid());
241 }
242 
is_ignored_relaxed_2(int i)243 inline bool is_ignored_relaxed_2(int i) {
244   static std::set<int> ignore = {};
245   return ignore.find(i) != ignore.end();
246 }
247 
CreateModel_dynamic_output_shape_5(Model * model)248 void CreateModel_dynamic_output_shape_5(Model *model) {
249   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
250   OperandType type8(Type::TENSOR_FLOAT16, {0, 0});
251   // Phase 1, operands
252   auto input01 = model->addOperand(&type1);
253   auto output0 = model->addOperand(&type8);
254   // Phase 2, operations
255   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output0});
256   // Phase 3, inputs and outputs
257   model->identifyInputsAndOutputs(
258     {input01},
259     {output0});
260   assert(model->isValid());
261 }
262 
is_ignored_dynamic_output_shape_5(int i)263 inline bool is_ignored_dynamic_output_shape_5(int i) {
264   static std::set<int> ignore = {};
265   return ignore.find(i) != ignore.end();
266 }
267 
CreateModel_dynamic_output_shape_relaxed_2(Model * model)268 void CreateModel_dynamic_output_shape_relaxed_2(Model *model) {
269   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
270   OperandType type8(Type::TENSOR_FLOAT16, {0, 0});
271   // Phase 1, operands
272   auto input01 = model->addOperand(&type1);
273   auto output0 = model->addOperand(&type8);
274   // Phase 2, operations
275   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output0});
276   // Phase 3, inputs and outputs
277   model->identifyInputsAndOutputs(
278     {input01},
279     {output0});
280   // Phase 4: set relaxed execution
281   model->relaxComputationFloat32toFloat16(true);
282   assert(model->isValid());
283 }
284 
is_ignored_dynamic_output_shape_relaxed_2(int i)285 inline bool is_ignored_dynamic_output_shape_relaxed_2(int i) {
286   static std::set<int> ignore = {};
287   return ignore.find(i) != ignore.end();
288 }
289 
CreateModel_6(Model * model)290 void CreateModel_6(Model *model) {
291   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
292   // Phase 1, operands
293   auto input01 = model->addOperand(&type1);
294   auto output01 = model->addOperand(&type1);
295   // Phase 2, operations
296   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output01});
297   // Phase 3, inputs and outputs
298   model->identifyInputsAndOutputs(
299     {input01},
300     {output01});
301   assert(model->isValid());
302 }
303 
is_ignored_6(int i)304 inline bool is_ignored_6(int i) {
305   static std::set<int> ignore = {};
306   return ignore.find(i) != ignore.end();
307 }
308 
CreateModel_relaxed_3(Model * model)309 void CreateModel_relaxed_3(Model *model) {
310   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
311   // Phase 1, operands
312   auto input01 = model->addOperand(&type1);
313   auto output01 = model->addOperand(&type1);
314   // Phase 2, operations
315   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output01});
316   // Phase 3, inputs and outputs
317   model->identifyInputsAndOutputs(
318     {input01},
319     {output01});
320   // Phase 4: set relaxed execution
321   model->relaxComputationFloat32toFloat16(true);
322   assert(model->isValid());
323 }
324 
is_ignored_relaxed_3(int i)325 inline bool is_ignored_relaxed_3(int i) {
326   static std::set<int> ignore = {};
327   return ignore.find(i) != ignore.end();
328 }
329 
CreateModel_dynamic_output_shape_6(Model * model)330 void CreateModel_dynamic_output_shape_6(Model *model) {
331   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
332   OperandType type9(Type::TENSOR_FLOAT32, {0, 0});
333   // Phase 1, operands
334   auto input01 = model->addOperand(&type1);
335   auto output01 = model->addOperand(&type9);
336   // Phase 2, operations
337   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output01});
338   // Phase 3, inputs and outputs
339   model->identifyInputsAndOutputs(
340     {input01},
341     {output01});
342   assert(model->isValid());
343 }
344 
is_ignored_dynamic_output_shape_6(int i)345 inline bool is_ignored_dynamic_output_shape_6(int i) {
346   static std::set<int> ignore = {};
347   return ignore.find(i) != ignore.end();
348 }
349 
CreateModel_dynamic_output_shape_relaxed_3(Model * model)350 void CreateModel_dynamic_output_shape_relaxed_3(Model *model) {
351   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
352   OperandType type9(Type::TENSOR_FLOAT32, {0, 0});
353   // Phase 1, operands
354   auto input01 = model->addOperand(&type1);
355   auto output01 = model->addOperand(&type9);
356   // Phase 2, operations
357   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output01});
358   // Phase 3, inputs and outputs
359   model->identifyInputsAndOutputs(
360     {input01},
361     {output01});
362   // Phase 4: set relaxed execution
363   model->relaxComputationFloat32toFloat16(true);
364   assert(model->isValid());
365 }
366 
is_ignored_dynamic_output_shape_relaxed_3(int i)367 inline bool is_ignored_dynamic_output_shape_relaxed_3(int i) {
368   static std::set<int> ignore = {};
369   return ignore.find(i) != ignore.end();
370 }
371 
CreateModel_7(Model * model)372 void CreateModel_7(Model *model) {
373   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
374   OperandType type2(Type::TENSOR_INT32, {2, 3});
375   // Phase 1, operands
376   auto input01 = model->addOperand(&type1);
377   auto output02 = model->addOperand(&type2);
378   // Phase 2, operations
379   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output02});
380   // Phase 3, inputs and outputs
381   model->identifyInputsAndOutputs(
382     {input01},
383     {output02});
384   assert(model->isValid());
385 }
386 
is_ignored_7(int i)387 inline bool is_ignored_7(int i) {
388   static std::set<int> ignore = {};
389   return ignore.find(i) != ignore.end();
390 }
391 
CreateModel_relaxed_4(Model * model)392 void CreateModel_relaxed_4(Model *model) {
393   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
394   OperandType type2(Type::TENSOR_INT32, {2, 3});
395   // Phase 1, operands
396   auto input01 = model->addOperand(&type1);
397   auto output02 = model->addOperand(&type2);
398   // Phase 2, operations
399   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output02});
400   // Phase 3, inputs and outputs
401   model->identifyInputsAndOutputs(
402     {input01},
403     {output02});
404   // Phase 4: set relaxed execution
405   model->relaxComputationFloat32toFloat16(true);
406   assert(model->isValid());
407 }
408 
is_ignored_relaxed_4(int i)409 inline bool is_ignored_relaxed_4(int i) {
410   static std::set<int> ignore = {};
411   return ignore.find(i) != ignore.end();
412 }
413 
CreateModel_dynamic_output_shape_7(Model * model)414 void CreateModel_dynamic_output_shape_7(Model *model) {
415   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
416   OperandType type10(Type::TENSOR_INT32, {0, 0});
417   // Phase 1, operands
418   auto input01 = model->addOperand(&type1);
419   auto output02 = model->addOperand(&type10);
420   // Phase 2, operations
421   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output02});
422   // Phase 3, inputs and outputs
423   model->identifyInputsAndOutputs(
424     {input01},
425     {output02});
426   assert(model->isValid());
427 }
428 
is_ignored_dynamic_output_shape_7(int i)429 inline bool is_ignored_dynamic_output_shape_7(int i) {
430   static std::set<int> ignore = {};
431   return ignore.find(i) != ignore.end();
432 }
433 
CreateModel_dynamic_output_shape_relaxed_4(Model * model)434 void CreateModel_dynamic_output_shape_relaxed_4(Model *model) {
435   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
436   OperandType type10(Type::TENSOR_INT32, {0, 0});
437   // Phase 1, operands
438   auto input01 = model->addOperand(&type1);
439   auto output02 = model->addOperand(&type10);
440   // Phase 2, operations
441   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output02});
442   // Phase 3, inputs and outputs
443   model->identifyInputsAndOutputs(
444     {input01},
445     {output02});
446   // Phase 4: set relaxed execution
447   model->relaxComputationFloat32toFloat16(true);
448   assert(model->isValid());
449 }
450 
is_ignored_dynamic_output_shape_relaxed_4(int i)451 inline bool is_ignored_dynamic_output_shape_relaxed_4(int i) {
452   static std::set<int> ignore = {};
453   return ignore.find(i) != ignore.end();
454 }
455 
CreateModel_8(Model * model)456 void CreateModel_8(Model *model) {
457   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
458   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
459   // Phase 1, operands
460   auto input01 = model->addOperand(&type1);
461   auto output03 = model->addOperand(&type3);
462   // Phase 2, operations
463   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output03});
464   // Phase 3, inputs and outputs
465   model->identifyInputsAndOutputs(
466     {input01},
467     {output03});
468   assert(model->isValid());
469 }
470 
is_ignored_8(int i)471 inline bool is_ignored_8(int i) {
472   static std::set<int> ignore = {};
473   return ignore.find(i) != ignore.end();
474 }
475 
CreateModel_relaxed_5(Model * model)476 void CreateModel_relaxed_5(Model *model) {
477   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
478   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
479   // Phase 1, operands
480   auto input01 = model->addOperand(&type1);
481   auto output03 = model->addOperand(&type3);
482   // Phase 2, operations
483   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output03});
484   // Phase 3, inputs and outputs
485   model->identifyInputsAndOutputs(
486     {input01},
487     {output03});
488   // Phase 4: set relaxed execution
489   model->relaxComputationFloat32toFloat16(true);
490   assert(model->isValid());
491 }
492 
is_ignored_relaxed_5(int i)493 inline bool is_ignored_relaxed_5(int i) {
494   static std::set<int> ignore = {};
495   return ignore.find(i) != ignore.end();
496 }
497 
CreateModel_dynamic_output_shape_8(Model * model)498 void CreateModel_dynamic_output_shape_8(Model *model) {
499   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
500   OperandType type11(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 4.0f, 100);
501   // Phase 1, operands
502   auto input01 = model->addOperand(&type1);
503   auto output03 = model->addOperand(&type11);
504   // Phase 2, operations
505   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output03});
506   // Phase 3, inputs and outputs
507   model->identifyInputsAndOutputs(
508     {input01},
509     {output03});
510   assert(model->isValid());
511 }
512 
is_ignored_dynamic_output_shape_8(int i)513 inline bool is_ignored_dynamic_output_shape_8(int i) {
514   static std::set<int> ignore = {};
515   return ignore.find(i) != ignore.end();
516 }
517 
CreateModel_dynamic_output_shape_relaxed_5(Model * model)518 void CreateModel_dynamic_output_shape_relaxed_5(Model *model) {
519   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
520   OperandType type11(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 4.0f, 100);
521   // Phase 1, operands
522   auto input01 = model->addOperand(&type1);
523   auto output03 = model->addOperand(&type11);
524   // Phase 2, operations
525   model->addOperation(ANEURALNETWORKS_CAST, {input01}, {output03});
526   // Phase 3, inputs and outputs
527   model->identifyInputsAndOutputs(
528     {input01},
529     {output03});
530   // Phase 4: set relaxed execution
531   model->relaxComputationFloat32toFloat16(true);
532   assert(model->isValid());
533 }
534 
is_ignored_dynamic_output_shape_relaxed_5(int i)535 inline bool is_ignored_dynamic_output_shape_relaxed_5(int i) {
536   static std::set<int> ignore = {};
537   return ignore.find(i) != ignore.end();
538 }
539 
CreateModel_9(Model * model)540 void CreateModel_9(Model *model) {
541   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
542   OperandType type2(Type::TENSOR_INT32, {2, 3});
543   // Phase 1, operands
544   auto input02 = model->addOperand(&type2);
545   auto output0 = model->addOperand(&type0);
546   // Phase 2, operations
547   model->addOperation(ANEURALNETWORKS_CAST, {input02}, {output0});
548   // Phase 3, inputs and outputs
549   model->identifyInputsAndOutputs(
550     {input02},
551     {output0});
552   assert(model->isValid());
553 }
554 
is_ignored_9(int i)555 inline bool is_ignored_9(int i) {
556   static std::set<int> ignore = {};
557   return ignore.find(i) != ignore.end();
558 }
559 
CreateModel_dynamic_output_shape_9(Model * model)560 void CreateModel_dynamic_output_shape_9(Model *model) {
561   OperandType type2(Type::TENSOR_INT32, {2, 3});
562   OperandType type8(Type::TENSOR_FLOAT16, {0, 0});
563   // Phase 1, operands
564   auto input02 = model->addOperand(&type2);
565   auto output0 = model->addOperand(&type8);
566   // Phase 2, operations
567   model->addOperation(ANEURALNETWORKS_CAST, {input02}, {output0});
568   // Phase 3, inputs and outputs
569   model->identifyInputsAndOutputs(
570     {input02},
571     {output0});
572   assert(model->isValid());
573 }
574 
is_ignored_dynamic_output_shape_9(int i)575 inline bool is_ignored_dynamic_output_shape_9(int i) {
576   static std::set<int> ignore = {};
577   return ignore.find(i) != ignore.end();
578 }
579 
CreateModel_10(Model * model)580 void CreateModel_10(Model *model) {
581   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
582   OperandType type2(Type::TENSOR_INT32, {2, 3});
583   // Phase 1, operands
584   auto input02 = model->addOperand(&type2);
585   auto output01 = model->addOperand(&type1);
586   // Phase 2, operations
587   model->addOperation(ANEURALNETWORKS_CAST, {input02}, {output01});
588   // Phase 3, inputs and outputs
589   model->identifyInputsAndOutputs(
590     {input02},
591     {output01});
592   assert(model->isValid());
593 }
594 
is_ignored_10(int i)595 inline bool is_ignored_10(int i) {
596   static std::set<int> ignore = {};
597   return ignore.find(i) != ignore.end();
598 }
599 
CreateModel_relaxed_6(Model * model)600 void CreateModel_relaxed_6(Model *model) {
601   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
602   OperandType type2(Type::TENSOR_INT32, {2, 3});
603   // Phase 1, operands
604   auto input02 = model->addOperand(&type2);
605   auto output01 = model->addOperand(&type1);
606   // Phase 2, operations
607   model->addOperation(ANEURALNETWORKS_CAST, {input02}, {output01});
608   // Phase 3, inputs and outputs
609   model->identifyInputsAndOutputs(
610     {input02},
611     {output01});
612   // Phase 4: set relaxed execution
613   model->relaxComputationFloat32toFloat16(true);
614   assert(model->isValid());
615 }
616 
is_ignored_relaxed_6(int i)617 inline bool is_ignored_relaxed_6(int i) {
618   static std::set<int> ignore = {};
619   return ignore.find(i) != ignore.end();
620 }
621 
CreateModel_dynamic_output_shape_10(Model * model)622 void CreateModel_dynamic_output_shape_10(Model *model) {
623   OperandType type2(Type::TENSOR_INT32, {2, 3});
624   OperandType type9(Type::TENSOR_FLOAT32, {0, 0});
625   // Phase 1, operands
626   auto input02 = model->addOperand(&type2);
627   auto output01 = model->addOperand(&type9);
628   // Phase 2, operations
629   model->addOperation(ANEURALNETWORKS_CAST, {input02}, {output01});
630   // Phase 3, inputs and outputs
631   model->identifyInputsAndOutputs(
632     {input02},
633     {output01});
634   assert(model->isValid());
635 }
636 
is_ignored_dynamic_output_shape_10(int i)637 inline bool is_ignored_dynamic_output_shape_10(int i) {
638   static std::set<int> ignore = {};
639   return ignore.find(i) != ignore.end();
640 }
641 
CreateModel_dynamic_output_shape_relaxed_6(Model * model)642 void CreateModel_dynamic_output_shape_relaxed_6(Model *model) {
643   OperandType type2(Type::TENSOR_INT32, {2, 3});
644   OperandType type9(Type::TENSOR_FLOAT32, {0, 0});
645   // Phase 1, operands
646   auto input02 = model->addOperand(&type2);
647   auto output01 = model->addOperand(&type9);
648   // Phase 2, operations
649   model->addOperation(ANEURALNETWORKS_CAST, {input02}, {output01});
650   // Phase 3, inputs and outputs
651   model->identifyInputsAndOutputs(
652     {input02},
653     {output01});
654   // Phase 4: set relaxed execution
655   model->relaxComputationFloat32toFloat16(true);
656   assert(model->isValid());
657 }
658 
is_ignored_dynamic_output_shape_relaxed_6(int i)659 inline bool is_ignored_dynamic_output_shape_relaxed_6(int i) {
660   static std::set<int> ignore = {};
661   return ignore.find(i) != ignore.end();
662 }
663 
CreateModel_11(Model * model)664 void CreateModel_11(Model *model) {
665   OperandType type2(Type::TENSOR_INT32, {2, 3});
666   // Phase 1, operands
667   auto input02 = model->addOperand(&type2);
668   auto output02 = model->addOperand(&type2);
669   // Phase 2, operations
670   model->addOperation(ANEURALNETWORKS_CAST, {input02}, {output02});
671   // Phase 3, inputs and outputs
672   model->identifyInputsAndOutputs(
673     {input02},
674     {output02});
675   assert(model->isValid());
676 }
677 
is_ignored_11(int i)678 inline bool is_ignored_11(int i) {
679   static std::set<int> ignore = {};
680   return ignore.find(i) != ignore.end();
681 }
682 
CreateModel_dynamic_output_shape_11(Model * model)683 void CreateModel_dynamic_output_shape_11(Model *model) {
684   OperandType type10(Type::TENSOR_INT32, {0, 0});
685   OperandType type2(Type::TENSOR_INT32, {2, 3});
686   // Phase 1, operands
687   auto input02 = model->addOperand(&type2);
688   auto output02 = model->addOperand(&type10);
689   // Phase 2, operations
690   model->addOperation(ANEURALNETWORKS_CAST, {input02}, {output02});
691   // Phase 3, inputs and outputs
692   model->identifyInputsAndOutputs(
693     {input02},
694     {output02});
695   assert(model->isValid());
696 }
697 
is_ignored_dynamic_output_shape_11(int i)698 inline bool is_ignored_dynamic_output_shape_11(int i) {
699   static std::set<int> ignore = {};
700   return ignore.find(i) != ignore.end();
701 }
702 
CreateModel_12(Model * model)703 void CreateModel_12(Model *model) {
704   OperandType type2(Type::TENSOR_INT32, {2, 3});
705   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
706   // Phase 1, operands
707   auto input02 = model->addOperand(&type2);
708   auto output03 = model->addOperand(&type3);
709   // Phase 2, operations
710   model->addOperation(ANEURALNETWORKS_CAST, {input02}, {output03});
711   // Phase 3, inputs and outputs
712   model->identifyInputsAndOutputs(
713     {input02},
714     {output03});
715   assert(model->isValid());
716 }
717 
is_ignored_12(int i)718 inline bool is_ignored_12(int i) {
719   static std::set<int> ignore = {};
720   return ignore.find(i) != ignore.end();
721 }
722 
CreateModel_dynamic_output_shape_12(Model * model)723 void CreateModel_dynamic_output_shape_12(Model *model) {
724   OperandType type11(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 4.0f, 100);
725   OperandType type2(Type::TENSOR_INT32, {2, 3});
726   // Phase 1, operands
727   auto input02 = model->addOperand(&type2);
728   auto output03 = model->addOperand(&type11);
729   // Phase 2, operations
730   model->addOperation(ANEURALNETWORKS_CAST, {input02}, {output03});
731   // Phase 3, inputs and outputs
732   model->identifyInputsAndOutputs(
733     {input02},
734     {output03});
735   assert(model->isValid());
736 }
737 
is_ignored_dynamic_output_shape_12(int i)738 inline bool is_ignored_dynamic_output_shape_12(int i) {
739   static std::set<int> ignore = {};
740   return ignore.find(i) != ignore.end();
741 }
742 
CreateModel_13(Model * model)743 void CreateModel_13(Model *model) {
744   OperandType type0(Type::TENSOR_FLOAT16, {2, 3});
745   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
746   // Phase 1, operands
747   auto input03 = model->addOperand(&type3);
748   auto output0 = model->addOperand(&type0);
749   // Phase 2, operations
750   model->addOperation(ANEURALNETWORKS_CAST, {input03}, {output0});
751   // Phase 3, inputs and outputs
752   model->identifyInputsAndOutputs(
753     {input03},
754     {output0});
755   assert(model->isValid());
756 }
757 
is_ignored_13(int i)758 inline bool is_ignored_13(int i) {
759   static std::set<int> ignore = {};
760   return ignore.find(i) != ignore.end();
761 }
762 
CreateModel_dynamic_output_shape_13(Model * model)763 void CreateModel_dynamic_output_shape_13(Model *model) {
764   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
765   OperandType type8(Type::TENSOR_FLOAT16, {0, 0});
766   // Phase 1, operands
767   auto input03 = model->addOperand(&type3);
768   auto output0 = model->addOperand(&type8);
769   // Phase 2, operations
770   model->addOperation(ANEURALNETWORKS_CAST, {input03}, {output0});
771   // Phase 3, inputs and outputs
772   model->identifyInputsAndOutputs(
773     {input03},
774     {output0});
775   assert(model->isValid());
776 }
777 
is_ignored_dynamic_output_shape_13(int i)778 inline bool is_ignored_dynamic_output_shape_13(int i) {
779   static std::set<int> ignore = {};
780   return ignore.find(i) != ignore.end();
781 }
782 
CreateModel_14(Model * model)783 void CreateModel_14(Model *model) {
784   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
785   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
786   // Phase 1, operands
787   auto input03 = model->addOperand(&type3);
788   auto output01 = model->addOperand(&type1);
789   // Phase 2, operations
790   model->addOperation(ANEURALNETWORKS_CAST, {input03}, {output01});
791   // Phase 3, inputs and outputs
792   model->identifyInputsAndOutputs(
793     {input03},
794     {output01});
795   assert(model->isValid());
796 }
797 
is_ignored_14(int i)798 inline bool is_ignored_14(int i) {
799   static std::set<int> ignore = {};
800   return ignore.find(i) != ignore.end();
801 }
802 
CreateModel_relaxed_7(Model * model)803 void CreateModel_relaxed_7(Model *model) {
804   OperandType type1(Type::TENSOR_FLOAT32, {2, 3});
805   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
806   // Phase 1, operands
807   auto input03 = model->addOperand(&type3);
808   auto output01 = model->addOperand(&type1);
809   // Phase 2, operations
810   model->addOperation(ANEURALNETWORKS_CAST, {input03}, {output01});
811   // Phase 3, inputs and outputs
812   model->identifyInputsAndOutputs(
813     {input03},
814     {output01});
815   // Phase 4: set relaxed execution
816   model->relaxComputationFloat32toFloat16(true);
817   assert(model->isValid());
818 }
819 
is_ignored_relaxed_7(int i)820 inline bool is_ignored_relaxed_7(int i) {
821   static std::set<int> ignore = {};
822   return ignore.find(i) != ignore.end();
823 }
824 
CreateModel_dynamic_output_shape_14(Model * model)825 void CreateModel_dynamic_output_shape_14(Model *model) {
826   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
827   OperandType type9(Type::TENSOR_FLOAT32, {0, 0});
828   // Phase 1, operands
829   auto input03 = model->addOperand(&type3);
830   auto output01 = model->addOperand(&type9);
831   // Phase 2, operations
832   model->addOperation(ANEURALNETWORKS_CAST, {input03}, {output01});
833   // Phase 3, inputs and outputs
834   model->identifyInputsAndOutputs(
835     {input03},
836     {output01});
837   assert(model->isValid());
838 }
839 
is_ignored_dynamic_output_shape_14(int i)840 inline bool is_ignored_dynamic_output_shape_14(int i) {
841   static std::set<int> ignore = {};
842   return ignore.find(i) != ignore.end();
843 }
844 
CreateModel_dynamic_output_shape_relaxed_7(Model * model)845 void CreateModel_dynamic_output_shape_relaxed_7(Model *model) {
846   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
847   OperandType type9(Type::TENSOR_FLOAT32, {0, 0});
848   // Phase 1, operands
849   auto input03 = model->addOperand(&type3);
850   auto output01 = model->addOperand(&type9);
851   // Phase 2, operations
852   model->addOperation(ANEURALNETWORKS_CAST, {input03}, {output01});
853   // Phase 3, inputs and outputs
854   model->identifyInputsAndOutputs(
855     {input03},
856     {output01});
857   // Phase 4: set relaxed execution
858   model->relaxComputationFloat32toFloat16(true);
859   assert(model->isValid());
860 }
861 
is_ignored_dynamic_output_shape_relaxed_7(int i)862 inline bool is_ignored_dynamic_output_shape_relaxed_7(int i) {
863   static std::set<int> ignore = {};
864   return ignore.find(i) != ignore.end();
865 }
866 
CreateModel_15(Model * model)867 void CreateModel_15(Model *model) {
868   OperandType type2(Type::TENSOR_INT32, {2, 3});
869   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
870   // Phase 1, operands
871   auto input03 = model->addOperand(&type3);
872   auto output02 = model->addOperand(&type2);
873   // Phase 2, operations
874   model->addOperation(ANEURALNETWORKS_CAST, {input03}, {output02});
875   // Phase 3, inputs and outputs
876   model->identifyInputsAndOutputs(
877     {input03},
878     {output02});
879   assert(model->isValid());
880 }
881 
is_ignored_15(int i)882 inline bool is_ignored_15(int i) {
883   static std::set<int> ignore = {};
884   return ignore.find(i) != ignore.end();
885 }
886 
CreateModel_dynamic_output_shape_15(Model * model)887 void CreateModel_dynamic_output_shape_15(Model *model) {
888   OperandType type10(Type::TENSOR_INT32, {0, 0});
889   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
890   // Phase 1, operands
891   auto input03 = model->addOperand(&type3);
892   auto output02 = model->addOperand(&type10);
893   // Phase 2, operations
894   model->addOperation(ANEURALNETWORKS_CAST, {input03}, {output02});
895   // Phase 3, inputs and outputs
896   model->identifyInputsAndOutputs(
897     {input03},
898     {output02});
899   assert(model->isValid());
900 }
901 
is_ignored_dynamic_output_shape_15(int i)902 inline bool is_ignored_dynamic_output_shape_15(int i) {
903   static std::set<int> ignore = {};
904   return ignore.find(i) != ignore.end();
905 }
906 
CreateModel_16(Model * model)907 void CreateModel_16(Model *model) {
908   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
909   // Phase 1, operands
910   auto input03 = model->addOperand(&type3);
911   auto output03 = model->addOperand(&type3);
912   // Phase 2, operations
913   model->addOperation(ANEURALNETWORKS_CAST, {input03}, {output03});
914   // Phase 3, inputs and outputs
915   model->identifyInputsAndOutputs(
916     {input03},
917     {output03});
918   assert(model->isValid());
919 }
920 
is_ignored_16(int i)921 inline bool is_ignored_16(int i) {
922   static std::set<int> ignore = {};
923   return ignore.find(i) != ignore.end();
924 }
925 
CreateModel_dynamic_output_shape_16(Model * model)926 void CreateModel_dynamic_output_shape_16(Model *model) {
927   OperandType type11(Type::TENSOR_QUANT8_ASYMM, {0, 0}, 4.0f, 100);
928   OperandType type3(Type::TENSOR_QUANT8_ASYMM, {2, 3}, 4.0f, 100);
929   // Phase 1, operands
930   auto input03 = model->addOperand(&type3);
931   auto output03 = model->addOperand(&type11);
932   // Phase 2, operations
933   model->addOperation(ANEURALNETWORKS_CAST, {input03}, {output03});
934   // Phase 3, inputs and outputs
935   model->identifyInputsAndOutputs(
936     {input03},
937     {output03});
938   assert(model->isValid());
939 }
940 
is_ignored_dynamic_output_shape_16(int i)941 inline bool is_ignored_dynamic_output_shape_16(int i) {
942   static std::set<int> ignore = {};
943   return ignore.find(i) != ignore.end();
944 }
945 
CreateModel_17(Model * model)946 void CreateModel_17(Model *model) {
947   OperandType type4(Type::TENSOR_FLOAT16, {2});
948   OperandType type7(Type::TENSOR_QUANT8_ASYMM, {2}, 4.0f, 100);
949   // Phase 1, operands
950   auto input04 = model->addOperand(&type4);
951   auto output04 = model->addOperand(&type7);
952   // Phase 2, operations
953   model->addOperation(ANEURALNETWORKS_CAST, {input04}, {output04});
954   // Phase 3, inputs and outputs
955   model->identifyInputsAndOutputs(
956     {input04},
957     {output04});
958   assert(model->isValid());
959 }
960 
is_ignored_17(int i)961 inline bool is_ignored_17(int i) {
962   static std::set<int> ignore = {};
963   return ignore.find(i) != ignore.end();
964 }
965 
CreateModel_dynamic_output_shape_17(Model * model)966 void CreateModel_dynamic_output_shape_17(Model *model) {
967   OperandType type12(Type::TENSOR_QUANT8_ASYMM, {0}, 4.0f, 100);
968   OperandType type4(Type::TENSOR_FLOAT16, {2});
969   // Phase 1, operands
970   auto input04 = model->addOperand(&type4);
971   auto output04 = model->addOperand(&type12);
972   // Phase 2, operations
973   model->addOperation(ANEURALNETWORKS_CAST, {input04}, {output04});
974   // Phase 3, inputs and outputs
975   model->identifyInputsAndOutputs(
976     {input04},
977     {output04});
978   assert(model->isValid());
979 }
980 
is_ignored_dynamic_output_shape_17(int i)981 inline bool is_ignored_dynamic_output_shape_17(int i) {
982   static std::set<int> ignore = {};
983   return ignore.find(i) != ignore.end();
984 }
985 
CreateModel_18(Model * model)986 void CreateModel_18(Model *model) {
987   OperandType type5(Type::TENSOR_FLOAT32, {2});
988   OperandType type7(Type::TENSOR_QUANT8_ASYMM, {2}, 4.0f, 100);
989   // Phase 1, operands
990   auto input05 = model->addOperand(&type5);
991   auto output05 = model->addOperand(&type7);
992   // Phase 2, operations
993   model->addOperation(ANEURALNETWORKS_CAST, {input05}, {output05});
994   // Phase 3, inputs and outputs
995   model->identifyInputsAndOutputs(
996     {input05},
997     {output05});
998   assert(model->isValid());
999 }
1000 
is_ignored_18(int i)1001 inline bool is_ignored_18(int i) {
1002   static std::set<int> ignore = {};
1003   return ignore.find(i) != ignore.end();
1004 }
1005 
CreateModel_relaxed_8(Model * model)1006 void CreateModel_relaxed_8(Model *model) {
1007   OperandType type5(Type::TENSOR_FLOAT32, {2});
1008   OperandType type7(Type::TENSOR_QUANT8_ASYMM, {2}, 4.0f, 100);
1009   // Phase 1, operands
1010   auto input05 = model->addOperand(&type5);
1011   auto output05 = model->addOperand(&type7);
1012   // Phase 2, operations
1013   model->addOperation(ANEURALNETWORKS_CAST, {input05}, {output05});
1014   // Phase 3, inputs and outputs
1015   model->identifyInputsAndOutputs(
1016     {input05},
1017     {output05});
1018   // Phase 4: set relaxed execution
1019   model->relaxComputationFloat32toFloat16(true);
1020   assert(model->isValid());
1021 }
1022 
is_ignored_relaxed_8(int i)1023 inline bool is_ignored_relaxed_8(int i) {
1024   static std::set<int> ignore = {};
1025   return ignore.find(i) != ignore.end();
1026 }
1027 
CreateModel_dynamic_output_shape_18(Model * model)1028 void CreateModel_dynamic_output_shape_18(Model *model) {
1029   OperandType type12(Type::TENSOR_QUANT8_ASYMM, {0}, 4.0f, 100);
1030   OperandType type5(Type::TENSOR_FLOAT32, {2});
1031   // Phase 1, operands
1032   auto input05 = model->addOperand(&type5);
1033   auto output05 = model->addOperand(&type12);
1034   // Phase 2, operations
1035   model->addOperation(ANEURALNETWORKS_CAST, {input05}, {output05});
1036   // Phase 3, inputs and outputs
1037   model->identifyInputsAndOutputs(
1038     {input05},
1039     {output05});
1040   assert(model->isValid());
1041 }
1042 
is_ignored_dynamic_output_shape_18(int i)1043 inline bool is_ignored_dynamic_output_shape_18(int i) {
1044   static std::set<int> ignore = {};
1045   return ignore.find(i) != ignore.end();
1046 }
1047 
CreateModel_dynamic_output_shape_relaxed_8(Model * model)1048 void CreateModel_dynamic_output_shape_relaxed_8(Model *model) {
1049   OperandType type12(Type::TENSOR_QUANT8_ASYMM, {0}, 4.0f, 100);
1050   OperandType type5(Type::TENSOR_FLOAT32, {2});
1051   // Phase 1, operands
1052   auto input05 = model->addOperand(&type5);
1053   auto output05 = model->addOperand(&type12);
1054   // Phase 2, operations
1055   model->addOperation(ANEURALNETWORKS_CAST, {input05}, {output05});
1056   // Phase 3, inputs and outputs
1057   model->identifyInputsAndOutputs(
1058     {input05},
1059     {output05});
1060   // Phase 4: set relaxed execution
1061   model->relaxComputationFloat32toFloat16(true);
1062   assert(model->isValid());
1063 }
1064 
is_ignored_dynamic_output_shape_relaxed_8(int i)1065 inline bool is_ignored_dynamic_output_shape_relaxed_8(int i) {
1066   static std::set<int> ignore = {};
1067   return ignore.find(i) != ignore.end();
1068 }
1069 
CreateModel_19(Model * model)1070 void CreateModel_19(Model *model) {
1071   OperandType type6(Type::TENSOR_INT32, {2});
1072   OperandType type7(Type::TENSOR_QUANT8_ASYMM, {2}, 4.0f, 100);
1073   // Phase 1, operands
1074   auto input06 = model->addOperand(&type6);
1075   auto output06 = model->addOperand(&type7);
1076   // Phase 2, operations
1077   model->addOperation(ANEURALNETWORKS_CAST, {input06}, {output06});
1078   // Phase 3, inputs and outputs
1079   model->identifyInputsAndOutputs(
1080     {input06},
1081     {output06});
1082   assert(model->isValid());
1083 }
1084 
is_ignored_19(int i)1085 inline bool is_ignored_19(int i) {
1086   static std::set<int> ignore = {};
1087   return ignore.find(i) != ignore.end();
1088 }
1089 
CreateModel_dynamic_output_shape_19(Model * model)1090 void CreateModel_dynamic_output_shape_19(Model *model) {
1091   OperandType type12(Type::TENSOR_QUANT8_ASYMM, {0}, 4.0f, 100);
1092   OperandType type6(Type::TENSOR_INT32, {2});
1093   // Phase 1, operands
1094   auto input06 = model->addOperand(&type6);
1095   auto output06 = model->addOperand(&type12);
1096   // Phase 2, operations
1097   model->addOperation(ANEURALNETWORKS_CAST, {input06}, {output06});
1098   // Phase 3, inputs and outputs
1099   model->identifyInputsAndOutputs(
1100     {input06},
1101     {output06});
1102   assert(model->isValid());
1103 }
1104 
is_ignored_dynamic_output_shape_19(int i)1105 inline bool is_ignored_dynamic_output_shape_19(int i) {
1106   static std::set<int> ignore = {};
1107   return ignore.find(i) != ignore.end();
1108 }
1109 
1110