test/generated/all_generated_tests.cpp

// DO NOT EDIT;
// Generated by ml/nn/runtime/test/specs/generate_test.sh

namespace add_broadcast_quant8 {
std::vector<MixedTypedExample> examples = {
// Generated add_broadcast_quant8 test
#include "generated/examples/add_broadcast_quant8.example.cpp"
};
// Generated model constructor
#include "generated/models/add_broadcast_quant8.model.cpp"
} // namespace add_broadcast_quant8
TEST_F(GeneratedTests, add_broadcast_quant8) {
    execute(add_broadcast_quant8::CreateModel,
            add_broadcast_quant8::is_ignored,
            add_broadcast_quant8::examples);
}

namespace add {
std::vector<MixedTypedExample> examples = {
// Generated add test
#include "generated/examples/add.example.cpp"
};
// Generated model constructor
#include "generated/models/add.model.cpp"
} // namespace add
TEST_F(GeneratedTests, add) {
    execute(add::CreateModel,
            add::is_ignored,
            add::examples);
}

namespace add_quant8 {
std::vector<MixedTypedExample> examples = {
// Generated add_quant8 test
#include "generated/examples/add_quant8.example.cpp"
};
// Generated model constructor
#include "generated/models/add_quant8.model.cpp"
} // namespace add_quant8
TEST_F(GeneratedTests, add_quant8) {
    execute(add_quant8::CreateModel,
            add_quant8::is_ignored,
            add_quant8::examples);
}

