1 // clang-format off
2 // Generated file (from: greater.mod.py). Do not edit
CreateModel(Model * model)3 void CreateModel(Model *model) {
4   OperandType type0(Type::TENSOR_FLOAT32, {3});
5   OperandType type1(Type::TENSOR_BOOL8, {3});
6   // Phase 1, operands
7   auto input0 = model->addOperand(&type0);
8   auto input1 = model->addOperand(&type0);
9   auto output0 = model->addOperand(&type1);
10   // Phase 2, operations
11   model->addOperation(ANEURALNETWORKS_GREATER, {input0, input1}, {output0});
12   // Phase 3, inputs and outputs
13   model->identifyInputsAndOutputs(
14     {input0, input1},
15     {output0});
16   assert(model->isValid());
17 }
18 
is_ignored(int i)19 inline bool is_ignored(int i) {
20   static std::set<int> ignore = {};
21   return ignore.find(i) != ignore.end();
22 }
23 
CreateModel_int32(Model * model)24 void CreateModel_int32(Model *model) {
25   OperandType type1(Type::TENSOR_BOOL8, {3});
26   OperandType type12(Type::TENSOR_INT32, {3});
27   // Phase 1, operands
28   auto input0 = model->addOperand(&type12);
29   auto input1 = model->addOperand(&type12);
30   auto output0 = model->addOperand(&type1);
31   // Phase 2, operations
32   model->addOperation(ANEURALNETWORKS_GREATER, {input0, input1}, {output0});
33   // Phase 3, inputs and outputs
34   model->identifyInputsAndOutputs(
35     {input0, input1},
36     {output0});
37   assert(model->isValid());
38 }
39 
is_ignored_int32(int i)40 inline bool is_ignored_int32(int i) {
41   static std::set<int> ignore = {};
42   return ignore.find(i) != ignore.end();
43 }
44 
CreateModel_float16(Model * model)45 void CreateModel_float16(Model *model) {
46   OperandType type1(Type::TENSOR_BOOL8, {3});
47   OperandType type13(Type::TENSOR_FLOAT16, {3});
48   // Phase 1, operands
49   auto input0 = model->addOperand(&type13);
50   auto input1 = model->addOperand(&type13);
51   auto output0 = model->addOperand(&type1);
52   // Phase 2, operations
53   model->addOperation(ANEURALNETWORKS_GREATER, {input0, input1}, {output0});
54   // Phase 3, inputs and outputs
55   model->identifyInputsAndOutputs(
56     {input0, input1},
57     {output0});
58   assert(model->isValid());
59 }
60 
is_ignored_float16(int i)61 inline bool is_ignored_float16(int i) {
62   static std::set<int> ignore = {};
63   return ignore.find(i) != ignore.end();
64 }
65 
CreateModel_relaxed(Model * model)66 void CreateModel_relaxed(Model *model) {
67   OperandType type0(Type::TENSOR_FLOAT32, {3});
68   OperandType type1(Type::TENSOR_BOOL8, {3});
69   // Phase 1, operands
70   auto input0 = model->addOperand(&type0);
71   auto input1 = model->addOperand(&type0);
72   auto output0 = model->addOperand(&type1);
73   // Phase 2, operations
74   model->addOperation(ANEURALNETWORKS_GREATER, {input0, input1}, {output0});
75   // Phase 3, inputs and outputs
76   model->identifyInputsAndOutputs(
77     {input0, input1},
78     {output0});
79   // Phase 4: set relaxed execution
80   model->relaxComputationFloat32toFloat16(true);
81   assert(model->isValid());
82 }
83 
is_ignored_relaxed(int i)84 inline bool is_ignored_relaxed(int i) {
85   static std::set<int> ignore = {};
86   return ignore.find(i) != ignore.end();
87 }
88 
CreateModel_dynamic_output_shape(Model * model)89 void CreateModel_dynamic_output_shape(Model *model) {
90   OperandType type0(Type::TENSOR_FLOAT32, {3});
91   OperandType type14(Type::TENSOR_BOOL8, {0});
92   // Phase 1, operands
93   auto input0 = model->addOperand(&type0);
94   auto input1 = model->addOperand(&type0);
95   auto output0 = model->addOperand(&type14);
96   // Phase 2, operations
97   model->addOperation(ANEURALNETWORKS_GREATER, {input0, input1}, {output0});
98   // Phase 3, inputs and outputs
99   model->identifyInputsAndOutputs(
100     {input0, input1},
101     {output0});
102   assert(model->isValid());
103 }
104 
is_ignored_dynamic_output_shape(int i)105 inline bool is_ignored_dynamic_output_shape(int i) {
106   static std::set<int> ignore = {};
107   return ignore.find(i) != ignore.end();
108 }
109 
CreateModel_dynamic_output_shape_int32(Model * model)110 void CreateModel_dynamic_output_shape_int32(Model *model) {
111   OperandType type12(Type::TENSOR_INT32, {3});
112   OperandType type14(Type::TENSOR_BOOL8, {0});
113   // Phase 1, operands
114   auto input0 = model->addOperand(&type12);
115   auto input1 = model->addOperand(&type12);
116   auto output0 = model->addOperand(&type14);
117   // Phase 2, operations
118   model->addOperation(ANEURALNETWORKS_GREATER, {input0, input1}, {output0});
119   // Phase 3, inputs and outputs
120   model->identifyInputsAndOutputs(
121     {input0, input1},
122     {output0});
123   assert(model->isValid());
124 }
125 
is_ignored_dynamic_output_shape_int32(int i)126 inline bool is_ignored_dynamic_output_shape_int32(int i) {
127   static std::set<int> ignore = {};
128   return ignore.find(i) != ignore.end();
129 }
130 
CreateModel_dynamic_output_shape_float16(Model * model)131 void CreateModel_dynamic_output_shape_float16(Model *model) {
132   OperandType type13(Type::TENSOR_FLOAT16, {3});
133   OperandType type14(Type::TENSOR_BOOL8, {0});
134   // Phase 1, operands
135   auto input0 = model->addOperand(&type13);
136   auto input1 = model->addOperand(&type13);
137   auto output0 = model->addOperand(&type14);
138   // Phase 2, operations
139   model->addOperation(ANEURALNETWORKS_GREATER, {input0, input1}, {output0});
140   // Phase 3, inputs and outputs
141   model->identifyInputsAndOutputs(
142     {input0, input1},
143     {output0});
144   assert(model->isValid());
145 }
146 
is_ignored_dynamic_output_shape_float16(int i)147 inline bool is_ignored_dynamic_output_shape_float16(int i) {
148   static std::set<int> ignore = {};
149   return ignore.find(i) != ignore.end();
150 }
151 
CreateModel_dynamic_output_shape_relaxed(Model * model)152 void CreateModel_dynamic_output_shape_relaxed(Model *model) {
153   OperandType type0(Type::TENSOR_FLOAT32, {3});
154   OperandType type14(Type::TENSOR_BOOL8, {0});
155   // Phase 1, operands
156   auto input0 = model->addOperand(&type0);
157   auto input1 = model->addOperand(&type0);
158   auto output0 = model->addOperand(&type14);
159   // Phase 2, operations
160   model->addOperation(ANEURALNETWORKS_GREATER, {input0, input1}, {output0});
161   // Phase 3, inputs and outputs
162   model->identifyInputsAndOutputs(
163     {input0, input1},
164     {output0});
165   // Phase 4: set relaxed execution
166   model->relaxComputationFloat32toFloat16(true);
167   assert(model->isValid());
168 }
169 
is_ignored_dynamic_output_shape_relaxed(int i)170 inline bool is_ignored_dynamic_output_shape_relaxed(int i) {
171   static std::set<int> ignore = {};
172   return ignore.find(i) != ignore.end();
173 }
174 
CreateModel_2(Model * model)175 void CreateModel_2(Model *model) {
176   OperandType type2(Type::TENSOR_FLOAT32, {2, 1});
177   OperandType type3(Type::TENSOR_FLOAT32, {2});
178   OperandType type4(Type::TENSOR_BOOL8, {2, 2});
179   // Phase 1, operands
180   auto input01 = model->addOperand(&type2);
181   auto input11 = model->addOperand(&type3);
182   auto output01 = model->addOperand(&type4);
183   // Phase 2, operations
184   model->addOperation(ANEURALNETWORKS_GREATER, {input01, input11}, {output01});
185   // Phase 3, inputs and outputs
186   model->identifyInputsAndOutputs(
187     {input01, input11},
188     {output01});
189   assert(model->isValid());
190 }
191 
is_ignored_2(int i)192 inline bool is_ignored_2(int i) {
193   static std::set<int> ignore = {};
194   return ignore.find(i) != ignore.end();
195 }
196 
CreateModel_int32_2(Model * model)197 void CreateModel_int32_2(Model *model) {
198   OperandType type15(Type::TENSOR_INT32, {2, 1});
199   OperandType type16(Type::TENSOR_INT32, {2});
200   OperandType type4(Type::TENSOR_BOOL8, {2, 2});
201   // Phase 1, operands
202   auto input01 = model->addOperand(&type15);
203   auto input11 = model->addOperand(&type16);
204   auto output01 = model->addOperand(&type4);
205   // Phase 2, operations
206   model->addOperation(ANEURALNETWORKS_GREATER, {input01, input11}, {output01});
207   // Phase 3, inputs and outputs
208   model->identifyInputsAndOutputs(
209     {input01, input11},
210     {output01});
211   assert(model->isValid());
212 }
213 
is_ignored_int32_2(int i)214 inline bool is_ignored_int32_2(int i) {
215   static std::set<int> ignore = {};
216   return ignore.find(i) != ignore.end();
217 }
218 
CreateModel_float16_2(Model * model)219 void CreateModel_float16_2(Model *model) {
220   OperandType type17(Type::TENSOR_FLOAT16, {2, 1});
221   OperandType type18(Type::TENSOR_FLOAT16, {2});
222   OperandType type4(Type::TENSOR_BOOL8, {2, 2});
223   // Phase 1, operands
224   auto input01 = model->addOperand(&type17);
225   auto input11 = model->addOperand(&type18);
226   auto output01 = model->addOperand(&type4);
227   // Phase 2, operations
228   model->addOperation(ANEURALNETWORKS_GREATER, {input01, input11}, {output01});
229   // Phase 3, inputs and outputs
230   model->identifyInputsAndOutputs(
231     {input01, input11},
232     {output01});
233   assert(model->isValid());
234 }
235 
is_ignored_float16_2(int i)236 inline bool is_ignored_float16_2(int i) {
237   static std::set<int> ignore = {};
238   return ignore.find(i) != ignore.end();
239 }
240 
CreateModel_relaxed_2(Model * model)241 void CreateModel_relaxed_2(Model *model) {
242   OperandType type2(Type::TENSOR_FLOAT32, {2, 1});
243   OperandType type3(Type::TENSOR_FLOAT32, {2});
244   OperandType type4(Type::TENSOR_BOOL8, {2, 2});
245   // Phase 1, operands
246   auto input01 = model->addOperand(&type2);
247   auto input11 = model->addOperand(&type3);
248   auto output01 = model->addOperand(&type4);
249   // Phase 2, operations
250   model->addOperation(ANEURALNETWORKS_GREATER, {input01, input11}, {output01});
251   // Phase 3, inputs and outputs
252   model->identifyInputsAndOutputs(
253     {input01, input11},
254     {output01});
255   // Phase 4: set relaxed execution
256   model->relaxComputationFloat32toFloat16(true);
257   assert(model->isValid());
258 }
259 
is_ignored_relaxed_2(int i)260 inline bool is_ignored_relaxed_2(int i) {
261   static std::set<int> ignore = {};
262   return ignore.find(i) != ignore.end();
263 }
264 
CreateModel_dynamic_output_shape_2(Model * model)265 void CreateModel_dynamic_output_shape_2(Model *model) {
266   OperandType type19(Type::TENSOR_BOOL8, {0, 0});
267   OperandType type2(Type::TENSOR_FLOAT32, {2, 1});
268   OperandType type3(Type::TENSOR_FLOAT32, {2});
269   // Phase 1, operands
270   auto input01 = model->addOperand(&type2);
271   auto input11 = model->addOperand(&type3);
272   auto output01 = model->addOperand(&type19);
273   // Phase 2, operations
274   model->addOperation(ANEURALNETWORKS_GREATER, {input01, input11}, {output01});
275   // Phase 3, inputs and outputs
276   model->identifyInputsAndOutputs(
277     {input01, input11},
278     {output01});
279   assert(model->isValid());
280 }
281 
is_ignored_dynamic_output_shape_2(int i)282 inline bool is_ignored_dynamic_output_shape_2(int i) {
283   static std::set<int> ignore = {};
284   return ignore.find(i) != ignore.end();
285 }
286 
CreateModel_dynamic_output_shape_int32_2(Model * model)287 void CreateModel_dynamic_output_shape_int32_2(Model *model) {
288   OperandType type15(Type::TENSOR_INT32, {2, 1});
289   OperandType type16(Type::TENSOR_INT32, {2});
290   OperandType type19(Type::TENSOR_BOOL8, {0, 0});
291   // Phase 1, operands
292   auto input01 = model->addOperand(&type15);
293   auto input11 = model->addOperand(&type16);
294   auto output01 = model->addOperand(&type19);
295   // Phase 2, operations
296   model->addOperation(ANEURALNETWORKS_GREATER, {input01, input11}, {output01});
297   // Phase 3, inputs and outputs
298   model->identifyInputsAndOutputs(
299     {input01, input11},
300     {output01});
301   assert(model->isValid());
302 }
303 
is_ignored_dynamic_output_shape_int32_2(int i)304 inline bool is_ignored_dynamic_output_shape_int32_2(int i) {
305   static std::set<int> ignore = {};
306   return ignore.find(i) != ignore.end();
307 }
308 
CreateModel_dynamic_output_shape_float16_2(Model * model)309 void CreateModel_dynamic_output_shape_float16_2(Model *model) {
310   OperandType type17(Type::TENSOR_FLOAT16, {2, 1});
311   OperandType type18(Type::TENSOR_FLOAT16, {2});
312   OperandType type19(Type::TENSOR_BOOL8, {0, 0});
313   // Phase 1, operands
314   auto input01 = model->addOperand(&type17);
315   auto input11 = model->addOperand(&type18);
316   auto output01 = model->addOperand(&type19);
317   // Phase 2, operations
318   model->addOperation(ANEURALNETWORKS_GREATER, {input01, input11}, {output01});
319   // Phase 3, inputs and outputs
320   model->identifyInputsAndOutputs(
321     {input01, input11},
322     {output01});
323   assert(model->isValid());
324 }
325 
is_ignored_dynamic_output_shape_float16_2(int i)326 inline bool is_ignored_dynamic_output_shape_float16_2(int i) {
327   static std::set<int> ignore = {};
328   return ignore.find(i) != ignore.end();
329 }
330 
CreateModel_dynamic_output_shape_relaxed_2(Model * model)331 void CreateModel_dynamic_output_shape_relaxed_2(Model *model) {
332   OperandType type19(Type::TENSOR_BOOL8, {0, 0});
333   OperandType type2(Type::TENSOR_FLOAT32, {2, 1});
334   OperandType type3(Type::TENSOR_FLOAT32, {2});
335   // Phase 1, operands
336   auto input01 = model->addOperand(&type2);
337   auto input11 = model->addOperand(&type3);
338   auto output01 = model->addOperand(&type19);
339   // Phase 2, operations
340   model->addOperation(ANEURALNETWORKS_GREATER, {input01, input11}, {output01});
341   // Phase 3, inputs and outputs
342   model->identifyInputsAndOutputs(
343     {input01, input11},
344     {output01});
345   // Phase 4: set relaxed execution
346   model->relaxComputationFloat32toFloat16(true);
347   assert(model->isValid());
348 }
349 
is_ignored_dynamic_output_shape_relaxed_2(int i)350 inline bool is_ignored_dynamic_output_shape_relaxed_2(int i) {
351   static std::set<int> ignore = {};
352   return ignore.find(i) != ignore.end();
353 }
354 
CreateModel_3(Model * model)355 void CreateModel_3(Model *model) {
356   OperandType type1(Type::TENSOR_BOOL8, {3});
357   OperandType type5(Type::TENSOR_QUANT8_ASYMM, {3}, 1.0f, 128);
358   OperandType type6(Type::TENSOR_QUANT8_ASYMM, {1}, 2.0f, 128);
359   // Phase 1, operands
360   auto input02 = model->addOperand(&type5);
361   auto input12 = model->addOperand(&type6);
362   auto output02 = model->addOperand(&type1);
363   // Phase 2, operations
364   model->addOperation(ANEURALNETWORKS_GREATER, {input02, input12}, {output02});
365   // Phase 3, inputs and outputs
366   model->identifyInputsAndOutputs(
367     {input02, input12},
368     {output02});
369   assert(model->isValid());
370 }
371 
is_ignored_3(int i)372 inline bool is_ignored_3(int i) {
373   static std::set<int> ignore = {};
374   return ignore.find(i) != ignore.end();
375 }
376 
CreateModel_dynamic_output_shape_3(Model * model)377 void CreateModel_dynamic_output_shape_3(Model *model) {
378   OperandType type14(Type::TENSOR_BOOL8, {0});
379   OperandType type5(Type::TENSOR_QUANT8_ASYMM, {3}, 1.0f, 128);
380   OperandType type6(Type::TENSOR_QUANT8_ASYMM, {1}, 2.0f, 128);
381   // Phase 1, operands
382   auto input02 = model->addOperand(&type5);
383   auto input12 = model->addOperand(&type6);
384   auto output02 = model->addOperand(&type14);
385   // Phase 2, operations
386   model->addOperation(ANEURALNETWORKS_GREATER, {input02, input12}, {output02});
387   // Phase 3, inputs and outputs
388   model->identifyInputsAndOutputs(
389     {input02, input12},
390     {output02});
391   assert(model->isValid());
392 }
393 
is_ignored_dynamic_output_shape_3(int i)394 inline bool is_ignored_dynamic_output_shape_3(int i) {
395   static std::set<int> ignore = {};
396   return ignore.find(i) != ignore.end();
397 }
398 
CreateModel_4(Model * model)399 void CreateModel_4(Model *model) {
400   OperandType type1(Type::TENSOR_BOOL8, {3});
401   OperandType type5(Type::TENSOR_QUANT8_ASYMM, {3}, 1.0f, 128);
402   OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1}, 1.0f, 129);
403   // Phase 1, operands
404   auto input03 = model->addOperand(&type5);
405   auto input13 = model->addOperand(&type7);
406   auto output03 = model->addOperand(&type1);
407   // Phase 2, operations
408   model->addOperation(ANEURALNETWORKS_GREATER, {input03, input13}, {output03});
409   // Phase 3, inputs and outputs
410   model->identifyInputsAndOutputs(
411     {input03, input13},
412     {output03});
413   assert(model->isValid());
414 }
415 
is_ignored_4(int i)416 inline bool is_ignored_4(int i) {
417   static std::set<int> ignore = {};
418   return ignore.find(i) != ignore.end();
419 }
420 
CreateModel_dynamic_output_shape_4(Model * model)421 void CreateModel_dynamic_output_shape_4(Model *model) {
422   OperandType type14(Type::TENSOR_BOOL8, {0});
423   OperandType type5(Type::TENSOR_QUANT8_ASYMM, {3}, 1.0f, 128);
424   OperandType type7(Type::TENSOR_QUANT8_ASYMM, {1}, 1.0f, 129);
425   // Phase 1, operands
426   auto input03 = model->addOperand(&type5);
427   auto input13 = model->addOperand(&type7);
428   auto output03 = model->addOperand(&type14);
429   // Phase 2, operations
430   model->addOperation(ANEURALNETWORKS_GREATER, {input03, input13}, {output03});
431   // Phase 3, inputs and outputs
432   model->identifyInputsAndOutputs(
433     {input03, input13},
434     {output03});
435   assert(model->isValid());
436 }
437 
is_ignored_dynamic_output_shape_4(int i)438 inline bool is_ignored_dynamic_output_shape_4(int i) {
439   static std::set<int> ignore = {};
440   return ignore.find(i) != ignore.end();
441 }
442 
CreateModel_5(Model * model)443 void CreateModel_5(Model *model) {
444   OperandType type10(Type::TENSOR_BOOL8, {1});
445   OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1}, 1.64771f, 31);
446   OperandType type9(Type::TENSOR_QUANT8_ASYMM, {1}, 1.49725f, 240);
447   // Phase 1, operands
448   auto input04 = model->addOperand(&type8);
449   auto input14 = model->addOperand(&type9);
450   auto output04 = model->addOperand(&type10);
451   // Phase 2, operations
452   model->addOperation(ANEURALNETWORKS_GREATER, {input04, input14}, {output04});
453   // Phase 3, inputs and outputs
454   model->identifyInputsAndOutputs(
455     {input04, input14},
456     {output04});
457   assert(model->isValid());
458 }
459 
is_ignored_5(int i)460 inline bool is_ignored_5(int i) {
461   static std::set<int> ignore = {};
462   return ignore.find(i) != ignore.end();
463 }
464 
CreateModel_dynamic_output_shape_5(Model * model)465 void CreateModel_dynamic_output_shape_5(Model *model) {
466   OperandType type14(Type::TENSOR_BOOL8, {0});
467   OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1}, 1.64771f, 31);
468   OperandType type9(Type::TENSOR_QUANT8_ASYMM, {1}, 1.49725f, 240);
469   // Phase 1, operands
470   auto input04 = model->addOperand(&type8);
471   auto input14 = model->addOperand(&type9);
472   auto output04 = model->addOperand(&type14);
473   // Phase 2, operations
474   model->addOperation(ANEURALNETWORKS_GREATER, {input04, input14}, {output04});
475   // Phase 3, inputs and outputs
476   model->identifyInputsAndOutputs(
477     {input04, input14},
478     {output04});
479   assert(model->isValid());
480 }
481 
is_ignored_dynamic_output_shape_5(int i)482 inline bool is_ignored_dynamic_output_shape_5(int i) {
483   static std::set<int> ignore = {};
484   return ignore.find(i) != ignore.end();
485 }
486 
CreateModel_6(Model * model)487 void CreateModel_6(Model *model) {
488   OperandType type10(Type::TENSOR_BOOL8, {1});
489   OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1}, 1.64771f, 31);
490   OperandType type9(Type::TENSOR_QUANT8_ASYMM, {1}, 1.49725f, 240);
491   // Phase 1, operands
492   auto input05 = model->addOperand(&type9);
493   auto input15 = model->addOperand(&type8);
494   auto output05 = model->addOperand(&type10);
495   // Phase 2, operations
496   model->addOperation(ANEURALNETWORKS_GREATER, {input05, input15}, {output05});
497   // Phase 3, inputs and outputs
498   model->identifyInputsAndOutputs(
499     {input05, input15},
500     {output05});
501   assert(model->isValid());
502 }
503 
is_ignored_6(int i)504 inline bool is_ignored_6(int i) {
505   static std::set<int> ignore = {};
506   return ignore.find(i) != ignore.end();
507 }
508 
CreateModel_dynamic_output_shape_6(Model * model)509 void CreateModel_dynamic_output_shape_6(Model *model) {
510   OperandType type14(Type::TENSOR_BOOL8, {0});
511   OperandType type8(Type::TENSOR_QUANT8_ASYMM, {1}, 1.64771f, 31);
512   OperandType type9(Type::TENSOR_QUANT8_ASYMM, {1}, 1.49725f, 240);
513   // Phase 1, operands
514   auto input05 = model->addOperand(&type9);
515   auto input15 = model->addOperand(&type8);
516   auto output05 = model->addOperand(&type14);
517   // Phase 2, operations
518   model->addOperation(ANEURALNETWORKS_GREATER, {input05, input15}, {output05});
519   // Phase 3, inputs and outputs
520   model->identifyInputsAndOutputs(
521     {input05, input15},
522     {output05});
523   assert(model->isValid());
524 }
525 
is_ignored_dynamic_output_shape_6(int i)526 inline bool is_ignored_dynamic_output_shape_6(int i) {
527   static std::set<int> ignore = {};
528   return ignore.find(i) != ignore.end();
529 }
530 
CreateModel_7(Model * model)531 void CreateModel_7(Model *model) {
532   OperandType type11(Type::TENSOR_BOOL8, {4});
533   // Phase 1, operands
534   auto input06 = model->addOperand(&type11);
535   auto input16 = model->addOperand(&type11);
536   auto output06 = model->addOperand(&type11);
537   // Phase 2, operations
538   model->addOperation(ANEURALNETWORKS_GREATER, {input06, input16}, {output06});
539   // Phase 3, inputs and outputs
540   model->identifyInputsAndOutputs(
541     {input06, input16},
542     {output06});
543   assert(model->isValid());
544 }
545 
is_ignored_7(int i)546 inline bool is_ignored_7(int i) {
547   static std::set<int> ignore = {};
548   return ignore.find(i) != ignore.end();
549 }
550 
CreateModel_dynamic_output_shape_7(Model * model)551 void CreateModel_dynamic_output_shape_7(Model *model) {
552   OperandType type11(Type::TENSOR_BOOL8, {4});
553   OperandType type14(Type::TENSOR_BOOL8, {0});
554   // Phase 1, operands
555   auto input06 = model->addOperand(&type11);
556   auto input16 = model->addOperand(&type11);
557   auto output06 = model->addOperand(&type14);
558   // Phase 2, operations
559   model->addOperation(ANEURALNETWORKS_GREATER, {input06, input16}, {output06});
560   // Phase 3, inputs and outputs
561   model->identifyInputsAndOutputs(
562     {input06, input16},
563     {output06});
564   assert(model->isValid());
565 }
566 
is_ignored_dynamic_output_shape_7(int i)567 inline bool is_ignored_dynamic_output_shape_7(int i) {
568   static std::set<int> ignore = {};
569   return ignore.find(i) != ignore.end();
570 }
571 
572