1 files changed, 2100 insertions, 1 deletions
diff --git a/runtimes/tests/neural_networks_test/generated/all_generated_tests.cpp b/runtimes/tests/neural_networks_test/generated/all_generated_tests.cpp
index 4dc3d5935..e163b602f 100644
--- a/runtimes/tests/neural_networks_test/generated/all_generated_tests.cpp
+++ b/runtimes/tests/neural_networks_test/generated/all_generated_tests.cpp
@@ -1,5 +1,5 @@
 // DO NOT EDIT;
-// Generated by ml/nn/runtime/test/specs/generate_test.sh
+// Generated by nnfw/runtimes/tests/neural_networks_test/specs/generate_test.sh
 
 namespace add_broadcast_quant8 {
 std::vector<MixedTypedExample> examples = {
@@ -57,6 +57,20 @@ TEST_F(GeneratedTests, avg_pool_float_1) {
             avg_pool_float_1::examples);
 }
 
+namespace avg_pool_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated avg_pool_float_2 test
+#include "generated/examples/avg_pool_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/avg_pool_float_2.model.cpp"
+} // namespace avg_pool_float_2
+TEST_F(GeneratedTests, avg_pool_float_2) {
+    execute(avg_pool_float_2::CreateModel,
+            avg_pool_float_2::is_ignored,
+            avg_pool_float_2::examples);
+}
+
 namespace avg_pool_float_3 {
 std::vector<MixedTypedExample> examples = {
 // Generated avg_pool_float_3 test
@@ -71,6 +85,20 @@ TEST_F(GeneratedTests, avg_pool_float_3) {
             avg_pool_float_3::examples);
 }
 
+namespace avg_pool_float_4 {
+std::vector<MixedTypedExample> examples = {
+// Generated avg_pool_float_4 test
+#include "generated/examples/avg_pool_float_4.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/avg_pool_float_4.model.cpp"
+} // namespace avg_pool_float_4
+TEST_F(GeneratedTests, avg_pool_float_4) {
+    execute(avg_pool_float_4::CreateModel,
+            avg_pool_float_4::is_ignored,
+            avg_pool_float_4::examples);
+}
+
 namespace avg_pool_float_5 {
 std::vector<MixedTypedExample> examples = {
 // Generated avg_pool_float_5 test
@@ -155,6 +183,62 @@ TEST_F(GeneratedTests, avg_pool_quant8_5) {
             avg_pool_quant8_5::examples);
 }
 
+namespace concat_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated concat_float_1 test
+#include "generated/examples/concat_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/concat_float_1.model.cpp"
+} // namespace concat_float_1
+TEST_F(GeneratedTests, concat_float_1) {
+    execute(concat_float_1::CreateModel,
+            concat_float_1::is_ignored,
+            concat_float_1::examples);
+}
+
+namespace concat_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated concat_float_2 test
+#include "generated/examples/concat_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/concat_float_2.model.cpp"
+} // namespace concat_float_2
+TEST_F(GeneratedTests, concat_float_2) {
+    execute(concat_float_2::CreateModel,
+            concat_float_2::is_ignored,
+            concat_float_2::examples);
+}
+
+namespace concat_float_3 {
+std::vector<MixedTypedExample> examples = {
+// Generated concat_float_3 test
+#include "generated/examples/concat_float_3.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/concat_float_3.model.cpp"
+} // namespace concat_float_3
+TEST_F(GeneratedTests, concat_float_3) {
+    execute(concat_float_3::CreateModel,
+            concat_float_3::is_ignored,
+            concat_float_3::examples);
+}
+
+namespace concat_float_4D_axis3_1_nnfw {
+std::vector<MixedTypedExample> examples = {
+// Generated concat_float_4D_axis3_1_nnfw test
+#include "generated/examples/concat_float_4D_axis3_1_nnfw.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/concat_float_4D_axis3_1_nnfw.model.cpp"
+} // namespace concat_float_4D_axis3_1_nnfw
+TEST_F(GeneratedTests, concat_float_4D_axis3_1_nnfw) {
+    execute(concat_float_4D_axis3_1_nnfw::CreateModel,
+            concat_float_4D_axis3_1_nnfw::is_ignored,
+            concat_float_4D_axis3_1_nnfw::examples);
+}
+
 namespace concat_quant8_1 {
 std::vector<MixedTypedExample> examples = {
 // Generated concat_quant8_1 test
@@ -477,6 +561,76 @@ TEST_F(GeneratedTests, conv_quant8_weights_as_inputs) {
             conv_quant8_weights_as_inputs::examples);
 }
 
+namespace depth_to_space_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated depth_to_space_float_1 test
+#include "generated/examples/depth_to_space_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/depth_to_space_float_1.model.cpp"
+} // namespace depth_to_space_float_1
+TEST_F(GeneratedTests, depth_to_space_float_1) {
+    execute(depth_to_space_float_1::CreateModel,
+            depth_to_space_float_1::is_ignored,
+            depth_to_space_float_1::examples);
+}
+
+namespace depth_to_space_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated depth_to_space_float_2 test
+#include "generated/examples/depth_to_space_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/depth_to_space_float_2.model.cpp"
+} // namespace depth_to_space_float_2
+TEST_F(GeneratedTests, depth_to_space_float_2) {
+    execute(depth_to_space_float_2::CreateModel,
+            depth_to_space_float_2::is_ignored,
+            depth_to_space_float_2::examples);
+}
+
+namespace depth_to_space_float_3 {
+std::vector<MixedTypedExample> examples = {
+// Generated depth_to_space_float_3 test
+#include "generated/examples/depth_to_space_float_3.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/depth_to_space_float_3.model.cpp"
+} // namespace depth_to_space_float_3
+TEST_F(GeneratedTests, depth_to_space_float_3) {
+    execute(depth_to_space_float_3::CreateModel,
+            depth_to_space_float_3::is_ignored,
+            depth_to_space_float_3::examples);
+}
+
+namespace depth_to_space_quant8_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated depth_to_space_quant8_1 test
+#include "generated/examples/depth_to_space_quant8_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/depth_to_space_quant8_1.model.cpp"
+} // namespace depth_to_space_quant8_1
+TEST_F(GeneratedTests, depth_to_space_quant8_1) {
+    execute(depth_to_space_quant8_1::CreateModel,
+            depth_to_space_quant8_1::is_ignored,
+            depth_to_space_quant8_1::examples);
+}
+
+namespace depth_to_space_quant8_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated depth_to_space_quant8_2 test
+#include "generated/examples/depth_to_space_quant8_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/depth_to_space_quant8_2.model.cpp"
+} // namespace depth_to_space_quant8_2
+TEST_F(GeneratedTests, depth_to_space_quant8_2) {
+    execute(depth_to_space_quant8_2::CreateModel,
+            depth_to_space_quant8_2::is_ignored,
+            depth_to_space_quant8_2::examples);
+}
+
 namespace depthwise_conv2d_float_2 {
 std::vector<MixedTypedExample> examples = {
 // Generated depthwise_conv2d_float_2 test
@@ -575,6 +729,76 @@ TEST_F(GeneratedTests, depthwise_conv2d_float_weights_as_inputs) {
             depthwise_conv2d_float_weights_as_inputs::examples);
 }
 
+namespace depthwise_conv2d_quant8_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated depthwise_conv2d_quant8_2 test
+#include "generated/examples/depthwise_conv2d_quant8_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/depthwise_conv2d_quant8_2.model.cpp"
+} // namespace depthwise_conv2d_quant8_2
+TEST_F(GeneratedTests, depthwise_conv2d_quant8_2) {
+    execute(depthwise_conv2d_quant8_2::CreateModel,
+            depthwise_conv2d_quant8_2::is_ignored,
+            depthwise_conv2d_quant8_2::examples);
+}
+
+namespace depthwise_conv2d_quant8_large {
+std::vector<MixedTypedExample> examples = {
+// Generated depthwise_conv2d_quant8_large test
+#include "generated/examples/depthwise_conv2d_quant8_large.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/depthwise_conv2d_quant8_large.model.cpp"
+} // namespace depthwise_conv2d_quant8_large
+TEST_F(GeneratedTests, depthwise_conv2d_quant8_large) {
+    execute(depthwise_conv2d_quant8_large::CreateModel,
+            depthwise_conv2d_quant8_large::is_ignored,
+            depthwise_conv2d_quant8_large::examples);
+}
+
+namespace depthwise_conv2d_quant8_large_weights_as_inputs {
+std::vector<MixedTypedExample> examples = {
+// Generated depthwise_conv2d_quant8_large_weights_as_inputs test
+#include "generated/examples/depthwise_conv2d_quant8_large_weights_as_inputs.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/depthwise_conv2d_quant8_large_weights_as_inputs.model.cpp"
+} // namespace depthwise_conv2d_quant8_large_weights_as_inputs
+TEST_F(GeneratedTests, depthwise_conv2d_quant8_large_weights_as_inputs) {
+    execute(depthwise_conv2d_quant8_large_weights_as_inputs::CreateModel,
+            depthwise_conv2d_quant8_large_weights_as_inputs::is_ignored,
+            depthwise_conv2d_quant8_large_weights_as_inputs::examples);
+}
+
+namespace depthwise_conv2d_quant8 {
+std::vector<MixedTypedExample> examples = {
+// Generated depthwise_conv2d_quant8 test
+#include "generated/examples/depthwise_conv2d_quant8.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/depthwise_conv2d_quant8.model.cpp"
+} // namespace depthwise_conv2d_quant8
+TEST_F(GeneratedTests, depthwise_conv2d_quant8) {
+    execute(depthwise_conv2d_quant8::CreateModel,
+            depthwise_conv2d_quant8::is_ignored,
+            depthwise_conv2d_quant8::examples);
+}
+
+namespace depthwise_conv2d_quant8_weights_as_inputs {
+std::vector<MixedTypedExample> examples = {
+// Generated depthwise_conv2d_quant8_weights_as_inputs test
+#include "generated/examples/depthwise_conv2d_quant8_weights_as_inputs.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/depthwise_conv2d_quant8_weights_as_inputs.model.cpp"
+} // namespace depthwise_conv2d_quant8_weights_as_inputs
+TEST_F(GeneratedTests, depthwise_conv2d_quant8_weights_as_inputs) {
+    execute(depthwise_conv2d_quant8_weights_as_inputs::CreateModel,
+            depthwise_conv2d_quant8_weights_as_inputs::is_ignored,
+            depthwise_conv2d_quant8_weights_as_inputs::examples);
+}
+
 namespace depthwise_conv {
 std::vector<MixedTypedExample> examples = {
 // Generated depthwise_conv test
@@ -589,6 +813,90 @@ TEST_F(GeneratedTests, depthwise_conv) {
             depthwise_conv::examples);
 }
 
+namespace dequantize {
+std::vector<MixedTypedExample> examples = {
+// Generated dequantize test
+#include "generated/examples/dequantize.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/dequantize.model.cpp"
+} // namespace dequantize
+TEST_F(GeneratedTests, dequantize) {
+    execute(dequantize::CreateModel,
+            dequantize::is_ignored,
+            dequantize::examples);
+}
+
+namespace embedding_lookup_2d_nnfw {
+std::vector<MixedTypedExample> examples = {
+// Generated embedding_lookup_2d_nnfw test
+#include "generated/examples/embedding_lookup_2d_nnfw.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/embedding_lookup_2d_nnfw.model.cpp"
+} // namespace embedding_lookup_2d_nnfw
+TEST_F(GeneratedTests, embedding_lookup_2d_nnfw) {
+    execute(embedding_lookup_2d_nnfw::CreateModel,
+            embedding_lookup_2d_nnfw::is_ignored,
+            embedding_lookup_2d_nnfw::examples);
+}
+
+namespace embedding_lookup_4d_nnfw {
+std::vector<MixedTypedExample> examples = {
+// Generated embedding_lookup_4d_nnfw test
+#include "generated/examples/embedding_lookup_4d_nnfw.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/embedding_lookup_4d_nnfw.model.cpp"
+} // namespace embedding_lookup_4d_nnfw
+TEST_F(GeneratedTests, embedding_lookup_4d_nnfw) {
+    execute(embedding_lookup_4d_nnfw::CreateModel,
+            embedding_lookup_4d_nnfw::is_ignored,
+            embedding_lookup_4d_nnfw::examples);
+}
+
+namespace embedding_lookup {
+std::vector<MixedTypedExample> examples = {
+// Generated embedding_lookup test
+#include "generated/examples/embedding_lookup.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/embedding_lookup.model.cpp"
+} // namespace embedding_lookup
+TEST_F(GeneratedTests, embedding_lookup) {
+    execute(embedding_lookup::CreateModel,
+            embedding_lookup::is_ignored,
+            embedding_lookup::examples);
+}
+
+namespace floor_ {
+std::vector<MixedTypedExample> examples = {
+// Generated floor_ test
+#include "generated/examples/floor_.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/floor_.model.cpp"
+} // namespace floor_
+TEST_F(GeneratedTests, floor_) {
+    execute(floor_::CreateModel,
+            floor_::is_ignored,
+            floor_::examples);
+}
+
+namespace fully_connected_float_1_nnfw {
+std::vector<MixedTypedExample> examples = {
+// Generated fully_connected_float_1_nnfw test
+#include "generated/examples/fully_connected_float_1_nnfw.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/fully_connected_float_1_nnfw.model.cpp"
+} // namespace fully_connected_float_1_nnfw
+TEST_F(GeneratedTests, fully_connected_float_1_nnfw) {
+    execute(fully_connected_float_1_nnfw::CreateModel,
+            fully_connected_float_1_nnfw::is_ignored,
+            fully_connected_float_1_nnfw::examples);
+}
+
 namespace fully_connected_float_2 {
 std::vector<MixedTypedExample> examples = {
 // Generated fully_connected_float_2 test
@@ -603,6 +911,20 @@ TEST_F(GeneratedTests, fully_connected_float_2) {
             fully_connected_float_2::examples);
 }
 
+namespace fully_connected_float_3 {
+std::vector<MixedTypedExample> examples = {
+// Generated fully_connected_float_3 test
+#include "generated/examples/fully_connected_float_3.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/fully_connected_float_3.model.cpp"
+} // namespace fully_connected_float_3
+TEST_F(GeneratedTests, fully_connected_float_3) {
+    execute(fully_connected_float_3::CreateModel,
+            fully_connected_float_3::is_ignored,
+            fully_connected_float_3::examples);
+}
+
 namespace fully_connected_float_large {
 std::vector<MixedTypedExample> examples = {
 // Generated fully_connected_float_large test
@@ -729,6 +1051,412 @@ TEST_F(GeneratedTests, fully_connected_quant8_weights_as_inputs) {
             fully_connected_quant8_weights_as_inputs::examples);
 }
 
+namespace hashtable_lookup_float {
+std::vector<MixedTypedExample> examples = {
+// Generated hashtable_lookup_float test
+#include "generated/examples/hashtable_lookup_float.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/hashtable_lookup_float.model.cpp"
+} // namespace hashtable_lookup_float
+TEST_F(GeneratedTests, hashtable_lookup_float) {
+    execute(hashtable_lookup_float::CreateModel,
+            hashtable_lookup_float::is_ignored,
+            hashtable_lookup_float::examples);
+}
+
+namespace hashtable_lookup_quant8 {
+std::vector<MixedTypedExample> examples = {
+// Generated hashtable_lookup_quant8 test
+#include "generated/examples/hashtable_lookup_quant8.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/hashtable_lookup_quant8.model.cpp"
+} // namespace hashtable_lookup_quant8
+TEST_F(GeneratedTests, hashtable_lookup_quant8) {
+    execute(hashtable_lookup_quant8::CreateModel,
+            hashtable_lookup_quant8::is_ignored,
+            hashtable_lookup_quant8::examples);
+}
+
+namespace l2_normalization_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated l2_normalization_2 test
+#include "generated/examples/l2_normalization_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/l2_normalization_2.model.cpp"
+} // namespace l2_normalization_2
+TEST_F(GeneratedTests, l2_normalization_2) {
+    execute(l2_normalization_2::CreateModel,
+            l2_normalization_2::is_ignored,
+            l2_normalization_2::examples);
+}
+
+namespace l2_normalization_large {
+std::vector<MixedTypedExample> examples = {
+// Generated l2_normalization_large test
+#include "generated/examples/l2_normalization_large.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/l2_normalization_large.model.cpp"
+} // namespace l2_normalization_large
+TEST_F(GeneratedTests, l2_normalization_large) {
+    execute(l2_normalization_large::CreateModel,
+            l2_normalization_large::is_ignored,
+            l2_normalization_large::examples);
+}
+
+namespace l2_normalization {
+std::vector<MixedTypedExample> examples = {
+// Generated l2_normalization test
+#include "generated/examples/l2_normalization.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/l2_normalization.model.cpp"
+} // namespace l2_normalization
+TEST_F(GeneratedTests, l2_normalization) {
+    execute(l2_normalization::CreateModel,
+            l2_normalization::is_ignored,
+            l2_normalization::examples);
+}
+
+namespace l2_pool_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated l2_pool_float_2 test
+#include "generated/examples/l2_pool_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/l2_pool_float_2.model.cpp"
+} // namespace l2_pool_float_2
+TEST_F(GeneratedTests, l2_pool_float_2) {
+    execute(l2_pool_float_2::CreateModel,
+            l2_pool_float_2::is_ignored,
+            l2_pool_float_2::examples);
+}
+
+namespace l2_pool_float_large {
+std::vector<MixedTypedExample> examples = {
+// Generated l2_pool_float_large test
+#include "generated/examples/l2_pool_float_large.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/l2_pool_float_large.model.cpp"
+} // namespace l2_pool_float_large
+TEST_F(GeneratedTests, l2_pool_float_large) {
+    execute(l2_pool_float_large::CreateModel,
+            l2_pool_float_large::is_ignored,
+            l2_pool_float_large::examples);
+}
+
+namespace l2_pool_float {
+std::vector<MixedTypedExample> examples = {
+// Generated l2_pool_float test
+#include "generated/examples/l2_pool_float.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/l2_pool_float.model.cpp"
+} // namespace l2_pool_float
+TEST_F(GeneratedTests, l2_pool_float) {
+    execute(l2_pool_float::CreateModel,
+            l2_pool_float::is_ignored,
+            l2_pool_float::examples);
+}
+
+namespace local_response_norm_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated local_response_norm_float_1 test
+#include "generated/examples/local_response_norm_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/local_response_norm_float_1.model.cpp"
+} // namespace local_response_norm_float_1
+TEST_F(GeneratedTests, local_response_norm_float_1) {
+    execute(local_response_norm_float_1::CreateModel,
+            local_response_norm_float_1::is_ignored,
+            local_response_norm_float_1::examples);
+}
+
+namespace local_response_norm_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated local_response_norm_float_2 test
+#include "generated/examples/local_response_norm_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/local_response_norm_float_2.model.cpp"
+} // namespace local_response_norm_float_2
+TEST_F(GeneratedTests, local_response_norm_float_2) {
+    execute(local_response_norm_float_2::CreateModel,
+            local_response_norm_float_2::is_ignored,
+            local_response_norm_float_2::examples);
+}
+
+namespace local_response_norm_float_3 {
+std::vector<MixedTypedExample> examples = {
+// Generated local_response_norm_float_3 test
+#include "generated/examples/local_response_norm_float_3.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/local_response_norm_float_3.model.cpp"
+} // namespace local_response_norm_float_3
+TEST_F(GeneratedTests, local_response_norm_float_3) {
+    execute(local_response_norm_float_3::CreateModel,
+            local_response_norm_float_3::is_ignored,
+            local_response_norm_float_3::examples);
+}
+
+namespace local_response_norm_float_4 {
+std::vector<MixedTypedExample> examples = {
+// Generated local_response_norm_float_4 test
+#include "generated/examples/local_response_norm_float_4.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/local_response_norm_float_4.model.cpp"
+} // namespace local_response_norm_float_4
+TEST_F(GeneratedTests, local_response_norm_float_4) {
+    execute(local_response_norm_float_4::CreateModel,
+            local_response_norm_float_4::is_ignored,
+            local_response_norm_float_4::examples);
+}
+
+namespace logistic_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated logistic_float_1 test
+#include "generated/examples/logistic_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/logistic_float_1.model.cpp"
+} // namespace logistic_float_1
+TEST_F(GeneratedTests, logistic_float_1) {
+    execute(logistic_float_1::CreateModel,
+            logistic_float_1::is_ignored,
+            logistic_float_1::examples);
+}
+
+namespace logistic_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated logistic_float_2 test
+#include "generated/examples/logistic_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/logistic_float_2.model.cpp"
+} // namespace logistic_float_2
+TEST_F(GeneratedTests, logistic_float_2) {
+    execute(logistic_float_2::CreateModel,
+            logistic_float_2::is_ignored,
+            logistic_float_2::examples);
+}
+
+namespace logistic_quant8_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated logistic_quant8_1 test
+#include "generated/examples/logistic_quant8_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/logistic_quant8_1.model.cpp"
+} // namespace logistic_quant8_1
+TEST_F(GeneratedTests, logistic_quant8_1) {
+    execute(logistic_quant8_1::CreateModel,
+            logistic_quant8_1::is_ignored,
+            logistic_quant8_1::examples);
+}
+
+namespace logistic_quant8_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated logistic_quant8_2 test
+#include "generated/examples/logistic_quant8_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/logistic_quant8_2.model.cpp"
+} // namespace logistic_quant8_2
+TEST_F(GeneratedTests, logistic_quant8_2) {
+    execute(logistic_quant8_2::CreateModel,
+            logistic_quant8_2::is_ignored,
+            logistic_quant8_2::examples);
+}
+
+namespace lsh_projection_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated lsh_projection_2 test
+#include "generated/examples/lsh_projection_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lsh_projection_2.model.cpp"
+} // namespace lsh_projection_2
+TEST_F(GeneratedTests, lsh_projection_2) {
+    execute(lsh_projection_2::CreateModel,
+            lsh_projection_2::is_ignored,
+            lsh_projection_2::examples);
+}
+
+namespace lsh_projection {
+std::vector<MixedTypedExample> examples = {
+// Generated lsh_projection test
+#include "generated/examples/lsh_projection.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lsh_projection.model.cpp"
+} // namespace lsh_projection
+TEST_F(GeneratedTests, lsh_projection) {
+    execute(lsh_projection::CreateModel,
+            lsh_projection::is_ignored,
+            lsh_projection::examples);
+}
+
+namespace lsh_projection_weights_as_inputs {
+std::vector<MixedTypedExample> examples = {
+// Generated lsh_projection_weights_as_inputs test
+#include "generated/examples/lsh_projection_weights_as_inputs.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lsh_projection_weights_as_inputs.model.cpp"
+} // namespace lsh_projection_weights_as_inputs
+TEST_F(GeneratedTests, lsh_projection_weights_as_inputs) {
+    execute(lsh_projection_weights_as_inputs::CreateModel,
+            lsh_projection_weights_as_inputs::is_ignored,
+            lsh_projection_weights_as_inputs::examples);
+}
+
+namespace lstm2 {
+std::vector<MixedTypedExample> examples = {
+// Generated lstm2 test
+#include "generated/examples/lstm2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lstm2.model.cpp"
+} // namespace lstm2
+TEST_F(GeneratedTests, lstm2) {
+    execute(lstm2::CreateModel,
+            lstm2::is_ignored,
+            lstm2::examples);
+}
+
+namespace lstm2_state2 {
+std::vector<MixedTypedExample> examples = {
+// Generated lstm2_state2 test
+#include "generated/examples/lstm2_state2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lstm2_state2.model.cpp"
+} // namespace lstm2_state2
+TEST_F(GeneratedTests, lstm2_state2) {
+    execute(lstm2_state2::CreateModel,
+            lstm2_state2::is_ignored,
+            lstm2_state2::examples);
+}
+
+namespace lstm2_state {
+std::vector<MixedTypedExample> examples = {
+// Generated lstm2_state test
+#include "generated/examples/lstm2_state.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lstm2_state.model.cpp"
+} // namespace lstm2_state
+TEST_F(GeneratedTests, lstm2_state) {
+    execute(lstm2_state::CreateModel,
+            lstm2_state::is_ignored,
+            lstm2_state::examples);
+}
+
+namespace lstm3 {
+std::vector<MixedTypedExample> examples = {
+// Generated lstm3 test
+#include "generated/examples/lstm3.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lstm3.model.cpp"
+} // namespace lstm3
+TEST_F(GeneratedTests, lstm3) {
+    execute(lstm3::CreateModel,
+            lstm3::is_ignored,
+            lstm3::examples);
+}
+
+namespace lstm3_state2 {
+std::vector<MixedTypedExample> examples = {
+// Generated lstm3_state2 test
+#include "generated/examples/lstm3_state2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lstm3_state2.model.cpp"
+} // namespace lstm3_state2
+TEST_F(GeneratedTests, lstm3_state2) {
+    execute(lstm3_state2::CreateModel,
+            lstm3_state2::is_ignored,
+            lstm3_state2::examples);
+}
+
+namespace lstm3_state3 {
+std::vector<MixedTypedExample> examples = {
+// Generated lstm3_state3 test
+#include "generated/examples/lstm3_state3.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lstm3_state3.model.cpp"
+} // namespace lstm3_state3
+TEST_F(GeneratedTests, lstm3_state3) {
+    execute(lstm3_state3::CreateModel,
+            lstm3_state3::is_ignored,
+            lstm3_state3::examples);
+}
+
+namespace lstm3_state {
+std::vector<MixedTypedExample> examples = {
+// Generated lstm3_state test
+#include "generated/examples/lstm3_state.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lstm3_state.model.cpp"
+} // namespace lstm3_state
+TEST_F(GeneratedTests, lstm3_state) {
+    execute(lstm3_state::CreateModel,
+            lstm3_state::is_ignored,
+            lstm3_state::examples);
+}
+
+namespace lstm {
+std::vector<MixedTypedExample> examples = {
+// Generated lstm test
+#include "generated/examples/lstm.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lstm.model.cpp"
+} // namespace lstm
+TEST_F(GeneratedTests, lstm) {
+    execute(lstm::CreateModel,
+            lstm::is_ignored,
+            lstm::examples);
+}
+
+namespace lstm_state2 {
+std::vector<MixedTypedExample> examples = {
+// Generated lstm_state2 test
+#include "generated/examples/lstm_state2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lstm_state2.model.cpp"
+} // namespace lstm_state2
+TEST_F(GeneratedTests, lstm_state2) {
+    execute(lstm_state2::CreateModel,
+            lstm_state2::is_ignored,
+            lstm_state2::examples);
+}
+
+namespace lstm_state {
+std::vector<MixedTypedExample> examples = {
+// Generated lstm_state test
+#include "generated/examples/lstm_state.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/lstm_state.model.cpp"
+} // namespace lstm_state
+TEST_F(GeneratedTests, lstm_state) {
+    execute(lstm_state::CreateModel,
+            lstm_state::is_ignored,
+            lstm_state::examples);
+}
+
 namespace max_pool_float_1 {
 std::vector<MixedTypedExample> examples = {
 // Generated max_pool_float_1 test
@@ -743,6 +1471,34 @@ TEST_F(GeneratedTests, max_pool_float_1) {
             max_pool_float_1::examples);
 }
 
+namespace max_pool_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated max_pool_float_2 test
+#include "generated/examples/max_pool_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/max_pool_float_2.model.cpp"
+} // namespace max_pool_float_2
+TEST_F(GeneratedTests, max_pool_float_2) {
+    execute(max_pool_float_2::CreateModel,
+            max_pool_float_2::is_ignored,
+            max_pool_float_2::examples);
+}
+
+namespace max_pool_float_3 {
+std::vector<MixedTypedExample> examples = {
+// Generated max_pool_float_3 test
+#include "generated/examples/max_pool_float_3.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/max_pool_float_3.model.cpp"
+} // namespace max_pool_float_3
+TEST_F(GeneratedTests, max_pool_float_3) {
+    execute(max_pool_float_3::CreateModel,
+            max_pool_float_3::is_ignored,
+            max_pool_float_3::examples);
+}
+
 namespace max_pool_float_4 {
 std::vector<MixedTypedExample> examples = {
 // Generated max_pool_float_4 test
@@ -813,6 +1569,62 @@ TEST_F(GeneratedTests, max_pool_quant8_4) {
             max_pool_quant8_4::examples);
 }
 
+namespace mobilenet_224_gender_basic_fixed {
+std::vector<MixedTypedExample> examples = {
+// Generated mobilenet_224_gender_basic_fixed test
+#include "generated/examples/mobilenet_224_gender_basic_fixed.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/mobilenet_224_gender_basic_fixed.model.cpp"
+} // namespace mobilenet_224_gender_basic_fixed
+TEST_F(GeneratedTests, mobilenet_224_gender_basic_fixed) {
+    execute(mobilenet_224_gender_basic_fixed::CreateModel,
+            mobilenet_224_gender_basic_fixed::is_ignored,
+            mobilenet_224_gender_basic_fixed::examples);
+}
+
+namespace mobilenet_quantized {
+std::vector<MixedTypedExample> examples = {
+// Generated mobilenet_quantized test
+#include "generated/examples/mobilenet_quantized.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/mobilenet_quantized.model.cpp"
+} // namespace mobilenet_quantized
+TEST_F(GeneratedTests, mobilenet_quantized) {
+    execute(mobilenet_quantized::CreateModel,
+            mobilenet_quantized::is_ignored,
+            mobilenet_quantized::examples);
+}
+
+namespace mul_broadcast_3D_1D_1_nnfw {
+std::vector<MixedTypedExample> examples = {
+// Generated mul_broadcast_3D_1D_1_nnfw test
+#include "generated/examples/mul_broadcast_3D_1D_1_nnfw.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/mul_broadcast_3D_1D_1_nnfw.model.cpp"
+} // namespace mul_broadcast_3D_1D_1_nnfw
+TEST_F(GeneratedTests, mul_broadcast_3D_1D_1_nnfw) {
+    execute(mul_broadcast_3D_1D_1_nnfw::CreateModel,
+            mul_broadcast_3D_1D_1_nnfw::is_ignored,
+            mul_broadcast_3D_1D_1_nnfw::examples);
+}
+
+namespace mul_broadcast_3D_1D_2_nnfw {
+std::vector<MixedTypedExample> examples = {
+// Generated mul_broadcast_3D_1D_2_nnfw test
+#include "generated/examples/mul_broadcast_3D_1D_2_nnfw.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/mul_broadcast_3D_1D_2_nnfw.model.cpp"
+} // namespace mul_broadcast_3D_1D_2_nnfw
+TEST_F(GeneratedTests, mul_broadcast_3D_1D_2_nnfw) {
+    execute(mul_broadcast_3D_1D_2_nnfw::CreateModel,
+            mul_broadcast_3D_1D_2_nnfw::is_ignored,
+            mul_broadcast_3D_1D_2_nnfw::examples);
+}
+
 namespace mul_broadcast_quant8 {
 std::vector<MixedTypedExample> examples = {
 // Generated mul_broadcast_quant8 test
@@ -869,6 +1681,62 @@ TEST_F(GeneratedTests, mul_relu) {
             mul_relu::examples);
 }
 
+namespace relu1_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated relu1_float_1 test
+#include "generated/examples/relu1_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/relu1_float_1.model.cpp"
+} // namespace relu1_float_1
+TEST_F(GeneratedTests, relu1_float_1) {
+    execute(relu1_float_1::CreateModel,
+            relu1_float_1::is_ignored,
+            relu1_float_1::examples);
+}
+
+namespace relu1_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated relu1_float_2 test
+#include "generated/examples/relu1_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/relu1_float_2.model.cpp"
+} // namespace relu1_float_2
+TEST_F(GeneratedTests, relu1_float_2) {
+    execute(relu1_float_2::CreateModel,
+            relu1_float_2::is_ignored,
+            relu1_float_2::examples);
+}
+
+namespace relu1_quant8_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated relu1_quant8_1 test
+#include "generated/examples/relu1_quant8_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/relu1_quant8_1.model.cpp"
+} // namespace relu1_quant8_1
+TEST_F(GeneratedTests, relu1_quant8_1) {
+    execute(relu1_quant8_1::CreateModel,
+            relu1_quant8_1::is_ignored,
+            relu1_quant8_1::examples);
+}
+
+namespace relu1_quant8_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated relu1_quant8_2 test
+#include "generated/examples/relu1_quant8_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/relu1_quant8_2.model.cpp"
+} // namespace relu1_quant8_2
+TEST_F(GeneratedTests, relu1_quant8_2) {
+    execute(relu1_quant8_2::CreateModel,
+            relu1_quant8_2::is_ignored,
+            relu1_quant8_2::examples);
+}
+
 namespace relu6_float_1 {
 std::vector<MixedTypedExample> examples = {
 // Generated relu6_float_1 test
@@ -925,6 +1793,62 @@ TEST_F(GeneratedTests, relu6_quant8_2) {
             relu6_quant8_2::examples);
 }
 
+namespace relu_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated relu_float_1 test
+#include "generated/examples/relu_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/relu_float_1.model.cpp"
+} // namespace relu_float_1
+TEST_F(GeneratedTests, relu_float_1) {
+    execute(relu_float_1::CreateModel,
+            relu_float_1::is_ignored,
+            relu_float_1::examples);
+}
+
+namespace relu_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated relu_float_2 test
+#include "generated/examples/relu_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/relu_float_2.model.cpp"
+} // namespace relu_float_2
+TEST_F(GeneratedTests, relu_float_2) {
+    execute(relu_float_2::CreateModel,
+            relu_float_2::is_ignored,
+            relu_float_2::examples);
+}
+
+namespace relu_quant8_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated relu_quant8_1 test
+#include "generated/examples/relu_quant8_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/relu_quant8_1.model.cpp"
+} // namespace relu_quant8_1
+TEST_F(GeneratedTests, relu_quant8_1) {
+    execute(relu_quant8_1::CreateModel,
+            relu_quant8_1::is_ignored,
+            relu_quant8_1::examples);
+}
+
+namespace relu_quant8_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated relu_quant8_2 test
+#include "generated/examples/relu_quant8_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/relu_quant8_2.model.cpp"
+} // namespace relu_quant8_2
+TEST_F(GeneratedTests, relu_quant8_2) {
+    execute(relu_quant8_2::CreateModel,
+            relu_quant8_2::is_ignored,
+            relu_quant8_2::examples);
+}
+
 namespace reshape {
 std::vector<MixedTypedExample> examples = {
 // Generated reshape test
@@ -981,6 +1905,62 @@ TEST_F(GeneratedTests, reshape_weights_as_inputs) {
             reshape_weights_as_inputs::examples);
 }
 
+namespace resize_bilinear_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated resize_bilinear_2 test
+#include "generated/examples/resize_bilinear_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/resize_bilinear_2.model.cpp"
+} // namespace resize_bilinear_2
+TEST_F(GeneratedTests, resize_bilinear_2) {
+    execute(resize_bilinear_2::CreateModel,
+            resize_bilinear_2::is_ignored,
+            resize_bilinear_2::examples);
+}
+
+namespace resize_bilinear {
+std::vector<MixedTypedExample> examples = {
+// Generated resize_bilinear test
+#include "generated/examples/resize_bilinear.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/resize_bilinear.model.cpp"
+} // namespace resize_bilinear
+TEST_F(GeneratedTests, resize_bilinear) {
+    execute(resize_bilinear::CreateModel,
+            resize_bilinear::is_ignored,
+            resize_bilinear::examples);
+}
+
+namespace rnn {
+std::vector<MixedTypedExample> examples = {
+// Generated rnn test
+#include "generated/examples/rnn.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/rnn.model.cpp"
+} // namespace rnn
+TEST_F(GeneratedTests, rnn) {
+    execute(rnn::CreateModel,
+            rnn::is_ignored,
+            rnn::examples);
+}
+
+namespace rnn_state {
+std::vector<MixedTypedExample> examples = {
+// Generated rnn_state test
+#include "generated/examples/rnn_state.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/rnn_state.model.cpp"
+} // namespace rnn_state
+TEST_F(GeneratedTests, rnn_state) {
+    execute(rnn_state::CreateModel,
+            rnn_state::is_ignored,
+            rnn_state::examples);
+}
+
 namespace softmax_float_1 {
 std::vector<MixedTypedExample> examples = {
 // Generated softmax_float_1 test
@@ -995,6 +1975,20 @@ TEST_F(GeneratedTests, softmax_float_1) {
             softmax_float_1::examples);
 }
 
+namespace softmax_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated softmax_float_2 test
+#include "generated/examples/softmax_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/softmax_float_2.model.cpp"
+} // namespace softmax_float_2
+TEST_F(GeneratedTests, softmax_float_2) {
+    execute(softmax_float_2::CreateModel,
+            softmax_float_2::is_ignored,
+            softmax_float_2::examples);
+}
+
 namespace softmax_quant8_1 {
 std::vector<MixedTypedExample> examples = {
 // Generated softmax_quant8_1 test
@@ -1023,3 +2017,1108 @@ TEST_F(GeneratedTests, softmax_quant8_2) {
             softmax_quant8_2::examples);
 }
 
+namespace space_to_depth_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated space_to_depth_float_1 test
+#include "generated/examples/space_to_depth_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/space_to_depth_float_1.model.cpp"
+} // namespace space_to_depth_float_1
+TEST_F(GeneratedTests, space_to_depth_float_1) {
+    execute(space_to_depth_float_1::CreateModel,
+            space_to_depth_float_1::is_ignored,
+            space_to_depth_float_1::examples);
+}
+
+namespace space_to_depth_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated space_to_depth_float_2 test
+#include "generated/examples/space_to_depth_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/space_to_depth_float_2.model.cpp"
+} // namespace space_to_depth_float_2
+TEST_F(GeneratedTests, space_to_depth_float_2) {
+    execute(space_to_depth_float_2::CreateModel,
+            space_to_depth_float_2::is_ignored,
+            space_to_depth_float_2::examples);
+}
+
+namespace space_to_depth_float_3 {
+std::vector<MixedTypedExample> examples = {
+// Generated space_to_depth_float_3 test
+#include "generated/examples/space_to_depth_float_3.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/space_to_depth_float_3.model.cpp"
+} // namespace space_to_depth_float_3
+TEST_F(GeneratedTests, space_to_depth_float_3) {
+    execute(space_to_depth_float_3::CreateModel,
+            space_to_depth_float_3::is_ignored,
+            space_to_depth_float_3::examples);
+}
+
+namespace space_to_depth_quant8_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated space_to_depth_quant8_1 test
+#include "generated/examples/space_to_depth_quant8_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/space_to_depth_quant8_1.model.cpp"
+} // namespace space_to_depth_quant8_1
+TEST_F(GeneratedTests, space_to_depth_quant8_1) {
+    execute(space_to_depth_quant8_1::CreateModel,
+            space_to_depth_quant8_1::is_ignored,
+            space_to_depth_quant8_1::examples);
+}
+
+namespace space_to_depth_quant8_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated space_to_depth_quant8_2 test
+#include "generated/examples/space_to_depth_quant8_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/space_to_depth_quant8_2.model.cpp"
+} // namespace space_to_depth_quant8_2
+TEST_F(GeneratedTests, space_to_depth_quant8_2) {
+    execute(space_to_depth_quant8_2::CreateModel,
+            space_to_depth_quant8_2::is_ignored,
+            space_to_depth_quant8_2::examples);
+}
+
+namespace svdf2 {
+std::vector<MixedTypedExample> examples = {
+// Generated svdf2 test
+#include "generated/examples/svdf2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/svdf2.model.cpp"
+} // namespace svdf2
+TEST_F(GeneratedTests, svdf2) {
+    execute(svdf2::CreateModel,
+            svdf2::is_ignored,
+            svdf2::examples);
+}
+
+namespace svdf {
+std::vector<MixedTypedExample> examples = {
+// Generated svdf test
+#include "generated/examples/svdf.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/svdf.model.cpp"
+} // namespace svdf
+TEST_F(GeneratedTests, svdf) {
+    execute(svdf::CreateModel,
+            svdf::is_ignored,
+            svdf::examples);
+}
+
+namespace svdf_state {
+std::vector<MixedTypedExample> examples = {
+// Generated svdf_state test
+#include "generated/examples/svdf_state.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/svdf_state.model.cpp"
+} // namespace svdf_state
+TEST_F(GeneratedTests, svdf_state) {
+    execute(svdf_state::CreateModel,
+            svdf_state::is_ignored,
+            svdf_state::examples);
+}
+
+namespace tanh_ {
+std::vector<MixedTypedExample> examples = {
+// Generated tanh_ test
+#include "generated/examples/tanh_.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/tanh_.model.cpp"
+} // namespace tanh_
+TEST_F(GeneratedTests, tanh_) {
+    execute(tanh_::CreateModel,
+            tanh_::is_ignored,
+            tanh_::examples);
+}
+
+namespace batch_to_space_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated batch_to_space_float_1 test
+#include "generated/examples/batch_to_space_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/batch_to_space_float_1.model.cpp"
+} // namespace batch_to_space_float_1
+TEST_F(GeneratedTests, batch_to_space_float_1) {
+    execute(batch_to_space_float_1::CreateModel,
+            batch_to_space_float_1::is_ignored,
+            batch_to_space_float_1::examples);
+}
+
+namespace batch_to_space {
+std::vector<MixedTypedExample> examples = {
+// Generated batch_to_space test
+#include "generated/examples/batch_to_space.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/batch_to_space.model.cpp"
+} // namespace batch_to_space
+TEST_F(GeneratedTests, batch_to_space) {
+    execute(batch_to_space::CreateModel,
+            batch_to_space::is_ignored,
+            batch_to_space::examples);
+}
+
+namespace batch_to_space_quant8_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated batch_to_space_quant8_1 test
+#include "generated/examples/batch_to_space_quant8_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/batch_to_space_quant8_1.model.cpp"
+} // namespace batch_to_space_quant8_1
+TEST_F(GeneratedTests, batch_to_space_quant8_1) {
+    execute(batch_to_space_quant8_1::CreateModel,
+            batch_to_space_quant8_1::is_ignored,
+            batch_to_space_quant8_1::examples);
+}
+
+namespace div_broadcast_float {
+std::vector<MixedTypedExample> examples = {
+// Generated div_broadcast_float test
+#include "generated/examples/div_broadcast_float.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/div_broadcast_float.model.cpp"
+} // namespace div_broadcast_float
+TEST_F(GeneratedTests, div_broadcast_float) {
+    execute(div_broadcast_float::CreateModel,
+            div_broadcast_float::is_ignored,
+            div_broadcast_float::examples);
+}
+
+namespace div_ {
+std::vector<MixedTypedExample> examples = {
+// Generated div_ test
+#include "generated/examples/div_.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/div_.model.cpp"
+} // namespace div_
+TEST_F(GeneratedTests, div_) {
+    execute(div_::CreateModel,
+            div_::is_ignored,
+            div_::examples);
+}
+
+namespace fully_connected_float_4d_simple {
+std::vector<MixedTypedExample> examples = {
+// Generated fully_connected_float_4d_simple test
+#include "generated/examples/fully_connected_float_4d_simple.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/fully_connected_float_4d_simple.model.cpp"
+} // namespace fully_connected_float_4d_simple
+TEST_F(GeneratedTests, fully_connected_float_4d_simple) {
+    execute(fully_connected_float_4d_simple::CreateModel,
+            fully_connected_float_4d_simple::is_ignored,
+            fully_connected_float_4d_simple::examples);
+}
+
+namespace mean_axis01_1_nnfw {
+std::vector<MixedTypedExample> examples = {
+// Generated mean_axis01_1_nnfw test
+#include "generated/examples/mean_axis01_1_nnfw.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/mean_axis01_1_nnfw.model.cpp"
+} // namespace mean_axis01_1_nnfw
+TEST_F(GeneratedTests, mean_axis01_1_nnfw) {
+    execute(mean_axis01_1_nnfw::CreateModel,
+            mean_axis01_1_nnfw::is_ignored,
+            mean_axis01_1_nnfw::examples);
+}
+
+namespace mean_axis01_2_nnfw {
+std::vector<MixedTypedExample> examples = {
+// Generated mean_axis01_2_nnfw test
+#include "generated/examples/mean_axis01_2_nnfw.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/mean_axis01_2_nnfw.model.cpp"
+} // namespace mean_axis01_2_nnfw
+TEST_F(GeneratedTests, mean_axis01_2_nnfw) {
+    execute(mean_axis01_2_nnfw::CreateModel,
+            mean_axis01_2_nnfw::is_ignored,
+            mean_axis01_2_nnfw::examples);
+}
+
+namespace mean_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated mean_float_1 test
+#include "generated/examples/mean_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/mean_float_1.model.cpp"
+} // namespace mean_float_1
+TEST_F(GeneratedTests, mean_float_1) {
+    execute(mean_float_1::CreateModel,
+            mean_float_1::is_ignored,
+            mean_float_1::examples);
+}
+
+namespace mean_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated mean_float_2 test
+#include "generated/examples/mean_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/mean_float_2.model.cpp"
+} // namespace mean_float_2
+TEST_F(GeneratedTests, mean_float_2) {
+    execute(mean_float_2::CreateModel,
+            mean_float_2::is_ignored,
+            mean_float_2::examples);
+}
+
+namespace mean {
+std::vector<MixedTypedExample> examples = {
+// Generated mean test
+#include "generated/examples/mean.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/mean.model.cpp"
+} // namespace mean
+TEST_F(GeneratedTests, mean) {
+    execute(mean::CreateModel,
+            mean::is_ignored,
+            mean::examples);
+}
+
+namespace mean_quant8_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated mean_quant8_1 test
+#include "generated/examples/mean_quant8_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/mean_quant8_1.model.cpp"
+} // namespace mean_quant8_1
+TEST_F(GeneratedTests, mean_quant8_1) {
+    execute(mean_quant8_1::CreateModel,
+            mean_quant8_1::is_ignored,
+            mean_quant8_1::examples);
+}
+
+namespace mean_quant8_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated mean_quant8_2 test
+#include "generated/examples/mean_quant8_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/mean_quant8_2.model.cpp"
+} // namespace mean_quant8_2
+TEST_F(GeneratedTests, mean_quant8_2) {
+    execute(mean_quant8_2::CreateModel,
+            mean_quant8_2::is_ignored,
+            mean_quant8_2::examples);
+}
+
+namespace pad_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated pad_float_1 test
+#include "generated/examples/pad_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/pad_float_1.model.cpp"
+} // namespace pad_float_1
+TEST_F(GeneratedTests, pad_float_1) {
+    execute(pad_float_1::CreateModel,
+            pad_float_1::is_ignored,
+            pad_float_1::examples);
+}
+
+namespace pad {
+std::vector<MixedTypedExample> examples = {
+// Generated pad test
+#include "generated/examples/pad.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/pad.model.cpp"
+} // namespace pad
+TEST_F(GeneratedTests, pad) {
+    execute(pad::CreateModel,
+            pad::is_ignored,
+            pad::examples);
+}
+
+namespace space_to_batch_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated space_to_batch_float_1 test
+#include "generated/examples/space_to_batch_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/space_to_batch_float_1.model.cpp"
+} // namespace space_to_batch_float_1
+TEST_F(GeneratedTests, space_to_batch_float_1) {
+    execute(space_to_batch_float_1::CreateModel,
+            space_to_batch_float_1::is_ignored,
+            space_to_batch_float_1::examples);
+}
+
+namespace space_to_batch_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated space_to_batch_float_2 test
+#include "generated/examples/space_to_batch_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/space_to_batch_float_2.model.cpp"
+} // namespace space_to_batch_float_2
+TEST_F(GeneratedTests, space_to_batch_float_2) {
+    execute(space_to_batch_float_2::CreateModel,
+            space_to_batch_float_2::is_ignored,
+            space_to_batch_float_2::examples);
+}
+
+namespace space_to_batch_float_3 {
+std::vector<MixedTypedExample> examples = {
+// Generated space_to_batch_float_3 test
+#include "generated/examples/space_to_batch_float_3.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/space_to_batch_float_3.model.cpp"
+} // namespace space_to_batch_float_3
+TEST_F(GeneratedTests, space_to_batch_float_3) {
+    execute(space_to_batch_float_3::CreateModel,
+            space_to_batch_float_3::is_ignored,
+            space_to_batch_float_3::examples);
+}
+
+namespace space_to_batch {
+std::vector<MixedTypedExample> examples = {
+// Generated space_to_batch test
+#include "generated/examples/space_to_batch.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/space_to_batch.model.cpp"
+} // namespace space_to_batch
+TEST_F(GeneratedTests, space_to_batch) {
+    execute(space_to_batch::CreateModel,
+            space_to_batch::is_ignored,
+            space_to_batch::examples);
+}
+
+namespace space_to_batch_quant8_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated space_to_batch_quant8_1 test
+#include "generated/examples/space_to_batch_quant8_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/space_to_batch_quant8_1.model.cpp"
+} // namespace space_to_batch_quant8_1
+TEST_F(GeneratedTests, space_to_batch_quant8_1) {
+    execute(space_to_batch_quant8_1::CreateModel,
+            space_to_batch_quant8_1::is_ignored,
+            space_to_batch_quant8_1::examples);
+}
+
+namespace space_to_batch_quant8_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated space_to_batch_quant8_2 test
+#include "generated/examples/space_to_batch_quant8_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/space_to_batch_quant8_2.model.cpp"
+} // namespace space_to_batch_quant8_2
+TEST_F(GeneratedTests, space_to_batch_quant8_2) {
+    execute(space_to_batch_quant8_2::CreateModel,
+            space_to_batch_quant8_2::is_ignored,
+            space_to_batch_quant8_2::examples);
+}
+
+namespace space_to_batch_quant8_3 {
+std::vector<MixedTypedExample> examples = {
+// Generated space_to_batch_quant8_3 test
+#include "generated/examples/space_to_batch_quant8_3.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/space_to_batch_quant8_3.model.cpp"
+} // namespace space_to_batch_quant8_3
+TEST_F(GeneratedTests, space_to_batch_quant8_3) {
+    execute(space_to_batch_quant8_3::CreateModel,
+            space_to_batch_quant8_3::is_ignored,
+            space_to_batch_quant8_3::examples);
+}
+
+namespace squeeze_2D_float_1_nnfw {
+std::vector<MixedTypedExample> examples = {
+// Generated squeeze_2D_float_1_nnfw test
+#include "generated/examples/squeeze_2D_float_1_nnfw.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/squeeze_2D_float_1_nnfw.model.cpp"
+} // namespace squeeze_2D_float_1_nnfw
+TEST_F(GeneratedTests, squeeze_2D_float_1_nnfw) {
+    execute(squeeze_2D_float_1_nnfw::CreateModel,
+            squeeze_2D_float_1_nnfw::is_ignored,
+            squeeze_2D_float_1_nnfw::examples);
+}
+
+namespace squeeze_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated squeeze_float_1 test
+#include "generated/examples/squeeze_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/squeeze_float_1.model.cpp"
+} // namespace squeeze_float_1
+TEST_F(GeneratedTests, squeeze_float_1) {
+    execute(squeeze_float_1::CreateModel,
+            squeeze_float_1::is_ignored,
+            squeeze_float_1::examples);
+}
+
+namespace squeeze {
+std::vector<MixedTypedExample> examples = {
+// Generated squeeze test
+#include "generated/examples/squeeze.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/squeeze.model.cpp"
+} // namespace squeeze
+TEST_F(GeneratedTests, squeeze) {
+    execute(squeeze::CreateModel,
+            squeeze::is_ignored,
+            squeeze::examples);
+}
+
+namespace squeeze_quant8_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated squeeze_quant8_1 test
+#include "generated/examples/squeeze_quant8_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/squeeze_quant8_1.model.cpp"
+} // namespace squeeze_quant8_1
+TEST_F(GeneratedTests, squeeze_quant8_1) {
+    execute(squeeze_quant8_1::CreateModel,
+            squeeze_quant8_1::is_ignored,
+            squeeze_quant8_1::examples);
+}
+
+namespace strided_slice_float_10 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_float_10 test
+#include "generated/examples/strided_slice_float_10.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_float_10.model.cpp"
+} // namespace strided_slice_float_10
+TEST_F(GeneratedTests, strided_slice_float_10) {
+    execute(strided_slice_float_10::CreateModel,
+            strided_slice_float_10::is_ignored,
+            strided_slice_float_10::examples);
+}
+
+namespace strided_slice_float_11 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_float_11 test
+#include "generated/examples/strided_slice_float_11.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_float_11.model.cpp"
+} // namespace strided_slice_float_11
+TEST_F(GeneratedTests, strided_slice_float_11) {
+    execute(strided_slice_float_11::CreateModel,
+            strided_slice_float_11::is_ignored,
+            strided_slice_float_11::examples);
+}
+
+namespace strided_slice_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_float_1 test
+#include "generated/examples/strided_slice_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_float_1.model.cpp"
+} // namespace strided_slice_float_1
+TEST_F(GeneratedTests, strided_slice_float_1) {
+    execute(strided_slice_float_1::CreateModel,
+            strided_slice_float_1::is_ignored,
+            strided_slice_float_1::examples);
+}
+
+namespace strided_slice_float_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_float_2 test
+#include "generated/examples/strided_slice_float_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_float_2.model.cpp"
+} // namespace strided_slice_float_2
+TEST_F(GeneratedTests, strided_slice_float_2) {
+    execute(strided_slice_float_2::CreateModel,
+            strided_slice_float_2::is_ignored,
+            strided_slice_float_2::examples);
+}
+
+namespace strided_slice_float_3 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_float_3 test
+#include "generated/examples/strided_slice_float_3.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_float_3.model.cpp"
+} // namespace strided_slice_float_3
+TEST_F(GeneratedTests, strided_slice_float_3) {
+    execute(strided_slice_float_3::CreateModel,
+            strided_slice_float_3::is_ignored,
+            strided_slice_float_3::examples);
+}
+
+namespace strided_slice_float_4 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_float_4 test
+#include "generated/examples/strided_slice_float_4.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_float_4.model.cpp"
+} // namespace strided_slice_float_4
+TEST_F(GeneratedTests, strided_slice_float_4) {
+    execute(strided_slice_float_4::CreateModel,
+            strided_slice_float_4::is_ignored,
+            strided_slice_float_4::examples);
+}
+
+namespace strided_slice_float_5 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_float_5 test
+#include "generated/examples/strided_slice_float_5.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_float_5.model.cpp"
+} // namespace strided_slice_float_5
+TEST_F(GeneratedTests, strided_slice_float_5) {
+    execute(strided_slice_float_5::CreateModel,
+            strided_slice_float_5::is_ignored,
+            strided_slice_float_5::examples);
+}
+
+namespace strided_slice_float_6 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_float_6 test
+#include "generated/examples/strided_slice_float_6.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_float_6.model.cpp"
+} // namespace strided_slice_float_6
+TEST_F(GeneratedTests, strided_slice_float_6) {
+    execute(strided_slice_float_6::CreateModel,
+            strided_slice_float_6::is_ignored,
+            strided_slice_float_6::examples);
+}
+
+namespace strided_slice_float_7 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_float_7 test
+#include "generated/examples/strided_slice_float_7.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_float_7.model.cpp"
+} // namespace strided_slice_float_7
+TEST_F(GeneratedTests, strided_slice_float_7) {
+    execute(strided_slice_float_7::CreateModel,
+            strided_slice_float_7::is_ignored,
+            strided_slice_float_7::examples);
+}
+
+namespace strided_slice_float_8 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_float_8 test
+#include "generated/examples/strided_slice_float_8.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_float_8.model.cpp"
+} // namespace strided_slice_float_8
+TEST_F(GeneratedTests, strided_slice_float_8) {
+    execute(strided_slice_float_8::CreateModel,
+            strided_slice_float_8::is_ignored,
+            strided_slice_float_8::examples);
+}
+
+namespace strided_slice_float_9 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_float_9 test
+#include "generated/examples/strided_slice_float_9.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_float_9.model.cpp"
+} // namespace strided_slice_float_9
+TEST_F(GeneratedTests, strided_slice_float_9) {
+    execute(strided_slice_float_9::CreateModel,
+            strided_slice_float_9::is_ignored,
+            strided_slice_float_9::examples);
+}
+
+namespace strided_slice {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice test
+#include "generated/examples/strided_slice.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice.model.cpp"
+} // namespace strided_slice
+TEST_F(GeneratedTests, strided_slice) {
+    execute(strided_slice::CreateModel,
+            strided_slice::is_ignored,
+            strided_slice::examples);
+}
+
+namespace strided_slice_qaunt8_10 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_qaunt8_10 test
+#include "generated/examples/strided_slice_qaunt8_10.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_qaunt8_10.model.cpp"
+} // namespace strided_slice_qaunt8_10
+TEST_F(GeneratedTests, strided_slice_qaunt8_10) {
+    execute(strided_slice_qaunt8_10::CreateModel,
+            strided_slice_qaunt8_10::is_ignored,
+            strided_slice_qaunt8_10::examples);
+}
+
+namespace strided_slice_qaunt8_11 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_qaunt8_11 test
+#include "generated/examples/strided_slice_qaunt8_11.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_qaunt8_11.model.cpp"
+} // namespace strided_slice_qaunt8_11
+TEST_F(GeneratedTests, strided_slice_qaunt8_11) {
+    execute(strided_slice_qaunt8_11::CreateModel,
+            strided_slice_qaunt8_11::is_ignored,
+            strided_slice_qaunt8_11::examples);
+}
+
+namespace strided_slice_quant8_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_quant8_1 test
+#include "generated/examples/strided_slice_quant8_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_quant8_1.model.cpp"
+} // namespace strided_slice_quant8_1
+TEST_F(GeneratedTests, strided_slice_quant8_1) {
+    execute(strided_slice_quant8_1::CreateModel,
+            strided_slice_quant8_1::is_ignored,
+            strided_slice_quant8_1::examples);
+}
+
+namespace strided_slice_quant8_2 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_quant8_2 test
+#include "generated/examples/strided_slice_quant8_2.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_quant8_2.model.cpp"
+} // namespace strided_slice_quant8_2
+TEST_F(GeneratedTests, strided_slice_quant8_2) {
+    execute(strided_slice_quant8_2::CreateModel,
+            strided_slice_quant8_2::is_ignored,
+            strided_slice_quant8_2::examples);
+}
+
+namespace strided_slice_quant8_3 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_quant8_3 test
+#include "generated/examples/strided_slice_quant8_3.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_quant8_3.model.cpp"
+} // namespace strided_slice_quant8_3
+TEST_F(GeneratedTests, strided_slice_quant8_3) {
+    execute(strided_slice_quant8_3::CreateModel,
+            strided_slice_quant8_3::is_ignored,
+            strided_slice_quant8_3::examples);
+}
+
+namespace strided_slice_quant8_4 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_quant8_4 test
+#include "generated/examples/strided_slice_quant8_4.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_quant8_4.model.cpp"
+} // namespace strided_slice_quant8_4
+TEST_F(GeneratedTests, strided_slice_quant8_4) {
+    execute(strided_slice_quant8_4::CreateModel,
+            strided_slice_quant8_4::is_ignored,
+            strided_slice_quant8_4::examples);
+}
+
+namespace strided_slice_quant8_5 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_quant8_5 test
+#include "generated/examples/strided_slice_quant8_5.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_quant8_5.model.cpp"
+} // namespace strided_slice_quant8_5
+TEST_F(GeneratedTests, strided_slice_quant8_5) {
+    execute(strided_slice_quant8_5::CreateModel,
+            strided_slice_quant8_5::is_ignored,
+            strided_slice_quant8_5::examples);
+}
+
+namespace strided_slice_quant8_6 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_quant8_6 test
+#include "generated/examples/strided_slice_quant8_6.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_quant8_6.model.cpp"
+} // namespace strided_slice_quant8_6
+TEST_F(GeneratedTests, strided_slice_quant8_6) {
+    execute(strided_slice_quant8_6::CreateModel,
+            strided_slice_quant8_6::is_ignored,
+            strided_slice_quant8_6::examples);
+}
+
+namespace strided_slice_quant8_7 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_quant8_7 test
+#include "generated/examples/strided_slice_quant8_7.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_quant8_7.model.cpp"
+} // namespace strided_slice_quant8_7
+TEST_F(GeneratedTests, strided_slice_quant8_7) {
+    execute(strided_slice_quant8_7::CreateModel,
+            strided_slice_quant8_7::is_ignored,
+            strided_slice_quant8_7::examples);
+}
+
+namespace strided_slice_quant8_8 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_quant8_8 test
+#include "generated/examples/strided_slice_quant8_8.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_quant8_8.model.cpp"
+} // namespace strided_slice_quant8_8
+TEST_F(GeneratedTests, strided_slice_quant8_8) {
+    execute(strided_slice_quant8_8::CreateModel,
+            strided_slice_quant8_8::is_ignored,
+            strided_slice_quant8_8::examples);
+}
+
+namespace strided_slice_quant8_9 {
+std::vector<MixedTypedExample> examples = {
+// Generated strided_slice_quant8_9 test
+#include "generated/examples/strided_slice_quant8_9.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/strided_slice_quant8_9.model.cpp"
+} // namespace strided_slice_quant8_9
+TEST_F(GeneratedTests, strided_slice_quant8_9) {
+    execute(strided_slice_quant8_9::CreateModel,
+            strided_slice_quant8_9::is_ignored,
+            strided_slice_quant8_9::examples);
+}
+
+namespace sub_broadcast_float {
+std::vector<MixedTypedExample> examples = {
+// Generated sub_broadcast_float test
+#include "generated/examples/sub_broadcast_float.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/sub_broadcast_float.model.cpp"
+} // namespace sub_broadcast_float
+TEST_F(GeneratedTests, sub_broadcast_float) {
+    execute(sub_broadcast_float::CreateModel,
+            sub_broadcast_float::is_ignored,
+            sub_broadcast_float::examples);
+}
+
+namespace sub {
+std::vector<MixedTypedExample> examples = {
+// Generated sub test
+#include "generated/examples/sub.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/sub.model.cpp"
+} // namespace sub
+TEST_F(GeneratedTests, sub) {
+    execute(sub::CreateModel,
+            sub::is_ignored,
+            sub::examples);
+}
+
+namespace transpose_float_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated transpose_float_1 test
+#include "generated/examples/transpose_float_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/transpose_float_1.model.cpp"
+} // namespace transpose_float_1
+TEST_F(GeneratedTests, transpose_float_1) {
+    execute(transpose_float_1::CreateModel,
+            transpose_float_1::is_ignored,
+            transpose_float_1::examples);
+}
+
+namespace transpose {
+std::vector<MixedTypedExample> examples = {
+// Generated transpose test
+#include "generated/examples/transpose.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/transpose.model.cpp"
+} // namespace transpose
+TEST_F(GeneratedTests, transpose) {
+    execute(transpose::CreateModel,
+            transpose::is_ignored,
+            transpose::examples);
+}
+
+namespace transpose_quant8_1 {
+std::vector<MixedTypedExample> examples = {
+// Generated transpose_quant8_1 test
+#include "generated/examples/transpose_quant8_1.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/transpose_quant8_1.model.cpp"
+} // namespace transpose_quant8_1
+TEST_F(GeneratedTests, transpose_quant8_1) {
+    execute(transpose_quant8_1::CreateModel,
+            transpose_quant8_1::is_ignored,
+            transpose_quant8_1::examples);
+}
+
+namespace cast_ex_float32_to_int32 {
+std::vector<MixedTypedExample> examples = {
+// Generated cast_ex_float32_to_int32 test
+#include "generated/examples/cast_ex_float32_to_int32.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/cast_ex_float32_to_int32.model.cpp"
+} // namespace cast_ex_float32_to_int32
+TEST_F(GeneratedTests, cast_ex_float32_to_int32) {
+    execute(cast_ex_float32_to_int32::CreateModel,
+            cast_ex_float32_to_int32::is_ignored,
+            cast_ex_float32_to_int32::examples);
+}
+
+namespace cast_ex_int32_to_float32 {
+std::vector<MixedTypedExample> examples = {
+// Generated cast_ex_int32_to_float32 test
+#include "generated/examples/cast_ex_int32_to_float32.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/cast_ex_int32_to_float32.model.cpp"
+} // namespace cast_ex_int32_to_float32
+TEST_F(GeneratedTests, cast_ex_int32_to_float32) {
+    execute(cast_ex_int32_to_float32::CreateModel,
+            cast_ex_int32_to_float32::is_ignored,
+            cast_ex_int32_to_float32::examples);
+}
+
+namespace gather_1D_float {
+std::vector<MixedTypedExample> examples = {
+// Generated gather_1D_float test
+#include "generated/examples/gather_1D_float.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/gather_1D_float.model.cpp"
+} // namespace gather_1D_float
+TEST_F(GeneratedTests, gather_1D_float) {
+    execute(gather_1D_float::CreateModel,
+            gather_1D_float::is_ignored,
+            gather_1D_float::examples);
+}
+
+namespace gather_1D_int32 {
+std::vector<MixedTypedExample> examples = {
+// Generated gather_1D_int32 test
+#include "generated/examples/gather_1D_int32.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/gather_1D_int32.model.cpp"
+} // namespace gather_1D_int32
+TEST_F(GeneratedTests, gather_1D_int32) {
+    execute(gather_1D_int32::CreateModel,
+            gather_1D_int32::is_ignored,
+            gather_1D_int32::examples);
+}
+
+namespace gather_1D_quant8 {
+std::vector<MixedTypedExample> examples = {
+// Generated gather_1D_quant8 test
+#include "generated/examples/gather_1D_quant8.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/gather_1D_quant8.model.cpp"
+} // namespace gather_1D_quant8
+TEST_F(GeneratedTests, gather_1D_quant8) {
+    execute(gather_1D_quant8::CreateModel,
+            gather_1D_quant8::is_ignored,
+            gather_1D_quant8::examples);
+}
+
+namespace gather_2D_float {
+std::vector<MixedTypedExample> examples = {
+// Generated gather_2D_float test
+#include "generated/examples/gather_2D_float.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/gather_2D_float.model.cpp"
+} // namespace gather_2D_float
+TEST_F(GeneratedTests, gather_2D_float) {
+    execute(gather_2D_float::CreateModel,
+            gather_2D_float::is_ignored,
+            gather_2D_float::examples);
+}
+
+namespace gather_2D_int32 {
+std::vector<MixedTypedExample> examples = {
+// Generated gather_2D_int32 test
+#include "generated/examples/gather_2D_int32.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/gather_2D_int32.model.cpp"
+} // namespace gather_2D_int32
+TEST_F(GeneratedTests, gather_2D_int32) {
+    execute(gather_2D_int32::CreateModel,
+            gather_2D_int32::is_ignored,
+            gather_2D_int32::examples);
+}
+
+namespace gather_2D_quant8 {
+std::vector<MixedTypedExample> examples = {
+// Generated gather_2D_quant8 test
+#include "generated/examples/gather_2D_quant8.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/gather_2D_quant8.model.cpp"
+} // namespace gather_2D_quant8
+TEST_F(GeneratedTests, gather_2D_quant8) {
+    execute(gather_2D_quant8::CreateModel,
+            gather_2D_quant8::is_ignored,
+            gather_2D_quant8::examples);
+}
+
+namespace tensorflowmax_ex_2D_float {
+std::vector<MixedTypedExample> examples = {
+// Generated tensorflowmax_ex_2D_float test
+#include "generated/examples/tensorflowmax_ex_2D_float.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/tensorflowmax_ex_2D_float.model.cpp"
+} // namespace tensorflowmax_ex_2D_float
+TEST_F(GeneratedTests, tensorflowmax_ex_2D_float) {
+    execute(tensorflowmax_ex_2D_float::CreateModel,
+            tensorflowmax_ex_2D_float::is_ignored,
+            tensorflowmax_ex_2D_float::examples);
+}
+
+namespace tensorflowmax_ex_2D_int32 {
+std::vector<MixedTypedExample> examples = {
+// Generated tensorflowmax_ex_2D_int32 test
+#include "generated/examples/tensorflowmax_ex_2D_int32.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/tensorflowmax_ex_2D_int32.model.cpp"
+} // namespace tensorflowmax_ex_2D_int32
+TEST_F(GeneratedTests, tensorflowmax_ex_2D_int32) {
+    execute(tensorflowmax_ex_2D_int32::CreateModel,
+            tensorflowmax_ex_2D_int32::is_ignored,
+            tensorflowmax_ex_2D_int32::examples);
+}
+
+namespace topk_v2_1D_float {
+std::vector<MixedTypedExample> examples = {
+// Generated topk_v2_1D_float test
+#include "generated/examples/topk_v2_1D_float.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/topk_v2_1D_float.model.cpp"
+} // namespace topk_v2_1D_float
+TEST_F(GeneratedTests, topk_v2_1D_float) {
+    execute(topk_v2_1D_float::CreateModel,
+            topk_v2_1D_float::is_ignored,
+            topk_v2_1D_float::examples);
+}
+
+namespace topk_v2_1D_int32 {
+std::vector<MixedTypedExample> examples = {
+// Generated topk_v2_1D_int32 test
+#include "generated/examples/topk_v2_1D_int32.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/topk_v2_1D_int32.model.cpp"
+} // namespace topk_v2_1D_int32
+TEST_F(GeneratedTests, topk_v2_1D_int32) {
+    execute(topk_v2_1D_int32::CreateModel,
+            topk_v2_1D_int32::is_ignored,
+            topk_v2_1D_int32::examples);
+}
+
+namespace topk_v2_1D_quant8 {
+std::vector<MixedTypedExample> examples = {
+// Generated topk_v2_1D_quant8 test
+#include "generated/examples/topk_v2_1D_quant8.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/topk_v2_1D_quant8.model.cpp"
+} // namespace topk_v2_1D_quant8
+TEST_F(GeneratedTests, topk_v2_1D_quant8) {
+    execute(topk_v2_1D_quant8::CreateModel,
+            topk_v2_1D_quant8::is_ignored,
+            topk_v2_1D_quant8::examples);
+}
+
+namespace topk_v2_2D_float {
+std::vector<MixedTypedExample> examples = {
+// Generated topk_v2_2D_float test
+#include "generated/examples/topk_v2_2D_float.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/topk_v2_2D_float.model.cpp"
+} // namespace topk_v2_2D_float
+TEST_F(GeneratedTests, topk_v2_2D_float) {
+    execute(topk_v2_2D_float::CreateModel,
+            topk_v2_2D_float::is_ignored,
+            topk_v2_2D_float::examples);
+}
+
+namespace topk_v2_2D_int32 {
+std::vector<MixedTypedExample> examples = {
+// Generated topk_v2_2D_int32 test
+#include "generated/examples/topk_v2_2D_int32.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/topk_v2_2D_int32.model.cpp"
+} // namespace topk_v2_2D_int32
+TEST_F(GeneratedTests, topk_v2_2D_int32) {
+    execute(topk_v2_2D_int32::CreateModel,
+            topk_v2_2D_int32::is_ignored,
+            topk_v2_2D_int32::examples);
+}
+
+namespace topk_v2_2D_quant8 {
+std::vector<MixedTypedExample> examples = {
+// Generated topk_v2_2D_quant8 test
+#include "generated/examples/topk_v2_2D_quant8.example.cpp"
+};
+// Generated model constructor
+#include "generated/models/topk_v2_2D_quant8.model.cpp"
+} // namespace topk_v2_2D_quant8
+TEST_F(GeneratedTests, topk_v2_2D_quant8) {
+    execute(topk_v2_2D_quant8::CreateModel,
+            topk_v2_2D_quant8::is_ignored,
+            topk_v2_2D_quant8::examples);
+}