namespace avg_pool_float_1 {
std::vector<MixedTypedExample> examples = {
// Generated avg_pool_float_1 test
#include "generated/examples/avg_pool_float_1.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_float_1.model.cpp"
} // namespace avg_pool_float_1
TEST_F(GeneratedTests, avg_pool_float_1) {
    execute(avg_pool_float_1::CreateModel,
            avg_pool_float_1::is_ignored,
            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
#include "generated/examples/avg_pool_float_3.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_float_3.model.cpp"
} // namespace avg_pool_float_3
TEST_F(GeneratedTests, avg_pool_float_3) {
    execute(avg_pool_float_3::CreateModel,
            avg_pool_float_3::is_ignored,
            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
#include "generated/examples/avg_pool_float_5.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_float_5.model.cpp"
} // namespace avg_pool_float_5
TEST_F(GeneratedTests, avg_pool_float_5) {
    execute(avg_pool_float_5::CreateModel,
            avg_pool_float_5::is_ignored,
            avg_pool_float_5::examples);
}

namespace avg_pool_quant8_1 {
std::vector<MixedTypedExample> examples = {
// Generated avg_pool_quant8_1 test
#include "generated/examples/avg_pool_quant8_1.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_quant8_1.model.cpp"
} // namespace avg_pool_quant8_1
TEST_F(GeneratedTests, avg_pool_quant8_1) {
    execute(avg_pool_quant8_1::CreateModel,
            avg_pool_quant8_1::is_ignored,
            avg_pool_quant8_1::examples);
}

namespace avg_pool_quant8_2 {
std::vector<MixedTypedExample> examples = {
// Generated avg_pool_quant8_2 test
#include "generated/examples/avg_pool_quant8_2.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_quant8_2.model.cpp"
} // namespace avg_pool_quant8_2
TEST_F(GeneratedTests, avg_pool_quant8_2) {
    execute(avg_pool_quant8_2::CreateModel,
            avg_pool_quant8_2::is_ignored,
            avg_pool_quant8_2::examples);
}

namespace avg_pool_quant8_3 {
std::vector<MixedTypedExample> examples = {
// Generated avg_pool_quant8_3 test
#include "generated/examples/avg_pool_quant8_3.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_quant8_3.model.cpp"
} // namespace avg_pool_quant8_3
TEST_F(GeneratedTests, avg_pool_quant8_3) {
    execute(avg_pool_quant8_3::CreateModel,
            avg_pool_quant8_3::is_ignored,
            avg_pool_quant8_3::examples);
}

namespace avg_pool_quant8_4 {
std::vector<MixedTypedExample> examples = {
// Generated avg_pool_quant8_4 test
#include "generated/examples/avg_pool_quant8_4.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_quant8_4.model.cpp"
} // namespace avg_pool_quant8_4
TEST_F(GeneratedTests, avg_pool_quant8_4) {
    execute(avg_pool_quant8_4::CreateModel,
            avg_pool_quant8_4::is_ignored,
            avg_pool_quant8_4::examples);
}

namespace avg_pool_quant8_5 {
std::vector<MixedTypedExample> examples = {
// Generated avg_pool_quant8_5 test
#include "generated/examples/avg_pool_quant8_5.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_quant8_5.model.cpp"
} // namespace avg_pool_quant8_5
TEST_F(GeneratedTests, avg_pool_quant8_5) {
    execute(avg_pool_quant8_5::CreateModel,
            avg_pool_quant8_5::is_ignored,
            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_quant8_1 {
std::vector<MixedTypedExample> examples = {
// Generated concat_quant8_1 test
#include "generated/examples/concat_quant8_1.example.cpp"
};
// Generated model constructor
#include "generated/models/concat_quant8_1.model.cpp"
} // namespace concat_quant8_1
TEST_F(GeneratedTests, concat_quant8_1) {
    execute(concat_quant8_1::CreateModel,
            concat_quant8_1::is_ignored,
            concat_quant8_1::examples);
}

namespace concat_quant8_2 {
std::vector<MixedTypedExample> examples = {
// Generated concat_quant8_2 test
#include "generated/examples/concat_quant8_2.example.cpp"
};
// Generated model constructor
#include "generated/models/concat_quant8_2.model.cpp"
} // namespace concat_quant8_2
TEST_F(GeneratedTests, concat_quant8_2) {
    execute(concat_quant8_2::CreateModel,
            concat_quant8_2::is_ignored,
            concat_quant8_2::examples);
}

namespace concat_quant8_3 {
std::vector<MixedTypedExample> examples = {
// Generated concat_quant8_3 test
#include "generated/examples/concat_quant8_3.example.cpp"
};
// Generated model constructor
#include "generated/models/concat_quant8_3.model.cpp"
} // namespace concat_quant8_3
TEST_F(GeneratedTests, concat_quant8_3) {
    execute(concat_quant8_3::CreateModel,
            concat_quant8_3::is_ignored,
            concat_quant8_3::examples);
}

namespace conv_1_h3_w2_SAME {
std::vector<MixedTypedExample> examples = {
// Generated conv_1_h3_w2_SAME test
#include "generated/examples/conv_1_h3_w2_SAME.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_1_h3_w2_SAME.model.cpp"
} // namespace conv_1_h3_w2_SAME
TEST_F(GeneratedTests, conv_1_h3_w2_SAME) {
    execute(conv_1_h3_w2_SAME::CreateModel,
            conv_1_h3_w2_SAME::is_ignored,
            conv_1_h3_w2_SAME::examples);
}

namespace conv_1_h3_w2_VALID {
std::vector<MixedTypedExample> examples = {
// Generated conv_1_h3_w2_VALID test
#include "generated/examples/conv_1_h3_w2_VALID.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_1_h3_w2_VALID.model.cpp"
} // namespace conv_1_h3_w2_VALID
TEST_F(GeneratedTests, conv_1_h3_w2_VALID) {
    execute(conv_1_h3_w2_VALID::CreateModel,
            conv_1_h3_w2_VALID::is_ignored,
            conv_1_h3_w2_VALID::examples);
}

namespace conv_3_h3_w2_SAME {
std::vector<MixedTypedExample> examples = {
// Generated conv_3_h3_w2_SAME test
#include "generated/examples/conv_3_h3_w2_SAME.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_3_h3_w2_SAME.model.cpp"
} // namespace conv_3_h3_w2_SAME
TEST_F(GeneratedTests, conv_3_h3_w2_SAME) {
    execute(conv_3_h3_w2_SAME::CreateModel,
            conv_3_h3_w2_SAME::is_ignored,
            conv_3_h3_w2_SAME::examples);
}

namespace conv_3_h3_w2_VALID {
std::vector<MixedTypedExample> examples = {
// Generated conv_3_h3_w2_VALID test
#include "generated/examples/conv_3_h3_w2_VALID.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_3_h3_w2_VALID.model.cpp"
} // namespace conv_3_h3_w2_VALID
TEST_F(GeneratedTests, conv_3_h3_w2_VALID) {
    execute(conv_3_h3_w2_VALID::CreateModel,
            conv_3_h3_w2_VALID::is_ignored,
            conv_3_h3_w2_VALID::examples);
}

namespace conv_float_2 {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_2 test
#include "generated/examples/conv_float_2.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_2.model.cpp"
} // namespace conv_float_2
TEST_F(GeneratedTests, conv_float_2) {
    execute(conv_float_2::CreateModel,
            conv_float_2::is_ignored,
            conv_float_2::examples);
}

namespace conv_float_channels {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_channels test
#include "generated/examples/conv_float_channels.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_channels.model.cpp"
} // namespace conv_float_channels
TEST_F(GeneratedTests, conv_float_channels) {
    execute(conv_float_channels::CreateModel,
            conv_float_channels::is_ignored,
            conv_float_channels::examples);
}

namespace conv_float_channels_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_channels_weights_as_inputs test
#include "generated/examples/conv_float_channels_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_channels_weights_as_inputs.model.cpp"
} // namespace conv_float_channels_weights_as_inputs
TEST_F(GeneratedTests, conv_float_channels_weights_as_inputs) {
    execute(conv_float_channels_weights_as_inputs::CreateModel,
            conv_float_channels_weights_as_inputs::is_ignored,
            conv_float_channels_weights_as_inputs::examples);
}

namespace conv_float_large {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_large test
#include "generated/examples/conv_float_large.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_large.model.cpp"
} // namespace conv_float_large
TEST_F(GeneratedTests, conv_float_large) {
    execute(conv_float_large::CreateModel,
            conv_float_large::is_ignored,
            conv_float_large::examples);
}

namespace conv_float_large_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_large_weights_as_inputs test
#include "generated/examples/conv_float_large_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_large_weights_as_inputs.model.cpp"
} // namespace conv_float_large_weights_as_inputs
TEST_F(GeneratedTests, conv_float_large_weights_as_inputs) {
    execute(conv_float_large_weights_as_inputs::CreateModel,
            conv_float_large_weights_as_inputs::is_ignored,
            conv_float_large_weights_as_inputs::examples);
}

namespace conv_float {
std::vector<MixedTypedExample> examples = {
// Generated conv_float test
#include "generated/examples/conv_float.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float.model.cpp"
} // namespace conv_float
TEST_F(GeneratedTests, conv_float) {
    execute(conv_float::CreateModel,
            conv_float::is_ignored,
            conv_float::examples);
}

namespace conv_float_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_weights_as_inputs test
#include "generated/examples/conv_float_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_weights_as_inputs.model.cpp"
} // namespace conv_float_weights_as_inputs
TEST_F(GeneratedTests, conv_float_weights_as_inputs) {
    execute(conv_float_weights_as_inputs::CreateModel,
            conv_float_weights_as_inputs::is_ignored,
            conv_float_weights_as_inputs::examples);
}

namespace conv_quant8_2 {
std::vector<MixedTypedExample> examples = {
// Generated conv_quant8_2 test
#include "generated/examples/conv_quant8_2.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_quant8_2.model.cpp"
} // namespace conv_quant8_2
TEST_F(GeneratedTests, conv_quant8_2) {
    execute(conv_quant8_2::CreateModel,
            conv_quant8_2::is_ignored,
            conv_quant8_2::examples);
}

namespace conv_quant8_channels {
std::vector<MixedTypedExample> examples = {
// Generated conv_quant8_channels test
#include "generated/examples/conv_quant8_channels.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_quant8_channels.model.cpp"
} // namespace conv_quant8_channels
TEST_F(GeneratedTests, conv_quant8_channels) {
    execute(conv_quant8_channels::CreateModel,
            conv_quant8_channels::is_ignored,
            conv_quant8_channels::examples);
}

namespace conv_quant8_channels_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated conv_quant8_channels_weights_as_inputs test
#include "generated/examples/conv_quant8_channels_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_quant8_channels_weights_as_inputs.model.cpp"
} // namespace conv_quant8_channels_weights_as_inputs
TEST_F(GeneratedTests, conv_quant8_channels_weights_as_inputs) {
    execute(conv_quant8_channels_weights_as_inputs::CreateModel,
            conv_quant8_channels_weights_as_inputs::is_ignored,
            conv_quant8_channels_weights_as_inputs::examples);
}

namespace conv_quant8_large {
std::vector<MixedTypedExample> examples = {
// Generated conv_quant8_large test
#include "generated/examples/conv_quant8_large.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_quant8_large.model.cpp"
} // namespace conv_quant8_large
TEST_F(GeneratedTests, conv_quant8_large) {
    execute(conv_quant8_large::CreateModel,
            conv_quant8_large::is_ignored,
            conv_quant8_large::examples);
}

namespace conv_quant8_large_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated conv_quant8_large_weights_as_inputs test
#include "generated/examples/conv_quant8_large_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_quant8_large_weights_as_inputs.model.cpp"
} // namespace conv_quant8_large_weights_as_inputs
TEST_F(GeneratedTests, conv_quant8_large_weights_as_inputs) {
    execute(conv_quant8_large_weights_as_inputs::CreateModel,
            conv_quant8_large_weights_as_inputs::is_ignored,
            conv_quant8_large_weights_as_inputs::examples);
}

namespace conv_quant8 {
std::vector<MixedTypedExample> examples = {
// Generated conv_quant8 test
#include "generated/examples/conv_quant8.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_quant8.model.cpp"
} // namespace conv_quant8
TEST_F(GeneratedTests, conv_quant8) {
    execute(conv_quant8::CreateModel,
            conv_quant8::is_ignored,
            conv_quant8::examples);
}

namespace conv_quant8_overflow {
std::vector<MixedTypedExample> examples = {
// Generated conv_quant8_overflow test
#include "generated/examples/conv_quant8_overflow.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_quant8_overflow.model.cpp"
} // namespace conv_quant8_overflow
TEST_F(GeneratedTests, conv_quant8_overflow) {
    execute(conv_quant8_overflow::CreateModel,
            conv_quant8_overflow::is_ignored,
            conv_quant8_overflow::examples);
}

namespace conv_quant8_overflow_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated conv_quant8_overflow_weights_as_inputs test
#include "generated/examples/conv_quant8_overflow_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_quant8_overflow_weights_as_inputs.model.cpp"
} // namespace conv_quant8_overflow_weights_as_inputs
TEST_F(GeneratedTests, conv_quant8_overflow_weights_as_inputs) {
    execute(conv_quant8_overflow_weights_as_inputs::CreateModel,
            conv_quant8_overflow_weights_as_inputs::is_ignored,
            conv_quant8_overflow_weights_as_inputs::examples);
}

namespace conv_quant8_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated conv_quant8_weights_as_inputs test
#include "generated/examples/conv_quant8_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_quant8_weights_as_inputs.model.cpp"
} // namespace conv_quant8_weights_as_inputs
TEST_F(GeneratedTests, conv_quant8_weights_as_inputs) {
    execute(conv_quant8_weights_as_inputs::CreateModel,
            conv_quant8_weights_as_inputs::is_ignored,
            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
#include "generated/examples/depthwise_conv2d_float_2.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_2.model.cpp"
} // namespace depthwise_conv2d_float_2
TEST_F(GeneratedTests, depthwise_conv2d_float_2) {
    execute(depthwise_conv2d_float_2::CreateModel,
            depthwise_conv2d_float_2::is_ignored,
            depthwise_conv2d_float_2::examples);
}

namespace depthwise_conv2d_float_large_2 {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float_large_2 test
#include "generated/examples/depthwise_conv2d_float_large_2.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_large_2.model.cpp"
} // namespace depthwise_conv2d_float_large_2
TEST_F(GeneratedTests, depthwise_conv2d_float_large_2) {
    execute(depthwise_conv2d_float_large_2::CreateModel,
            depthwise_conv2d_float_large_2::is_ignored,
            depthwise_conv2d_float_large_2::examples);
}

namespace depthwise_conv2d_float_large_2_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float_large_2_weights_as_inputs test
#include "generated/examples/depthwise_conv2d_float_large_2_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_large_2_weights_as_inputs.model.cpp"
} // namespace depthwise_conv2d_float_large_2_weights_as_inputs
TEST_F(GeneratedTests, depthwise_conv2d_float_large_2_weights_as_inputs) {
    execute(depthwise_conv2d_float_large_2_weights_as_inputs::CreateModel,
            depthwise_conv2d_float_large_2_weights_as_inputs::is_ignored,
            depthwise_conv2d_float_large_2_weights_as_inputs::examples);
}

namespace depthwise_conv2d_float_large {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float_large test
#include "generated/examples/depthwise_conv2d_float_large.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_large.model.cpp"
} // namespace depthwise_conv2d_float_large
TEST_F(GeneratedTests, depthwise_conv2d_float_large) {
    execute(depthwise_conv2d_float_large::CreateModel,
            depthwise_conv2d_float_large::is_ignored,
            depthwise_conv2d_float_large::examples);
}

namespace depthwise_conv2d_float_large_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float_large_weights_as_inputs test
#include "generated/examples/depthwise_conv2d_float_large_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_large_weights_as_inputs.model.cpp"
} // namespace depthwise_conv2d_float_large_weights_as_inputs
TEST_F(GeneratedTests, depthwise_conv2d_float_large_weights_as_inputs) {
    execute(depthwise_conv2d_float_large_weights_as_inputs::CreateModel,
            depthwise_conv2d_float_large_weights_as_inputs::is_ignored,
            depthwise_conv2d_float_large_weights_as_inputs::examples);
}

namespace depthwise_conv2d_float {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float test
#include "generated/examples/depthwise_conv2d_float.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float.model.cpp"
} // namespace depthwise_conv2d_float
TEST_F(GeneratedTests, depthwise_conv2d_float) {
    execute(depthwise_conv2d_float::CreateModel,
            depthwise_conv2d_float::is_ignored,
            depthwise_conv2d_float::examples);
}

namespace depthwise_conv2d_float_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float_weights_as_inputs test
#include "generated/examples/depthwise_conv2d_float_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_weights_as_inputs.model.cpp"
} // namespace depthwise_conv2d_float_weights_as_inputs
TEST_F(GeneratedTests, depthwise_conv2d_float_weights_as_inputs) {
    execute(depthwise_conv2d_float_weights_as_inputs::CreateModel,
            depthwise_conv2d_float_weights_as_inputs::is_ignored,
            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
#include "generated/examples/depthwise_conv.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv.model.cpp"
} // namespace depthwise_conv
TEST_F(GeneratedTests, depthwise_conv) {
    execute(depthwise_conv::CreateModel,
            depthwise_conv::is_ignored,
            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 {
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_2 {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_float_2 test
#include "generated/examples/fully_connected_float_2.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_float_2.model.cpp"
} // namespace fully_connected_float_2
TEST_F(GeneratedTests, fully_connected_float_2) {
    execute(fully_connected_float_2::CreateModel,
            fully_connected_float_2::is_ignored,
            fully_connected_float_2::examples);
}

namespace fully_connected_float_large {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_float_large test
#include "generated/examples/fully_connected_float_large.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_float_large.model.cpp"
} // namespace fully_connected_float_large
TEST_F(GeneratedTests, fully_connected_float_large) {
    execute(fully_connected_float_large::CreateModel,
            fully_connected_float_large::is_ignored,
            fully_connected_float_large::examples);
}

namespace fully_connected_float_large_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_float_large_weights_as_inputs test
#include "generated/examples/fully_connected_float_large_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_float_large_weights_as_inputs.model.cpp"
} // namespace fully_connected_float_large_weights_as_inputs
TEST_F(GeneratedTests, fully_connected_float_large_weights_as_inputs) {
    execute(fully_connected_float_large_weights_as_inputs::CreateModel,
            fully_connected_float_large_weights_as_inputs::is_ignored,
            fully_connected_float_large_weights_as_inputs::examples);
}

namespace fully_connected_float {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_float test
#include "generated/examples/fully_connected_float.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_float.model.cpp"
} // namespace fully_connected_float
TEST_F(GeneratedTests, fully_connected_float) {
    execute(fully_connected_float::CreateModel,
            fully_connected_float::is_ignored,
            fully_connected_float::examples);
}

namespace fully_connected_float_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_float_weights_as_inputs test
#include "generated/examples/fully_connected_float_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_float_weights_as_inputs.model.cpp"
} // namespace fully_connected_float_weights_as_inputs
TEST_F(GeneratedTests, fully_connected_float_weights_as_inputs) {
    execute(fully_connected_float_weights_as_inputs::CreateModel,
            fully_connected_float_weights_as_inputs::is_ignored,
            fully_connected_float_weights_as_inputs::examples);
}

namespace fully_connected_quant8_2 {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_quant8_2 test
#include "generated/examples/fully_connected_quant8_2.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_quant8_2.model.cpp"
} // namespace fully_connected_quant8_2
TEST_F(GeneratedTests, fully_connected_quant8_2) {
    execute(fully_connected_quant8_2::CreateModel,
            fully_connected_quant8_2::is_ignored,
            fully_connected_quant8_2::examples);
}

namespace fully_connected_quant8_large {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_quant8_large test
#include "generated/examples/fully_connected_quant8_large.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_quant8_large.model.cpp"
} // namespace fully_connected_quant8_large
TEST_F(GeneratedTests, fully_connected_quant8_large) {
    execute(fully_connected_quant8_large::CreateModel,
            fully_connected_quant8_large::is_ignored,
            fully_connected_quant8_large::examples);
}

namespace fully_connected_quant8_large_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_quant8_large_weights_as_inputs test
#include "generated/examples/fully_connected_quant8_large_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_quant8_large_weights_as_inputs.model.cpp"
} // namespace fully_connected_quant8_large_weights_as_inputs
TEST_F(GeneratedTests, fully_connected_quant8_large_weights_as_inputs) {
    execute(fully_connected_quant8_large_weights_as_inputs::CreateModel,
            fully_connected_quant8_large_weights_as_inputs::is_ignored,
            fully_connected_quant8_large_weights_as_inputs::examples);
}

namespace fully_connected_quant8 {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_quant8 test
#include "generated/examples/fully_connected_quant8.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_quant8.model.cpp"
} // namespace fully_connected_quant8
TEST_F(GeneratedTests, fully_connected_quant8) {
    execute(fully_connected_quant8::CreateModel,
            fully_connected_quant8::is_ignored,
            fully_connected_quant8::examples);
}

namespace fully_connected_quant8_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_quant8_weights_as_inputs test
#include "generated/examples/fully_connected_quant8_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_quant8_weights_as_inputs.model.cpp"
} // namespace fully_connected_quant8_weights_as_inputs
TEST_F(GeneratedTests, fully_connected_quant8_weights_as_inputs) {
    execute(fully_connected_quant8_weights_as_inputs::CreateModel,
            fully_connected_quant8_weights_as_inputs::is_ignored,
            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
#include "generated/examples/max_pool_float_1.example.cpp"
};
// Generated model constructor
#include "generated/models/max_pool_float_1.model.cpp"
} // namespace max_pool_float_1
TEST_F(GeneratedTests, max_pool_float_1) {
    execute(max_pool_float_1::CreateModel,
            max_pool_float_1::is_ignored,
            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
#include "generated/examples/max_pool_float_4.example.cpp"
};
// Generated model constructor
#include "generated/models/max_pool_float_4.model.cpp"
} // namespace max_pool_float_4
TEST_F(GeneratedTests, max_pool_float_4) {
    execute(max_pool_float_4::CreateModel,
            max_pool_float_4::is_ignored,
            max_pool_float_4::examples);
}

namespace max_pool_quant8_1 {
std::vector<MixedTypedExample> examples = {
// Generated max_pool_quant8_1 test
#include "generated/examples/max_pool_quant8_1.example.cpp"
};
// Generated model constructor
#include "generated/models/max_pool_quant8_1.model.cpp"
} // namespace max_pool_quant8_1
TEST_F(GeneratedTests, max_pool_quant8_1) {
    execute(max_pool_quant8_1::CreateModel,
            max_pool_quant8_1::is_ignored,
            max_pool_quant8_1::examples);
}

namespace max_pool_quant8_2 {
std::vector<MixedTypedExample> examples = {
// Generated max_pool_quant8_2 test
#include "generated/examples/max_pool_quant8_2.example.cpp"
};
// Generated model constructor
#include "generated/models/max_pool_quant8_2.model.cpp"
} // namespace max_pool_quant8_2
TEST_F(GeneratedTests, max_pool_quant8_2) {
    execute(max_pool_quant8_2::CreateModel,
            max_pool_quant8_2::is_ignored,
            max_pool_quant8_2::examples);
}

namespace max_pool_quant8_3 {
std::vector<MixedTypedExample> examples = {
// Generated max_pool_quant8_3 test
#include "generated/examples/max_pool_quant8_3.example.cpp"
};
// Generated model constructor
#include "generated/models/max_pool_quant8_3.model.cpp"
} // namespace max_pool_quant8_3
TEST_F(GeneratedTests, max_pool_quant8_3) {
    execute(max_pool_quant8_3::CreateModel,
            max_pool_quant8_3::is_ignored,
            max_pool_quant8_3::examples);
}

namespace max_pool_quant8_4 {
std::vector<MixedTypedExample> examples = {
// Generated max_pool_quant8_4 test
#include "generated/examples/max_pool_quant8_4.example.cpp"
};
// Generated model constructor
#include "generated/models/max_pool_quant8_4.model.cpp"
} // namespace max_pool_quant8_4
TEST_F(GeneratedTests, max_pool_quant8_4) {
    execute(max_pool_quant8_4::CreateModel,
            max_pool_quant8_4::is_ignored,
            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_quant8 {
std::vector<MixedTypedExample> examples = {
// Generated mul_broadcast_quant8 test
#include "generated/examples/mul_broadcast_quant8.example.cpp"
};
// Generated model constructor
#include "generated/models/mul_broadcast_quant8.model.cpp"
} // namespace mul_broadcast_quant8
TEST_F(GeneratedTests, mul_broadcast_quant8) {
    execute(mul_broadcast_quant8::CreateModel,
            mul_broadcast_quant8::is_ignored,
            mul_broadcast_quant8::examples);
}

namespace mul {
std::vector<MixedTypedExample> examples = {
// Generated mul test
#include "generated/examples/mul.example.cpp"
};
// Generated model constructor
#include "generated/models/mul.model.cpp"
} // namespace mul
TEST_F(GeneratedTests, mul) {
    execute(mul::CreateModel,
            mul::is_ignored,
            mul::examples);
}

namespace mul_quant8 {
std::vector<MixedTypedExample> examples = {
// Generated mul_quant8 test
#include "generated/examples/mul_quant8.example.cpp"
};
// Generated model constructor
#include "generated/models/mul_quant8.model.cpp"
} // namespace mul_quant8
TEST_F(GeneratedTests, mul_quant8) {
    execute(mul_quant8::CreateModel,
            mul_quant8::is_ignored,
            mul_quant8::examples);
}

namespace mul_relu {
std::vector<MixedTypedExample> examples = {
// Generated mul_relu test
#include "generated/examples/mul_relu.example.cpp"
};
// Generated model constructor
#include "generated/models/mul_relu.model.cpp"
} // namespace mul_relu
TEST_F(GeneratedTests, mul_relu) {
    execute(mul_relu::CreateModel,
            mul_relu::is_ignored,
            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
#include "generated/examples/relu6_float_1.example.cpp"
};
// Generated model constructor
#include "generated/models/relu6_float_1.model.cpp"
} // namespace relu6_float_1
TEST_F(GeneratedTests, relu6_float_1) {
    execute(relu6_float_1::CreateModel,
            relu6_float_1::is_ignored,
            relu6_float_1::examples);
}

namespace relu6_float_2 {
std::vector<MixedTypedExample> examples = {
// Generated relu6_float_2 test
#include "generated/examples/relu6_float_2.example.cpp"
};
// Generated model constructor
#include "generated/models/relu6_float_2.model.cpp"
} // namespace relu6_float_2
TEST_F(GeneratedTests, relu6_float_2) {
    execute(relu6_float_2::CreateModel,
            relu6_float_2::is_ignored,
            relu6_float_2::examples);
}

namespace relu6_quant8_1 {
std::vector<MixedTypedExample> examples = {
// Generated relu6_quant8_1 test
#include "generated/examples/relu6_quant8_1.example.cpp"
};
// Generated model constructor
#include "generated/models/relu6_quant8_1.model.cpp"
} // namespace relu6_quant8_1
TEST_F(GeneratedTests, relu6_quant8_1) {
    execute(relu6_quant8_1::CreateModel,
            relu6_quant8_1::is_ignored,
            relu6_quant8_1::examples);
}

namespace relu6_quant8_2 {
std::vector<MixedTypedExample> examples = {
// Generated relu6_quant8_2 test
#include "generated/examples/relu6_quant8_2.example.cpp"
};
// Generated model constructor
#include "generated/models/relu6_quant8_2.model.cpp"
} // namespace relu6_quant8_2
TEST_F(GeneratedTests, relu6_quant8_2) {
    execute(relu6_quant8_2::CreateModel,
            relu6_quant8_2::is_ignored,
            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
#include "generated/examples/reshape.example.cpp"
};
// Generated model constructor
#include "generated/models/reshape.model.cpp"
} // namespace reshape
TEST_F(GeneratedTests, reshape) {
    execute(reshape::CreateModel,
            reshape::is_ignored,
            reshape::examples);
}

namespace reshape_quant8 {
std::vector<MixedTypedExample> examples = {
// Generated reshape_quant8 test
#include "generated/examples/reshape_quant8.example.cpp"
};
// Generated model constructor
#include "generated/models/reshape_quant8.model.cpp"
} // namespace reshape_quant8
TEST_F(GeneratedTests, reshape_quant8) {
    execute(reshape_quant8::CreateModel,
            reshape_quant8::is_ignored,
            reshape_quant8::examples);
}

namespace reshape_quant8_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated reshape_quant8_weights_as_inputs test
#include "generated/examples/reshape_quant8_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/reshape_quant8_weights_as_inputs.model.cpp"
} // namespace reshape_quant8_weights_as_inputs
TEST_F(GeneratedTests, reshape_quant8_weights_as_inputs) {
    execute(reshape_quant8_weights_as_inputs::CreateModel,
            reshape_quant8_weights_as_inputs::is_ignored,
            reshape_quant8_weights_as_inputs::examples);
}

namespace reshape_weights_as_inputs {
std::vector<MixedTypedExample> examples = {
// Generated reshape_weights_as_inputs test
#include "generated/examples/reshape_weights_as_inputs.example.cpp"
};
// Generated model constructor
#include "generated/models/reshape_weights_as_inputs.model.cpp"
} // namespace reshape_weights_as_inputs
TEST_F(GeneratedTests, reshape_weights_as_inputs) {
    execute(reshape_weights_as_inputs::CreateModel,
            reshape_weights_as_inputs::is_ignored,
            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
#include "generated/examples/softmax_float_1.example.cpp"
};
// Generated model constructor
#include "generated/models/softmax_float_1.model.cpp"
} // namespace softmax_float_1
TEST_F(GeneratedTests, softmax_float_1) {
    execute(softmax_float_1::CreateModel,
            softmax_float_1::is_ignored,
            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
#include "generated/examples/softmax_quant8_1.example.cpp"
};
// Generated model constructor
#include "generated/models/softmax_quant8_1.model.cpp"
} // namespace softmax_quant8_1
TEST_F(GeneratedTests, softmax_quant8_1) {
    execute(softmax_quant8_1::CreateModel,
            softmax_quant8_1::is_ignored,
            softmax_quant8_1::examples);
}

namespace softmax_quant8_2 {
std::vector<MixedTypedExample> examples = {
// Generated softmax_quant8_2 test
#include "generated/examples/softmax_quant8_2.example.cpp"
};
// Generated model constructor
#include "generated/models/softmax_quant8_2.model.cpp"
} // namespace softmax_quant8_2
TEST_F(GeneratedTests, softmax_quant8_2) {
    execute(softmax_quant8_2::CreateModel,
            softmax_quant8_2::is_ignored,
            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 add_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated add_relaxed test
#include "generated/examples/add_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/add_relaxed.model.cpp"
} // namespace add_relaxed
TEST_F(GeneratedTests, add_relaxed) {
    execute(add_relaxed::CreateModel,
            add_relaxed::is_ignored,
            add_relaxed::examples);
}

namespace avg_pool_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated avg_pool_float_1_relaxed test
#include "generated/examples/avg_pool_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_float_1_relaxed.model.cpp"
} // namespace avg_pool_float_1_relaxed
TEST_F(GeneratedTests, avg_pool_float_1_relaxed) {
    execute(avg_pool_float_1_relaxed::CreateModel,
            avg_pool_float_1_relaxed::is_ignored,
            avg_pool_float_1_relaxed::examples);
}

namespace avg_pool_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated avg_pool_float_2_relaxed test
#include "generated/examples/avg_pool_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_float_2_relaxed.model.cpp"
} // namespace avg_pool_float_2_relaxed
TEST_F(GeneratedTests, avg_pool_float_2_relaxed) {
    execute(avg_pool_float_2_relaxed::CreateModel,
            avg_pool_float_2_relaxed::is_ignored,
            avg_pool_float_2_relaxed::examples);
}

namespace avg_pool_float_3_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated avg_pool_float_3_relaxed test
#include "generated/examples/avg_pool_float_3_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_float_3_relaxed.model.cpp"
} // namespace avg_pool_float_3_relaxed
TEST_F(GeneratedTests, avg_pool_float_3_relaxed) {
    execute(avg_pool_float_3_relaxed::CreateModel,
            avg_pool_float_3_relaxed::is_ignored,
            avg_pool_float_3_relaxed::examples);
}

namespace avg_pool_float_4_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated avg_pool_float_4_relaxed test
#include "generated/examples/avg_pool_float_4_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_float_4_relaxed.model.cpp"
} // namespace avg_pool_float_4_relaxed
TEST_F(GeneratedTests, avg_pool_float_4_relaxed) {
    execute(avg_pool_float_4_relaxed::CreateModel,
            avg_pool_float_4_relaxed::is_ignored,
            avg_pool_float_4_relaxed::examples);
}

namespace avg_pool_float_5_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated avg_pool_float_5_relaxed test
#include "generated/examples/avg_pool_float_5_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/avg_pool_float_5_relaxed.model.cpp"
} // namespace avg_pool_float_5_relaxed
TEST_F(GeneratedTests, avg_pool_float_5_relaxed) {
    execute(avg_pool_float_5_relaxed::CreateModel,
            avg_pool_float_5_relaxed::is_ignored,
            avg_pool_float_5_relaxed::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_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated batch_to_space_float_1_relaxed test
#include "generated/examples/batch_to_space_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/batch_to_space_float_1_relaxed.model.cpp"
} // namespace batch_to_space_float_1_relaxed
TEST_F(GeneratedTests, batch_to_space_float_1_relaxed) {
    execute(batch_to_space_float_1_relaxed::CreateModel,
            batch_to_space_float_1_relaxed::is_ignored,
            batch_to_space_float_1_relaxed::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 batch_to_space_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated batch_to_space_relaxed test
#include "generated/examples/batch_to_space_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/batch_to_space_relaxed.model.cpp"
} // namespace batch_to_space_relaxed
TEST_F(GeneratedTests, batch_to_space_relaxed) {
    execute(batch_to_space_relaxed::CreateModel,
            batch_to_space_relaxed::is_ignored,
            batch_to_space_relaxed::examples);
}

namespace concat_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated concat_float_1_relaxed test
#include "generated/examples/concat_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/concat_float_1_relaxed.model.cpp"
} // namespace concat_float_1_relaxed
TEST_F(GeneratedTests, concat_float_1_relaxed) {
    execute(concat_float_1_relaxed::CreateModel,
            concat_float_1_relaxed::is_ignored,
            concat_float_1_relaxed::examples);
}

namespace concat_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated concat_float_2_relaxed test
#include "generated/examples/concat_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/concat_float_2_relaxed.model.cpp"
} // namespace concat_float_2_relaxed
TEST_F(GeneratedTests, concat_float_2_relaxed) {
    execute(concat_float_2_relaxed::CreateModel,
            concat_float_2_relaxed::is_ignored,
            concat_float_2_relaxed::examples);
}

namespace concat_float_3_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated concat_float_3_relaxed test
#include "generated/examples/concat_float_3_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/concat_float_3_relaxed.model.cpp"
} // namespace concat_float_3_relaxed
TEST_F(GeneratedTests, concat_float_3_relaxed) {
    execute(concat_float_3_relaxed::CreateModel,
            concat_float_3_relaxed::is_ignored,
            concat_float_3_relaxed::examples);
}

namespace conv_1_h3_w2_SAME_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated conv_1_h3_w2_SAME_relaxed test
#include "generated/examples/conv_1_h3_w2_SAME_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_1_h3_w2_SAME_relaxed.model.cpp"
} // namespace conv_1_h3_w2_SAME_relaxed
TEST_F(GeneratedTests, conv_1_h3_w2_SAME_relaxed) {
    execute(conv_1_h3_w2_SAME_relaxed::CreateModel,
            conv_1_h3_w2_SAME_relaxed::is_ignored,
            conv_1_h3_w2_SAME_relaxed::examples);
}

namespace conv_1_h3_w2_VALID_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated conv_1_h3_w2_VALID_relaxed test
#include "generated/examples/conv_1_h3_w2_VALID_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_1_h3_w2_VALID_relaxed.model.cpp"
} // namespace conv_1_h3_w2_VALID_relaxed
TEST_F(GeneratedTests, conv_1_h3_w2_VALID_relaxed) {
    execute(conv_1_h3_w2_VALID_relaxed::CreateModel,
            conv_1_h3_w2_VALID_relaxed::is_ignored,
            conv_1_h3_w2_VALID_relaxed::examples);
}

namespace conv_3_h3_w2_SAME_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated conv_3_h3_w2_SAME_relaxed test
#include "generated/examples/conv_3_h3_w2_SAME_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_3_h3_w2_SAME_relaxed.model.cpp"
} // namespace conv_3_h3_w2_SAME_relaxed
TEST_F(GeneratedTests, conv_3_h3_w2_SAME_relaxed) {
    execute(conv_3_h3_w2_SAME_relaxed::CreateModel,
            conv_3_h3_w2_SAME_relaxed::is_ignored,
            conv_3_h3_w2_SAME_relaxed::examples);
}

namespace conv_3_h3_w2_VALID_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated conv_3_h3_w2_VALID_relaxed test
#include "generated/examples/conv_3_h3_w2_VALID_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_3_h3_w2_VALID_relaxed.model.cpp"
} // namespace conv_3_h3_w2_VALID_relaxed
TEST_F(GeneratedTests, conv_3_h3_w2_VALID_relaxed) {
    execute(conv_3_h3_w2_VALID_relaxed::CreateModel,
            conv_3_h3_w2_VALID_relaxed::is_ignored,
            conv_3_h3_w2_VALID_relaxed::examples);
}

namespace conv_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_2_relaxed test
#include "generated/examples/conv_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_2_relaxed.model.cpp"
} // namespace conv_float_2_relaxed
TEST_F(GeneratedTests, conv_float_2_relaxed) {
    execute(conv_float_2_relaxed::CreateModel,
            conv_float_2_relaxed::is_ignored,
            conv_float_2_relaxed::examples);
}

namespace conv_float_channels_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_channels_relaxed test
#include "generated/examples/conv_float_channels_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_channels_relaxed.model.cpp"
} // namespace conv_float_channels_relaxed
TEST_F(GeneratedTests, conv_float_channels_relaxed) {
    execute(conv_float_channels_relaxed::CreateModel,
            conv_float_channels_relaxed::is_ignored,
            conv_float_channels_relaxed::examples);
}

namespace conv_float_channels_weights_as_inputs_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_channels_weights_as_inputs_relaxed test
#include "generated/examples/conv_float_channels_weights_as_inputs_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_channels_weights_as_inputs_relaxed.model.cpp"
} // namespace conv_float_channels_weights_as_inputs_relaxed
TEST_F(GeneratedTests, conv_float_channels_weights_as_inputs_relaxed) {
    execute(conv_float_channels_weights_as_inputs_relaxed::CreateModel,
            conv_float_channels_weights_as_inputs_relaxed::is_ignored,
            conv_float_channels_weights_as_inputs_relaxed::examples);
}

namespace conv_float_large_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_large_relaxed test
#include "generated/examples/conv_float_large_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_large_relaxed.model.cpp"
} // namespace conv_float_large_relaxed
TEST_F(GeneratedTests, conv_float_large_relaxed) {
    execute(conv_float_large_relaxed::CreateModel,
            conv_float_large_relaxed::is_ignored,
            conv_float_large_relaxed::examples);
}

namespace conv_float_large_weights_as_inputs_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_large_weights_as_inputs_relaxed test
#include "generated/examples/conv_float_large_weights_as_inputs_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_large_weights_as_inputs_relaxed.model.cpp"
} // namespace conv_float_large_weights_as_inputs_relaxed
TEST_F(GeneratedTests, conv_float_large_weights_as_inputs_relaxed) {
    execute(conv_float_large_weights_as_inputs_relaxed::CreateModel,
            conv_float_large_weights_as_inputs_relaxed::is_ignored,
            conv_float_large_weights_as_inputs_relaxed::examples);
}

namespace conv_float_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_relaxed test
#include "generated/examples/conv_float_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_relaxed.model.cpp"
} // namespace conv_float_relaxed
TEST_F(GeneratedTests, conv_float_relaxed) {
    execute(conv_float_relaxed::CreateModel,
            conv_float_relaxed::is_ignored,
            conv_float_relaxed::examples);
}

namespace conv_float_weights_as_inputs_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated conv_float_weights_as_inputs_relaxed test
#include "generated/examples/conv_float_weights_as_inputs_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/conv_float_weights_as_inputs_relaxed.model.cpp"
} // namespace conv_float_weights_as_inputs_relaxed
TEST_F(GeneratedTests, conv_float_weights_as_inputs_relaxed) {
    execute(conv_float_weights_as_inputs_relaxed::CreateModel,
            conv_float_weights_as_inputs_relaxed::is_ignored,
            conv_float_weights_as_inputs_relaxed::examples);
}

namespace depth_to_space_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated depth_to_space_float_1_relaxed test
#include "generated/examples/depth_to_space_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/depth_to_space_float_1_relaxed.model.cpp"
} // namespace depth_to_space_float_1_relaxed
TEST_F(GeneratedTests, depth_to_space_float_1_relaxed) {
    execute(depth_to_space_float_1_relaxed::CreateModel,
            depth_to_space_float_1_relaxed::is_ignored,
            depth_to_space_float_1_relaxed::examples);
}

namespace depth_to_space_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated depth_to_space_float_2_relaxed test
#include "generated/examples/depth_to_space_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/depth_to_space_float_2_relaxed.model.cpp"
} // namespace depth_to_space_float_2_relaxed
TEST_F(GeneratedTests, depth_to_space_float_2_relaxed) {
    execute(depth_to_space_float_2_relaxed::CreateModel,
            depth_to_space_float_2_relaxed::is_ignored,
            depth_to_space_float_2_relaxed::examples);
}

namespace depth_to_space_float_3_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated depth_to_space_float_3_relaxed test
#include "generated/examples/depth_to_space_float_3_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/depth_to_space_float_3_relaxed.model.cpp"
} // namespace depth_to_space_float_3_relaxed
TEST_F(GeneratedTests, depth_to_space_float_3_relaxed) {
    execute(depth_to_space_float_3_relaxed::CreateModel,
            depth_to_space_float_3_relaxed::is_ignored,
            depth_to_space_float_3_relaxed::examples);
}

namespace depthwise_conv2d_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float_2_relaxed test
#include "generated/examples/depthwise_conv2d_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_2_relaxed.model.cpp"
} // namespace depthwise_conv2d_float_2_relaxed
TEST_F(GeneratedTests, depthwise_conv2d_float_2_relaxed) {
    execute(depthwise_conv2d_float_2_relaxed::CreateModel,
            depthwise_conv2d_float_2_relaxed::is_ignored,
            depthwise_conv2d_float_2_relaxed::examples);
}

namespace depthwise_conv2d_float_large_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float_large_2_relaxed test
#include "generated/examples/depthwise_conv2d_float_large_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_large_2_relaxed.model.cpp"
} // namespace depthwise_conv2d_float_large_2_relaxed
TEST_F(GeneratedTests, depthwise_conv2d_float_large_2_relaxed) {
    execute(depthwise_conv2d_float_large_2_relaxed::CreateModel,
            depthwise_conv2d_float_large_2_relaxed::is_ignored,
            depthwise_conv2d_float_large_2_relaxed::examples);
}

namespace depthwise_conv2d_float_large_2_weights_as_inputs_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float_large_2_weights_as_inputs_relaxed test
#include "generated/examples/depthwise_conv2d_float_large_2_weights_as_inputs_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_large_2_weights_as_inputs_relaxed.model.cpp"
} // namespace depthwise_conv2d_float_large_2_weights_as_inputs_relaxed
TEST_F(GeneratedTests, depthwise_conv2d_float_large_2_weights_as_inputs_relaxed) {
    execute(depthwise_conv2d_float_large_2_weights_as_inputs_relaxed::CreateModel,
            depthwise_conv2d_float_large_2_weights_as_inputs_relaxed::is_ignored,
            depthwise_conv2d_float_large_2_weights_as_inputs_relaxed::examples);
}

namespace depthwise_conv2d_float_large_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float_large_relaxed test
#include "generated/examples/depthwise_conv2d_float_large_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_large_relaxed.model.cpp"
} // namespace depthwise_conv2d_float_large_relaxed
TEST_F(GeneratedTests, depthwise_conv2d_float_large_relaxed) {
    execute(depthwise_conv2d_float_large_relaxed::CreateModel,
            depthwise_conv2d_float_large_relaxed::is_ignored,
            depthwise_conv2d_float_large_relaxed::examples);
}

namespace depthwise_conv2d_float_large_weights_as_inputs_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float_large_weights_as_inputs_relaxed test
#include "generated/examples/depthwise_conv2d_float_large_weights_as_inputs_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_large_weights_as_inputs_relaxed.model.cpp"
} // namespace depthwise_conv2d_float_large_weights_as_inputs_relaxed
TEST_F(GeneratedTests, depthwise_conv2d_float_large_weights_as_inputs_relaxed) {
    execute(depthwise_conv2d_float_large_weights_as_inputs_relaxed::CreateModel,
            depthwise_conv2d_float_large_weights_as_inputs_relaxed::is_ignored,
            depthwise_conv2d_float_large_weights_as_inputs_relaxed::examples);
}

namespace depthwise_conv2d_float_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float_relaxed test
#include "generated/examples/depthwise_conv2d_float_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_relaxed.model.cpp"
} // namespace depthwise_conv2d_float_relaxed
TEST_F(GeneratedTests, depthwise_conv2d_float_relaxed) {
    execute(depthwise_conv2d_float_relaxed::CreateModel,
            depthwise_conv2d_float_relaxed::is_ignored,
            depthwise_conv2d_float_relaxed::examples);
}

namespace depthwise_conv2d_float_weights_as_inputs_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv2d_float_weights_as_inputs_relaxed test
#include "generated/examples/depthwise_conv2d_float_weights_as_inputs_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv2d_float_weights_as_inputs_relaxed.model.cpp"
} // namespace depthwise_conv2d_float_weights_as_inputs_relaxed
TEST_F(GeneratedTests, depthwise_conv2d_float_weights_as_inputs_relaxed) {
    execute(depthwise_conv2d_float_weights_as_inputs_relaxed::CreateModel,
            depthwise_conv2d_float_weights_as_inputs_relaxed::is_ignored,
            depthwise_conv2d_float_weights_as_inputs_relaxed::examples);
}

namespace depthwise_conv_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated depthwise_conv_relaxed test
#include "generated/examples/depthwise_conv_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/depthwise_conv_relaxed.model.cpp"
} // namespace depthwise_conv_relaxed
TEST_F(GeneratedTests, depthwise_conv_relaxed) {
    execute(depthwise_conv_relaxed::CreateModel,
            depthwise_conv_relaxed::is_ignored,
            depthwise_conv_relaxed::examples);
}

namespace dequantize_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated dequantize_relaxed test
#include "generated/examples/dequantize_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/dequantize_relaxed.model.cpp"
} // namespace dequantize_relaxed
TEST_F(GeneratedTests, dequantize_relaxed) {
    execute(dequantize_relaxed::CreateModel,
            dequantize_relaxed::is_ignored,
            dequantize_relaxed::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_broadcast_float_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated div_broadcast_float_relaxed test
#include "generated/examples/div_broadcast_float_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/div_broadcast_float_relaxed.model.cpp"
} // namespace div_broadcast_float_relaxed
TEST_F(GeneratedTests, div_broadcast_float_relaxed) {
    execute(div_broadcast_float_relaxed::CreateModel,
            div_broadcast_float_relaxed::is_ignored,
            div_broadcast_float_relaxed::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 div_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated div_relaxed test
#include "generated/examples/div_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/div_relaxed.model.cpp"
} // namespace div_relaxed
TEST_F(GeneratedTests, div_relaxed) {
    execute(div_relaxed::CreateModel,
            div_relaxed::is_ignored,
            div_relaxed::examples);
}

namespace embedding_lookup_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated embedding_lookup_relaxed test
#include "generated/examples/embedding_lookup_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/embedding_lookup_relaxed.model.cpp"
} // namespace embedding_lookup_relaxed
TEST_F(GeneratedTests, embedding_lookup_relaxed) {
    execute(embedding_lookup_relaxed::CreateModel,
            embedding_lookup_relaxed::is_ignored,
            embedding_lookup_relaxed::examples);
}

namespace floor_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated floor_relaxed test
#include "generated/examples/floor_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/floor_relaxed.model.cpp"
} // namespace floor_relaxed
TEST_F(GeneratedTests, floor_relaxed) {
    execute(floor_relaxed::CreateModel,
            floor_relaxed::is_ignored,
            floor_relaxed::examples);
}

namespace fully_connected_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_float_2_relaxed test
#include "generated/examples/fully_connected_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_float_2_relaxed.model.cpp"
} // namespace fully_connected_float_2_relaxed
TEST_F(GeneratedTests, fully_connected_float_2_relaxed) {
    execute(fully_connected_float_2_relaxed::CreateModel,
            fully_connected_float_2_relaxed::is_ignored,
            fully_connected_float_2_relaxed::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 fully_connected_float_4d_simple_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_float_4d_simple_relaxed test
#include "generated/examples/fully_connected_float_4d_simple_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_float_4d_simple_relaxed.model.cpp"
} // namespace fully_connected_float_4d_simple_relaxed
TEST_F(GeneratedTests, fully_connected_float_4d_simple_relaxed) {
    execute(fully_connected_float_4d_simple_relaxed::CreateModel,
            fully_connected_float_4d_simple_relaxed::is_ignored,
            fully_connected_float_4d_simple_relaxed::examples);
}

namespace fully_connected_float_large_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_float_large_relaxed test
#include "generated/examples/fully_connected_float_large_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_float_large_relaxed.model.cpp"
} // namespace fully_connected_float_large_relaxed
TEST_F(GeneratedTests, fully_connected_float_large_relaxed) {
    execute(fully_connected_float_large_relaxed::CreateModel,
            fully_connected_float_large_relaxed::is_ignored,
            fully_connected_float_large_relaxed::examples);
}

namespace fully_connected_float_large_weights_as_inputs_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_float_large_weights_as_inputs_relaxed test
#include "generated/examples/fully_connected_float_large_weights_as_inputs_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_float_large_weights_as_inputs_relaxed.model.cpp"
} // namespace fully_connected_float_large_weights_as_inputs_relaxed
TEST_F(GeneratedTests, fully_connected_float_large_weights_as_inputs_relaxed) {
    execute(fully_connected_float_large_weights_as_inputs_relaxed::CreateModel,
            fully_connected_float_large_weights_as_inputs_relaxed::is_ignored,
            fully_connected_float_large_weights_as_inputs_relaxed::examples);
}

namespace fully_connected_float_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_float_relaxed test
#include "generated/examples/fully_connected_float_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_float_relaxed.model.cpp"
} // namespace fully_connected_float_relaxed
TEST_F(GeneratedTests, fully_connected_float_relaxed) {
    execute(fully_connected_float_relaxed::CreateModel,
            fully_connected_float_relaxed::is_ignored,
            fully_connected_float_relaxed::examples);
}

namespace fully_connected_float_weights_as_inputs_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated fully_connected_float_weights_as_inputs_relaxed test
#include "generated/examples/fully_connected_float_weights_as_inputs_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/fully_connected_float_weights_as_inputs_relaxed.model.cpp"
} // namespace fully_connected_float_weights_as_inputs_relaxed
TEST_F(GeneratedTests, fully_connected_float_weights_as_inputs_relaxed) {
    execute(fully_connected_float_weights_as_inputs_relaxed::CreateModel,
            fully_connected_float_weights_as_inputs_relaxed::is_ignored,
            fully_connected_float_weights_as_inputs_relaxed::examples);
}

namespace hashtable_lookup_float_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated hashtable_lookup_float_relaxed test
#include "generated/examples/hashtable_lookup_float_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/hashtable_lookup_float_relaxed.model.cpp"
} // namespace hashtable_lookup_float_relaxed
TEST_F(GeneratedTests, hashtable_lookup_float_relaxed) {
    execute(hashtable_lookup_float_relaxed::CreateModel,
            hashtable_lookup_float_relaxed::is_ignored,
            hashtable_lookup_float_relaxed::examples);
}

namespace l2_normalization_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated l2_normalization_2_relaxed test
#include "generated/examples/l2_normalization_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/l2_normalization_2_relaxed.model.cpp"
} // namespace l2_normalization_2_relaxed
TEST_F(GeneratedTests, l2_normalization_2_relaxed) {
    execute(l2_normalization_2_relaxed::CreateModel,
            l2_normalization_2_relaxed::is_ignored,
            l2_normalization_2_relaxed::examples);
}

namespace l2_normalization_large_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated l2_normalization_large_relaxed test
#include "generated/examples/l2_normalization_large_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/l2_normalization_large_relaxed.model.cpp"
} // namespace l2_normalization_large_relaxed
TEST_F(GeneratedTests, l2_normalization_large_relaxed) {
    execute(l2_normalization_large_relaxed::CreateModel,
            l2_normalization_large_relaxed::is_ignored,
            l2_normalization_large_relaxed::examples);
}

namespace l2_normalization_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated l2_normalization_relaxed test
#include "generated/examples/l2_normalization_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/l2_normalization_relaxed.model.cpp"
} // namespace l2_normalization_relaxed
TEST_F(GeneratedTests, l2_normalization_relaxed) {
    execute(l2_normalization_relaxed::CreateModel,
            l2_normalization_relaxed::is_ignored,
            l2_normalization_relaxed::examples);
}

namespace l2_pool_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated l2_pool_float_2_relaxed test
#include "generated/examples/l2_pool_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/l2_pool_float_2_relaxed.model.cpp"
} // namespace l2_pool_float_2_relaxed
TEST_F(GeneratedTests, l2_pool_float_2_relaxed) {
    execute(l2_pool_float_2_relaxed::CreateModel,
            l2_pool_float_2_relaxed::is_ignored,
            l2_pool_float_2_relaxed::examples);
}

namespace l2_pool_float_large_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated l2_pool_float_large_relaxed test
#include "generated/examples/l2_pool_float_large_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/l2_pool_float_large_relaxed.model.cpp"
} // namespace l2_pool_float_large_relaxed
TEST_F(GeneratedTests, l2_pool_float_large_relaxed) {
    execute(l2_pool_float_large_relaxed::CreateModel,
            l2_pool_float_large_relaxed::is_ignored,
            l2_pool_float_large_relaxed::examples);
}

namespace l2_pool_float_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated l2_pool_float_relaxed test
#include "generated/examples/l2_pool_float_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/l2_pool_float_relaxed.model.cpp"
} // namespace l2_pool_float_relaxed
TEST_F(GeneratedTests, l2_pool_float_relaxed) {
    execute(l2_pool_float_relaxed::CreateModel,
            l2_pool_float_relaxed::is_ignored,
            l2_pool_float_relaxed::examples);
}

namespace local_response_norm_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated local_response_norm_float_1_relaxed test
#include "generated/examples/local_response_norm_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/local_response_norm_float_1_relaxed.model.cpp"
} // namespace local_response_norm_float_1_relaxed
TEST_F(GeneratedTests, local_response_norm_float_1_relaxed) {
    execute(local_response_norm_float_1_relaxed::CreateModel,
            local_response_norm_float_1_relaxed::is_ignored,
            local_response_norm_float_1_relaxed::examples);
}

namespace local_response_norm_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated local_response_norm_float_2_relaxed test
#include "generated/examples/local_response_norm_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/local_response_norm_float_2_relaxed.model.cpp"
} // namespace local_response_norm_float_2_relaxed
TEST_F(GeneratedTests, local_response_norm_float_2_relaxed) {
    execute(local_response_norm_float_2_relaxed::CreateModel,
            local_response_norm_float_2_relaxed::is_ignored,
            local_response_norm_float_2_relaxed::examples);
}

namespace local_response_norm_float_3_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated local_response_norm_float_3_relaxed test
#include "generated/examples/local_response_norm_float_3_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/local_response_norm_float_3_relaxed.model.cpp"
} // namespace local_response_norm_float_3_relaxed
TEST_F(GeneratedTests, local_response_norm_float_3_relaxed) {
    execute(local_response_norm_float_3_relaxed::CreateModel,
            local_response_norm_float_3_relaxed::is_ignored,
            local_response_norm_float_3_relaxed::examples);
}

namespace local_response_norm_float_4_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated local_response_norm_float_4_relaxed test
#include "generated/examples/local_response_norm_float_4_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/local_response_norm_float_4_relaxed.model.cpp"
} // namespace local_response_norm_float_4_relaxed
TEST_F(GeneratedTests, local_response_norm_float_4_relaxed) {
    execute(local_response_norm_float_4_relaxed::CreateModel,
            local_response_norm_float_4_relaxed::is_ignored,
            local_response_norm_float_4_relaxed::examples);
}

namespace logistic_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated logistic_float_1_relaxed test
#include "generated/examples/logistic_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/logistic_float_1_relaxed.model.cpp"
} // namespace logistic_float_1_relaxed
TEST_F(GeneratedTests, logistic_float_1_relaxed) {
    execute(logistic_float_1_relaxed::CreateModel,
            logistic_float_1_relaxed::is_ignored,
            logistic_float_1_relaxed::examples);
}

namespace logistic_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated logistic_float_2_relaxed test
#include "generated/examples/logistic_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/logistic_float_2_relaxed.model.cpp"
} // namespace logistic_float_2_relaxed
TEST_F(GeneratedTests, logistic_float_2_relaxed) {
    execute(logistic_float_2_relaxed::CreateModel,
            logistic_float_2_relaxed::is_ignored,
            logistic_float_2_relaxed::examples);
}

namespace lsh_projection_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lsh_projection_2_relaxed test
#include "generated/examples/lsh_projection_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lsh_projection_2_relaxed.model.cpp"
} // namespace lsh_projection_2_relaxed
TEST_F(GeneratedTests, lsh_projection_2_relaxed) {
    execute(lsh_projection_2_relaxed::CreateModel,
            lsh_projection_2_relaxed::is_ignored,
            lsh_projection_2_relaxed::examples);
}

namespace lsh_projection_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lsh_projection_relaxed test
#include "generated/examples/lsh_projection_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lsh_projection_relaxed.model.cpp"
} // namespace lsh_projection_relaxed
TEST_F(GeneratedTests, lsh_projection_relaxed) {
    execute(lsh_projection_relaxed::CreateModel,
            lsh_projection_relaxed::is_ignored,
            lsh_projection_relaxed::examples);
}

namespace lsh_projection_weights_as_inputs_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lsh_projection_weights_as_inputs_relaxed test
#include "generated/examples/lsh_projection_weights_as_inputs_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lsh_projection_weights_as_inputs_relaxed.model.cpp"
} // namespace lsh_projection_weights_as_inputs_relaxed
TEST_F(GeneratedTests, lsh_projection_weights_as_inputs_relaxed) {
    execute(lsh_projection_weights_as_inputs_relaxed::CreateModel,
            lsh_projection_weights_as_inputs_relaxed::is_ignored,
            lsh_projection_weights_as_inputs_relaxed::examples);
}

namespace lstm2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lstm2_relaxed test
#include "generated/examples/lstm2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lstm2_relaxed.model.cpp"
} // namespace lstm2_relaxed
TEST_F(GeneratedTests, lstm2_relaxed) {
    execute(lstm2_relaxed::CreateModel,
            lstm2_relaxed::is_ignored,
            lstm2_relaxed::examples);
}

namespace lstm2_state2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lstm2_state2_relaxed test
#include "generated/examples/lstm2_state2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lstm2_state2_relaxed.model.cpp"
} // namespace lstm2_state2_relaxed
TEST_F(GeneratedTests, lstm2_state2_relaxed) {
    execute(lstm2_state2_relaxed::CreateModel,
            lstm2_state2_relaxed::is_ignored,
            lstm2_state2_relaxed::examples);
}

namespace lstm2_state_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lstm2_state_relaxed test
#include "generated/examples/lstm2_state_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lstm2_state_relaxed.model.cpp"
} // namespace lstm2_state_relaxed
TEST_F(GeneratedTests, lstm2_state_relaxed) {
    execute(lstm2_state_relaxed::CreateModel,
            lstm2_state_relaxed::is_ignored,
            lstm2_state_relaxed::examples);
}

namespace lstm3_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lstm3_relaxed test
#include "generated/examples/lstm3_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lstm3_relaxed.model.cpp"
} // namespace lstm3_relaxed
TEST_F(GeneratedTests, lstm3_relaxed) {
    execute(lstm3_relaxed::CreateModel,
            lstm3_relaxed::is_ignored,
            lstm3_relaxed::examples);
}

namespace lstm3_state2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lstm3_state2_relaxed test
#include "generated/examples/lstm3_state2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lstm3_state2_relaxed.model.cpp"
} // namespace lstm3_state2_relaxed
TEST_F(GeneratedTests, lstm3_state2_relaxed) {
    execute(lstm3_state2_relaxed::CreateModel,
            lstm3_state2_relaxed::is_ignored,
            lstm3_state2_relaxed::examples);
}

namespace lstm3_state3_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lstm3_state3_relaxed test
#include "generated/examples/lstm3_state3_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lstm3_state3_relaxed.model.cpp"
} // namespace lstm3_state3_relaxed
TEST_F(GeneratedTests, lstm3_state3_relaxed) {
    execute(lstm3_state3_relaxed::CreateModel,
            lstm3_state3_relaxed::is_ignored,
            lstm3_state3_relaxed::examples);
}

namespace lstm3_state_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lstm3_state_relaxed test
#include "generated/examples/lstm3_state_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lstm3_state_relaxed.model.cpp"
} // namespace lstm3_state_relaxed
TEST_F(GeneratedTests, lstm3_state_relaxed) {
    execute(lstm3_state_relaxed::CreateModel,
            lstm3_state_relaxed::is_ignored,
            lstm3_state_relaxed::examples);
}

namespace lstm_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lstm_relaxed test
#include "generated/examples/lstm_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lstm_relaxed.model.cpp"
} // namespace lstm_relaxed
TEST_F(GeneratedTests, lstm_relaxed) {
    execute(lstm_relaxed::CreateModel,
            lstm_relaxed::is_ignored,
            lstm_relaxed::examples);
}

namespace lstm_state2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lstm_state2_relaxed test
#include "generated/examples/lstm_state2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lstm_state2_relaxed.model.cpp"
} // namespace lstm_state2_relaxed
TEST_F(GeneratedTests, lstm_state2_relaxed) {
    execute(lstm_state2_relaxed::CreateModel,
            lstm_state2_relaxed::is_ignored,
            lstm_state2_relaxed::examples);
}

namespace lstm_state_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated lstm_state_relaxed test
#include "generated/examples/lstm_state_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/lstm_state_relaxed.model.cpp"
} // namespace lstm_state_relaxed
TEST_F(GeneratedTests, lstm_state_relaxed) {
    execute(lstm_state_relaxed::CreateModel,
            lstm_state_relaxed::is_ignored,
            lstm_state_relaxed::examples);
}

namespace max_pool_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated max_pool_float_1_relaxed test
#include "generated/examples/max_pool_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/max_pool_float_1_relaxed.model.cpp"
} // namespace max_pool_float_1_relaxed
TEST_F(GeneratedTests, max_pool_float_1_relaxed) {
    execute(max_pool_float_1_relaxed::CreateModel,
            max_pool_float_1_relaxed::is_ignored,
            max_pool_float_1_relaxed::examples);
}

namespace max_pool_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated max_pool_float_2_relaxed test
#include "generated/examples/max_pool_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/max_pool_float_2_relaxed.model.cpp"
} // namespace max_pool_float_2_relaxed
TEST_F(GeneratedTests, max_pool_float_2_relaxed) {
    execute(max_pool_float_2_relaxed::CreateModel,
            max_pool_float_2_relaxed::is_ignored,
            max_pool_float_2_relaxed::examples);
}

namespace max_pool_float_3_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated max_pool_float_3_relaxed test
#include "generated/examples/max_pool_float_3_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/max_pool_float_3_relaxed.model.cpp"
} // namespace max_pool_float_3_relaxed
TEST_F(GeneratedTests, max_pool_float_3_relaxed) {
    execute(max_pool_float_3_relaxed::CreateModel,
            max_pool_float_3_relaxed::is_ignored,
            max_pool_float_3_relaxed::examples);
}

namespace max_pool_float_4_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated max_pool_float_4_relaxed test
#include "generated/examples/max_pool_float_4_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/max_pool_float_4_relaxed.model.cpp"
} // namespace max_pool_float_4_relaxed
TEST_F(GeneratedTests, max_pool_float_4_relaxed) {
    execute(max_pool_float_4_relaxed::CreateModel,
            max_pool_float_4_relaxed::is_ignored,
            max_pool_float_4_relaxed::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_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated mean_float_1_relaxed test
#include "generated/examples/mean_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/mean_float_1_relaxed.model.cpp"
} // namespace mean_float_1_relaxed
TEST_F(GeneratedTests, mean_float_1_relaxed) {
    execute(mean_float_1_relaxed::CreateModel,
            mean_float_1_relaxed::is_ignored,
            mean_float_1_relaxed::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_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated mean_float_2_relaxed test
#include "generated/examples/mean_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/mean_float_2_relaxed.model.cpp"
} // namespace mean_float_2_relaxed
TEST_F(GeneratedTests, mean_float_2_relaxed) {
    execute(mean_float_2_relaxed::CreateModel,
            mean_float_2_relaxed::is_ignored,
            mean_float_2_relaxed::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 mean_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated mean_relaxed test
#include "generated/examples/mean_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/mean_relaxed.model.cpp"
} // namespace mean_relaxed
TEST_F(GeneratedTests, mean_relaxed) {
    execute(mean_relaxed::CreateModel,
            mean_relaxed::is_ignored,
            mean_relaxed::examples);
}

namespace mobilenet_224_gender_basic_fixed_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated mobilenet_224_gender_basic_fixed_relaxed test
#include "generated/examples/mobilenet_224_gender_basic_fixed_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/mobilenet_224_gender_basic_fixed_relaxed.model.cpp"
} // namespace mobilenet_224_gender_basic_fixed_relaxed
TEST_F(GeneratedTests, mobilenet_224_gender_basic_fixed_relaxed) {
    execute(mobilenet_224_gender_basic_fixed_relaxed::CreateModel,
            mobilenet_224_gender_basic_fixed_relaxed::is_ignored,
            mobilenet_224_gender_basic_fixed_relaxed::examples);
}

namespace mul_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated mul_relaxed test
#include "generated/examples/mul_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/mul_relaxed.model.cpp"
} // namespace mul_relaxed
TEST_F(GeneratedTests, mul_relaxed) {
    execute(mul_relaxed::CreateModel,
            mul_relaxed::is_ignored,
            mul_relaxed::examples);
}

namespace mul_relu_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated mul_relu_relaxed test
#include "generated/examples/mul_relu_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/mul_relu_relaxed.model.cpp"
} // namespace mul_relu_relaxed
TEST_F(GeneratedTests, mul_relu_relaxed) {
    execute(mul_relu_relaxed::CreateModel,
            mul_relu_relaxed::is_ignored,
            mul_relu_relaxed::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_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated pad_float_1_relaxed test
#include "generated/examples/pad_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/pad_float_1_relaxed.model.cpp"
} // namespace pad_float_1_relaxed
TEST_F(GeneratedTests, pad_float_1_relaxed) {
    execute(pad_float_1_relaxed::CreateModel,
            pad_float_1_relaxed::is_ignored,
            pad_float_1_relaxed::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 pad_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated pad_relaxed test
#include "generated/examples/pad_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/pad_relaxed.model.cpp"
} // namespace pad_relaxed
TEST_F(GeneratedTests, pad_relaxed) {
    execute(pad_relaxed::CreateModel,
            pad_relaxed::is_ignored,
            pad_relaxed::examples);
}

namespace relu1_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated relu1_float_1_relaxed test
#include "generated/examples/relu1_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/relu1_float_1_relaxed.model.cpp"
} // namespace relu1_float_1_relaxed
TEST_F(GeneratedTests, relu1_float_1_relaxed) {
    execute(relu1_float_1_relaxed::CreateModel,
            relu1_float_1_relaxed::is_ignored,
            relu1_float_1_relaxed::examples);
}

namespace relu1_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated relu1_float_2_relaxed test
#include "generated/examples/relu1_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/relu1_float_2_relaxed.model.cpp"
} // namespace relu1_float_2_relaxed
TEST_F(GeneratedTests, relu1_float_2_relaxed) {
    execute(relu1_float_2_relaxed::CreateModel,
            relu1_float_2_relaxed::is_ignored,
            relu1_float_2_relaxed::examples);
}

namespace relu6_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated relu6_float_1_relaxed test
#include "generated/examples/relu6_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/relu6_float_1_relaxed.model.cpp"
} // namespace relu6_float_1_relaxed
TEST_F(GeneratedTests, relu6_float_1_relaxed) {
    execute(relu6_float_1_relaxed::CreateModel,
            relu6_float_1_relaxed::is_ignored,
            relu6_float_1_relaxed::examples);
}

namespace relu6_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated relu6_float_2_relaxed test
#include "generated/examples/relu6_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/relu6_float_2_relaxed.model.cpp"
} // namespace relu6_float_2_relaxed
TEST_F(GeneratedTests, relu6_float_2_relaxed) {
    execute(relu6_float_2_relaxed::CreateModel,
            relu6_float_2_relaxed::is_ignored,
            relu6_float_2_relaxed::examples);
}

namespace relu_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated relu_float_1_relaxed test
#include "generated/examples/relu_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/relu_float_1_relaxed.model.cpp"
} // namespace relu_float_1_relaxed
TEST_F(GeneratedTests, relu_float_1_relaxed) {
    execute(relu_float_1_relaxed::CreateModel,
            relu_float_1_relaxed::is_ignored,
            relu_float_1_relaxed::examples);
}

namespace relu_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated relu_float_2_relaxed test
#include "generated/examples/relu_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/relu_float_2_relaxed.model.cpp"
} // namespace relu_float_2_relaxed
TEST_F(GeneratedTests, relu_float_2_relaxed) {
    execute(relu_float_2_relaxed::CreateModel,
            relu_float_2_relaxed::is_ignored,
            relu_float_2_relaxed::examples);
}

namespace reshape_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated reshape_relaxed test
#include "generated/examples/reshape_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/reshape_relaxed.model.cpp"
} // namespace reshape_relaxed
TEST_F(GeneratedTests, reshape_relaxed) {
    execute(reshape_relaxed::CreateModel,
            reshape_relaxed::is_ignored,
            reshape_relaxed::examples);
}

namespace reshape_weights_as_inputs_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated reshape_weights_as_inputs_relaxed test
#include "generated/examples/reshape_weights_as_inputs_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/reshape_weights_as_inputs_relaxed.model.cpp"
} // namespace reshape_weights_as_inputs_relaxed
TEST_F(GeneratedTests, reshape_weights_as_inputs_relaxed) {
    execute(reshape_weights_as_inputs_relaxed::CreateModel,
            reshape_weights_as_inputs_relaxed::is_ignored,
            reshape_weights_as_inputs_relaxed::examples);
}

namespace resize_bilinear_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated resize_bilinear_2_relaxed test
#include "generated/examples/resize_bilinear_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/resize_bilinear_2_relaxed.model.cpp"
} // namespace resize_bilinear_2_relaxed
TEST_F(GeneratedTests, resize_bilinear_2_relaxed) {
    execute(resize_bilinear_2_relaxed::CreateModel,
            resize_bilinear_2_relaxed::is_ignored,
            resize_bilinear_2_relaxed::examples);
}

namespace resize_bilinear_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated resize_bilinear_relaxed test
#include "generated/examples/resize_bilinear_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/resize_bilinear_relaxed.model.cpp"
} // namespace resize_bilinear_relaxed
TEST_F(GeneratedTests, resize_bilinear_relaxed) {
    execute(resize_bilinear_relaxed::CreateModel,
            resize_bilinear_relaxed::is_ignored,
            resize_bilinear_relaxed::examples);
}

namespace rnn_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated rnn_relaxed test
#include "generated/examples/rnn_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/rnn_relaxed.model.cpp"
} // namespace rnn_relaxed
TEST_F(GeneratedTests, rnn_relaxed) {
    execute(rnn_relaxed::CreateModel,
            rnn_relaxed::is_ignored,
            rnn_relaxed::examples);
}

namespace rnn_state_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated rnn_state_relaxed test
#include "generated/examples/rnn_state_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/rnn_state_relaxed.model.cpp"
} // namespace rnn_state_relaxed
TEST_F(GeneratedTests, rnn_state_relaxed) {
    execute(rnn_state_relaxed::CreateModel,
            rnn_state_relaxed::is_ignored,
            rnn_state_relaxed::examples);
}

namespace softmax_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated softmax_float_1_relaxed test
#include "generated/examples/softmax_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/softmax_float_1_relaxed.model.cpp"
} // namespace softmax_float_1_relaxed
TEST_F(GeneratedTests, softmax_float_1_relaxed) {
    execute(softmax_float_1_relaxed::CreateModel,
            softmax_float_1_relaxed::is_ignored,
            softmax_float_1_relaxed::examples);
}

namespace softmax_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated softmax_float_2_relaxed test
#include "generated/examples/softmax_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/softmax_float_2_relaxed.model.cpp"
} // namespace softmax_float_2_relaxed
TEST_F(GeneratedTests, softmax_float_2_relaxed) {
    execute(softmax_float_2_relaxed::CreateModel,
            softmax_float_2_relaxed::is_ignored,
            softmax_float_2_relaxed::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_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated space_to_batch_float_1_relaxed test
#include "generated/examples/space_to_batch_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/space_to_batch_float_1_relaxed.model.cpp"
} // namespace space_to_batch_float_1_relaxed
TEST_F(GeneratedTests, space_to_batch_float_1_relaxed) {
    execute(space_to_batch_float_1_relaxed::CreateModel,
            space_to_batch_float_1_relaxed::is_ignored,
            space_to_batch_float_1_relaxed::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_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated space_to_batch_float_2_relaxed test
#include "generated/examples/space_to_batch_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/space_to_batch_float_2_relaxed.model.cpp"
} // namespace space_to_batch_float_2_relaxed
TEST_F(GeneratedTests, space_to_batch_float_2_relaxed) {
    execute(space_to_batch_float_2_relaxed::CreateModel,
            space_to_batch_float_2_relaxed::is_ignored,
            space_to_batch_float_2_relaxed::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_float_3_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated space_to_batch_float_3_relaxed test
#include "generated/examples/space_to_batch_float_3_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/space_to_batch_float_3_relaxed.model.cpp"
} // namespace space_to_batch_float_3_relaxed
TEST_F(GeneratedTests, space_to_batch_float_3_relaxed) {
    execute(space_to_batch_float_3_relaxed::CreateModel,
            space_to_batch_float_3_relaxed::is_ignored,
            space_to_batch_float_3_relaxed::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 space_to_batch_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated space_to_batch_relaxed test
#include "generated/examples/space_to_batch_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/space_to_batch_relaxed.model.cpp"
} // namespace space_to_batch_relaxed
TEST_F(GeneratedTests, space_to_batch_relaxed) {
    execute(space_to_batch_relaxed::CreateModel,
            space_to_batch_relaxed::is_ignored,
            space_to_batch_relaxed::examples);
}

namespace space_to_depth_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated space_to_depth_float_1_relaxed test
#include "generated/examples/space_to_depth_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/space_to_depth_float_1_relaxed.model.cpp"
} // namespace space_to_depth_float_1_relaxed
TEST_F(GeneratedTests, space_to_depth_float_1_relaxed) {
    execute(space_to_depth_float_1_relaxed::CreateModel,
            space_to_depth_float_1_relaxed::is_ignored,
            space_to_depth_float_1_relaxed::examples);
}

namespace space_to_depth_float_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated space_to_depth_float_2_relaxed test
#include "generated/examples/space_to_depth_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/space_to_depth_float_2_relaxed.model.cpp"
} // namespace space_to_depth_float_2_relaxed
TEST_F(GeneratedTests, space_to_depth_float_2_relaxed) {
    execute(space_to_depth_float_2_relaxed::CreateModel,
            space_to_depth_float_2_relaxed::is_ignored,
            space_to_depth_float_2_relaxed::examples);
}

namespace space_to_depth_float_3_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated space_to_depth_float_3_relaxed test
#include "generated/examples/space_to_depth_float_3_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/space_to_depth_float_3_relaxed.model.cpp"
} // namespace space_to_depth_float_3_relaxed
TEST_F(GeneratedTests, space_to_depth_float_3_relaxed) {
    execute(space_to_depth_float_3_relaxed::CreateModel,
            space_to_depth_float_3_relaxed::is_ignored,
            space_to_depth_float_3_relaxed::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_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated squeeze_float_1_relaxed test
#include "generated/examples/squeeze_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/squeeze_float_1_relaxed.model.cpp"
} // namespace squeeze_float_1_relaxed
TEST_F(GeneratedTests, squeeze_float_1_relaxed) {
    execute(squeeze_float_1_relaxed::CreateModel,
            squeeze_float_1_relaxed::is_ignored,
            squeeze_float_1_relaxed::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 squeeze_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated squeeze_relaxed test
#include "generated/examples/squeeze_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/squeeze_relaxed.model.cpp"
} // namespace squeeze_relaxed
TEST_F(GeneratedTests, squeeze_relaxed) {
    execute(squeeze_relaxed::CreateModel,
            squeeze_relaxed::is_ignored,
            squeeze_relaxed::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_10_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated strided_slice_float_10_relaxed test
#include "generated/examples/strided_slice_float_10_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/strided_slice_float_10_relaxed.model.cpp"
} // namespace strided_slice_float_10_relaxed
TEST_F(GeneratedTests, strided_slice_float_10_relaxed) {
    execute(strided_slice_float_10_relaxed::CreateModel,
            strided_slice_float_10_relaxed::is_ignored,
            strided_slice_float_10_relaxed::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_11_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated strided_slice_float_11_relaxed test
#include "generated/examples/strided_slice_float_11_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/strided_slice_float_11_relaxed.model.cpp"
} // namespace strided_slice_float_11_relaxed
TEST_F(GeneratedTests, strided_slice_float_11_relaxed) {
    execute(strided_slice_float_11_relaxed::CreateModel,
            strided_slice_float_11_relaxed::is_ignored,
            strided_slice_float_11_relaxed::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_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated strided_slice_float_1_relaxed test
#include "generated/examples/strided_slice_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/strided_slice_float_1_relaxed.model.cpp"
} // namespace strided_slice_float_1_relaxed
TEST_F(GeneratedTests, strided_slice_float_1_relaxed) {
    execute(strided_slice_float_1_relaxed::CreateModel,
            strided_slice_float_1_relaxed::is_ignored,
            strided_slice_float_1_relaxed::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_2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated strided_slice_float_2_relaxed test
#include "generated/examples/strided_slice_float_2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/strided_slice_float_2_relaxed.model.cpp"
} // namespace strided_slice_float_2_relaxed
TEST_F(GeneratedTests, strided_slice_float_2_relaxed) {
    execute(strided_slice_float_2_relaxed::CreateModel,
            strided_slice_float_2_relaxed::is_ignored,
            strided_slice_float_2_relaxed::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_3_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated strided_slice_float_3_relaxed test
#include "generated/examples/strided_slice_float_3_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/strided_slice_float_3_relaxed.model.cpp"
} // namespace strided_slice_float_3_relaxed
TEST_F(GeneratedTests, strided_slice_float_3_relaxed) {
    execute(strided_slice_float_3_relaxed::CreateModel,
            strided_slice_float_3_relaxed::is_ignored,
            strided_slice_float_3_relaxed::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_4_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated strided_slice_float_4_relaxed test
#include "generated/examples/strided_slice_float_4_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/strided_slice_float_4_relaxed.model.cpp"
} // namespace strided_slice_float_4_relaxed
TEST_F(GeneratedTests, strided_slice_float_4_relaxed) {
    execute(strided_slice_float_4_relaxed::CreateModel,
            strided_slice_float_4_relaxed::is_ignored,
            strided_slice_float_4_relaxed::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_5_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated strided_slice_float_5_relaxed test
#include "generated/examples/strided_slice_float_5_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/strided_slice_float_5_relaxed.model.cpp"
} // namespace strided_slice_float_5_relaxed
TEST_F(GeneratedTests, strided_slice_float_5_relaxed) {
    execute(strided_slice_float_5_relaxed::CreateModel,
            strided_slice_float_5_relaxed::is_ignored,
            strided_slice_float_5_relaxed::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_6_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated strided_slice_float_6_relaxed test
#include "generated/examples/strided_slice_float_6_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/strided_slice_float_6_relaxed.model.cpp"
} // namespace strided_slice_float_6_relaxed
TEST_F(GeneratedTests, strided_slice_float_6_relaxed) {
    execute(strided_slice_float_6_relaxed::CreateModel,
            strided_slice_float_6_relaxed::is_ignored,
            strided_slice_float_6_relaxed::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_7_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated strided_slice_float_7_relaxed test
#include "generated/examples/strided_slice_float_7_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/strided_slice_float_7_relaxed.model.cpp"
} // namespace strided_slice_float_7_relaxed
TEST_F(GeneratedTests, strided_slice_float_7_relaxed) {
    execute(strided_slice_float_7_relaxed::CreateModel,
            strided_slice_float_7_relaxed::is_ignored,
            strided_slice_float_7_relaxed::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_8_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated strided_slice_float_8_relaxed test
#include "generated/examples/strided_slice_float_8_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/strided_slice_float_8_relaxed.model.cpp"
} // namespace strided_slice_float_8_relaxed
TEST_F(GeneratedTests, strided_slice_float_8_relaxed) {
    execute(strided_slice_float_8_relaxed::CreateModel,
            strided_slice_float_8_relaxed::is_ignored,
            strided_slice_float_8_relaxed::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_float_9_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated strided_slice_float_9_relaxed test
#include "generated/examples/strided_slice_float_9_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/strided_slice_float_9_relaxed.model.cpp"
} // namespace strided_slice_float_9_relaxed
TEST_F(GeneratedTests, strided_slice_float_9_relaxed) {
    execute(strided_slice_float_9_relaxed::CreateModel,
            strided_slice_float_9_relaxed::is_ignored,
            strided_slice_float_9_relaxed::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 strided_slice_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated strided_slice_relaxed test
#include "generated/examples/strided_slice_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/strided_slice_relaxed.model.cpp"
} // namespace strided_slice_relaxed
TEST_F(GeneratedTests, strided_slice_relaxed) {
    execute(strided_slice_relaxed::CreateModel,
            strided_slice_relaxed::is_ignored,
            strided_slice_relaxed::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_broadcast_float_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated sub_broadcast_float_relaxed test
#include "generated/examples/sub_broadcast_float_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/sub_broadcast_float_relaxed.model.cpp"
} // namespace sub_broadcast_float_relaxed
TEST_F(GeneratedTests, sub_broadcast_float_relaxed) {
    execute(sub_broadcast_float_relaxed::CreateModel,
            sub_broadcast_float_relaxed::is_ignored,
            sub_broadcast_float_relaxed::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 sub_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated sub_relaxed test
#include "generated/examples/sub_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/sub_relaxed.model.cpp"
} // namespace sub_relaxed
TEST_F(GeneratedTests, sub_relaxed) {
    execute(sub_relaxed::CreateModel,
            sub_relaxed::is_ignored,
            sub_relaxed::examples);
}

namespace svdf2_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated svdf2_relaxed test
#include "generated/examples/svdf2_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/svdf2_relaxed.model.cpp"
} // namespace svdf2_relaxed
TEST_F(GeneratedTests, svdf2_relaxed) {
    execute(svdf2_relaxed::CreateModel,
            svdf2_relaxed::is_ignored,
            svdf2_relaxed::examples);
}

namespace svdf_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated svdf_relaxed test
#include "generated/examples/svdf_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/svdf_relaxed.model.cpp"
} // namespace svdf_relaxed
TEST_F(GeneratedTests, svdf_relaxed) {
    execute(svdf_relaxed::CreateModel,
            svdf_relaxed::is_ignored,
            svdf_relaxed::examples);
}

namespace svdf_state_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated svdf_state_relaxed test
#include "generated/examples/svdf_state_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/svdf_state_relaxed.model.cpp"
} // namespace svdf_state_relaxed
TEST_F(GeneratedTests, svdf_state_relaxed) {
    execute(svdf_state_relaxed::CreateModel,
            svdf_state_relaxed::is_ignored,
            svdf_state_relaxed::examples);
}

namespace tanh_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated tanh_relaxed test
#include "generated/examples/tanh_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/tanh_relaxed.model.cpp"
} // namespace tanh_relaxed
TEST_F(GeneratedTests, tanh_relaxed) {
    execute(tanh_relaxed::CreateModel,
            tanh_relaxed::is_ignored,
            tanh_relaxed::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_float_1_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated transpose_float_1_relaxed test
#include "generated/examples/transpose_float_1_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/transpose_float_1_relaxed.model.cpp"
} // namespace transpose_float_1_relaxed
TEST_F(GeneratedTests, transpose_float_1_relaxed) {
    execute(transpose_float_1_relaxed::CreateModel,
            transpose_float_1_relaxed::is_ignored,
            transpose_float_1_relaxed::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 transpose_relaxed {
std::vector<MixedTypedExample> examples = {
// Generated transpose_relaxed test
#include "generated/examples/transpose_relaxed.example.cpp"
};
// Generated model constructor
#include "generated/models/transpose_relaxed.model.cpp"
} // namespace transpose_relaxed
TEST_F(GeneratedTests, transpose_relaxed) {
    execute(transpose_relaxed::CreateModel,
            transpose_relaxed::is_ignored,
            transpose_relaxed::examples);
}